SÉCURITÉ APPLICATIVE

M1-SSI
2019 - 2020
 RÉVERSE ENGINEERING / RÉTRO-INGÉNIERIE
• L'étude et l'analyse d'un système pour en déduire son fonctionnement
interne.
• Ce n’est pas propre à l’informatique
• Dans le domaine informatique, faire du reverse revient souvent à utiliser des
outils d'analyse comme le désassembleur ou le décompilateur dans le cadre
d'analyse en boîte blanche.
• On retrouve également des outils permettant d'analyser les entrées/sorties
d'un programme en sniffant le réseau comme Wireshark,
 OBJECTIFS
• Il peut être utilisé pour comprendre en détail le fonctionnement d'un logiciel,
• Améliorer la sécurité d'un logiciel (recherche de failles, étude d'un malware,
...)
• Permettre de contourner les protections logiciels (numéro de licence, etc...),
• Reproduire le comportement d'un logiciel en outrepassant les DRM et
restrictions des logiciels propriétaires.
 ASSEMBLEUR
• Les applications les plus bas niveaux (BIOS, firmwares, systèmes
d’exploitation, jeux pour consoles archaïques, applications MS-DOS, etc.)
sont généralement largement écrites en assembleur.
• Dans ce cas, il n’y a guère d’alternatives : il est strictement nécessaire de
connaître très finement l’architecture de la plateforme matérielle cible, ainsi
que les instructions du processeur réservées aux opérations bas niveau
(initialisation matérielle, etc.).
 BYTECODE
• Plutôt que de livrer des applications compilées pour un processeur existant,
certains environnements de développement compilent dans un langage
intermédiaire de haut niveau, appelé « bytecode ».
• Un environnement d’exécution doit être fourni pour chaque plateforme
matérielle sur laquelle doit s’exécuter ce langage intermédiaire.
• on peut citer comme environnement Flash ActionScript, Visual Basic 6 et son
P-Code, les langages de script comme Python (fichiers PYC/PYO), mais aussi
… les protections logicielles.
 NOTIONS DE BASE
• Le langage binaire
• L’octet
• Le mot double mot
• Les registres processeurs
• EAX, EBX, ECX et EDX sont des registres 32 bits. Ils contiennent
• AX, BX, CX et DX dans les 16 bits de poids faible. Ils contiennent
• AH, HB, CH et DH dans les 08 bits de poids fort et
• AL, BL, CL et DL dans les 08 bits de poids faible
• Les registres EAX, EBX, ECX et EDX sont disponibles qu’en mode protégé
• Mov eax, 10100101010010101001010101101101b
• Mov ax, 1011100101010101b
• Mov al, 10110101b
• Mov bl,al
• Conversion binaire décimal et inversement
• L’hexadécimal utilise une base 16 [0..9 et A..F]
• Passage de du binaire à l’hexadécimal et inversement
• F54Bh= 1111 0101 0100 1011b
• Exp
• Mov EAX, 19h
• Add EAX, 21h
• Mov EBX, EAX
• EAX, EBX, ECX et EDX sont les registres de travail.
• EDI et ESI sont utilisés principalement pour des instructions d'adressage, mais
peuvent aussi servir de registres de travail.
• EBP et ESP sont des registres de pile. ESP pointe vers le sommet de la pile. EBP
permet de travailler dans la pile sans devoir utiliser ESP qu'il ne vaut mieux
pas modifier pour de pas avoir de problèmes d'alignements de la pile.
• EIP désigne l'adresse de l'instruction en cours d'éxecution.
COMMENT TESTER UN PROGRAMME ?
 OSSATURE D’UN PROGRAMME ASSEMBLEUR
• #include ‘’asm_io.inc’’
• Segment .data // les données initialisées sont placées dans ce segment de données
• Segment .bas // les données non initialisées sont placées dans le segment bas
• Segment .text
• Global _asm_main
• _asm_main:
• Enter 0,0
• Pusha
• // votre code doit être placé ici
• Popa
• Mov eax, 0
• Leave
• ret
• Une fois le programme écrit il est enregistré avec l’extension asm esp a.asm
• L’assemblage du code se fait via l’instruction nasm –f format a.asm
• Format prend l’un de des valeurs coff, elf, obj ou win32 selon le compilateur
utilisé
• Pour cette partie du cours le programme assmebleur sera lancé à partir d’un
programme en C
• Int main()
• { Int ret_status;
• Ret_status=_asm_main();
• Return ret_status; }
• Compiler : gcc –c progC.c
• Lier : gcc –o premier progC.o premier.o asm_io.o
• %include ‘’asm_io.inc ’’ • Call print_string
• Segment .data • Call read_int
• Prompt .data • Mov [nbr], EAX
• Prompt1 db « entrer un nombre : »,0 • Mov EAX, prompt2
• Prompt2 db « entrer un deuxieme • Call print_string
nombre : »,0
• Call read_int
• Prompt3 db « le resultat est : », 0
• Add EAX, [nbr]
• Segment .bss • Mov EBX, EAX
• Nbr resb 1
• Mov EAX, prompt3
• Segment .text
• Call print_string
• global _asm_main • Mov EAX, EBX
• _asm_main:
• Call print_int
• Enter 0,0
• Popa
• Pusha • Mov EAX,0
• Mov EAX, prompt1
• Leave Ret
 COMPARAISON
• CMP op1, OP2
• Le résultat de l’opération n’est pas stocké
• Seul le registre flag est positionné
• Exp si op1=op2 le bit ZF (zéro flag) est positionné à 1
•

• Z-flag : pour Zero-flag, c’est le plus utilisé en « reversing »,il est mis 1 si le résultat d'une
instruction arithmétique a donné 0.
• O-flag : pour Overflow-flag, sert pour marquer un débordement.
• C-flag : pour Carry-flag, il est positionné si le résultat nécessite une retenue.
• S-flag :pour Sign Flag, il est positionné lorsque le résultat de l'opération est négatif.
 IF
• :if (EAX==0)
• EBX=1;
• Else EBX=2;
En assembleur :
Cmp eax,0
Jz bcl //saut vers bcl si etat du bit ZF du flag = 1
Mov ebx,2
Jmp svt // saut inconditionnel aller à svt quelque soit l’etat du registre Flag
bcl:
Mov ebx,1
Suivant :
 IF EXEMPLE 2
• If (EAX >=5) EBX=1;
• Else EBX = 2;
• En assembleur
• Cmp EAX,5
• Jge bcl
• Mov ebx, 2
• Jmp svt
• Bcl:
• Mov ebx, 1
• Svt:
 BOUCLE FOR
• Var =0;
• For (i=10; i>0 ; i--) var+=i;
• En assembleur
• Mov eax, 0
• Mov ecx, 10
• Bcl:
• Add eax, ecx
• Loop bcl
• Loop utilise le registre ECX. Pour chaque passage dans loop ECX est
décrémenté de 1 jusqu’à atteindre 0
• loope et loopz décrémente ECX et saute à l’etiquette si ECX<>0 et ZF=1
• Loopne, loopnz décrémente ECX et saute à l’étiquette si ECX<>0 et ZF=0
 BOUCLE WHILE
• While (condition) {corp de la boucle }
• En assembleur
• Bcl :
• jxx fin
• ; corp de la boucle
• jmp bcl
• Fin
• Jxx = (je, jne, jge, jle,….)
 BOUCLE DO WHILE
• Do { corp de la boucle }
• while condition
• En assembleur
• Bcl:
• corp de la boucle
• code pour positionner FLAGS suivant la condition
• jxx bcl
 DIRECTIVE %DEFINE
• A la même fonction que #define en C

• %define size 100

• %define ch1 dword [ebp+3]
• %define ch2 dword [ebp+12]

• Définition de trois variable auxquelles sont affectées des valeurs pour tout le
programme
DIRECTIVES DE DONNÉES
 EXEMPLE D’UTILISATION
• Mov a1, [L1] ; copie l’octet situé en l1dans a1
• Mov EAX, L1; EAX = l’adresse de l’octet L1
• Mov [L1], ah ; copie ah dans l’octet en L1
• Mov dword [L6], 1 stock 1 dans le double mot qui commence en L6
 LES ENTRÉES SORTIES
• Le langage assembleur ne dispose pas de bibliothèque standards
• Il doit accéder directement au matériel ou utiliser des routines de bas
niveau, généralement fournies par l’OS
• Le code assembleur peut utiliser les routines E/S de la bibliothèque standard
C
• L’utilisation d’une routine se fait en important le fichier assembleur nécessaire
• Exp %include ‘’asm_io.inc’’
 LES INTERRUPTIONS
• Int main () {
• char * string = ‘bonjour, tout le monde! ‘;
• Write (1, string, 23);
• }
• Pour réaliser la même chose en assembleur, il sera nécessaire d’utiliser une
interruption pour par exp ecrire à l’ecran ou quitter le programme (exit)
 LES INTERRUPTION – PROG ASM
• Xor eax, eax // mise à zéro • Int 0x80
• Xor ebx, ebx • Dec bl
• Xor ecx, ecx • Mov al,1
• Xor edx, edx • Int 0x80
• Jmp short string
• String;
• Code :
• Call code
• Pop ecx
• Db ‘bonjour, tout le monde! ‘
• Mov bl, 1 (0:entrée clavier, 1: S écran, 2:s
erreur)
• Mov dl, 23 // taille de la chaine
• Mov al, 4
 LES PILES
• La pile est une structure de données de type LIFO ( Last in First out ) dans
laquelle il est possible d’empiler et de dépiler des données.
• Le sommet de la pile est indiqué par le registre ESP.
• Les instructions principalement utilisées pour la manipuler sont "push" et
"pop". Elles permettent respectivement d'empiler et de dépiler.