Chiffrements par blocs  DES Introduction L'algorithme DES, Data Encryption Standard, a été créé dans les laboratoires de la firme IBM Corp. C'est un chiffrement qui transforme des blocs de 64 bits avec une clé secrète de 56 bits au moyen de permutations et de substitutions. Le DES est considéré comme étant raisonnablement sécuritaire, officiellement défini dans la publication FIPS 46-3 et il est public. La clé est en fait constituée de 64 bits, dont 56 bits sont générés aléatoirement et utilisés dans l'algorithme. Les huit autres bits peuvent être utilisés pour la détection d'erreurs (dans une transmission par exemple). Chacun des huit bits est utilisé comme bit de parité des sept groupes de 8 bits. Comme blowfish, le DES est un chiffrement Feistel. Il utilise les transformations de substitution et de transposition (chiffrement par produit). Il est aussi appelé Data Encryption Algorithm (DEA). Algorithme Pour être chiffré, un bloc subit tout d'abord une permutation initiale, puis un algorithme complexe est appliqué en fonction de la clé (calcul médian), et enfin le bloc subit une permutation finale. Cette dernière permutation est l'inverse de la permutation initiale. De cette façon, l'algorithme de chiffrement et de déchiffrement est le même. Le calcul médian dépendant de la clé peut être défini comme étant deux fonctions : une première appelée la fonction de chiffrement et une fonction de programmation de la clé. Chiffrement Programmation de la clé La fonction de programmation du bloc de 48 bits en fonction de la clé est appelée à chaque round avec en entrée, un nombre entier "n" entre 1 et 16 et le bloc de 64 bits de la clé. La sortie est le bloc clé "K" de 48 bits, ce bloc étant une sélection de bits de la clé après des permutations. Kn = PC(n,CLÉ) PC = programmation de la clé Permuation initiale Les 64 bits du bloc en entrée dans l'algorithme DES subissent la permutation initiale.  Bloc en entrée   Bloc en sortie  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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 P.I. 58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 62 54 46 38 30 22 14 6 64 56 48 40 32 24 16 8 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7 Ainsi, le premier bit du bloc résultant de la permutation initiale est le 58ème bit du bloc en entrée, le deuxième bit est le 50ème bit et ainsi de suite. Calcul médian Le calcul médian peut se résumer comme étant une fonction contenant 16 itérations identiques. Cette fonction traite deux blocs à la fois : un bloc de 32 bits, les données, et l'autre de 48 bits, la clé. Le résultat donne un bloc de 32 bits. Le bloc de donnée de 64 bits est préalablement divisé en deux blocs de 32 bits, "L" et "R" (pour "Left" et "Right"), après être passé dans la permutation initiale. Ainsi, "L" contient les bits pairs et "R" contient les bits impairs. Les 48 bits du bloc "K" (pour "Key") sont choisis à partir de la clé initiale de 64 bits. La sortie de L'R' après l'itération est définie par : L' = R R' = L XOR f(R,K) L'R' = [R][L + f(R,K)] L'entrée à la première itération du chiffrement est le bloc ayant subit la permutation initiale. À la fin, le bloc L'R' restant après la seizième itération devient le bloc de pré-sortie (avant la permutation finale). À chaque itération, un bloc "K" différent de 48 bits est choisi à partir de la clé de 64 bits. Pour "n" variant de 1 à 16, on a Ln = Rn-1 Rn = Ln-1 XOR f(Rn-1,Kn) La fonction de chiffrement "f" f reçoit le bloc "R" et le bloc "K" en entrée. La fonction E prend un bloc de 32 bits en entrée et donne un bloc de 48 bits en sortie. Les 48 bits, représentés en huit blocs de 6 bits chacun, sont obtenus en sélectionnant les bits du bloc en entrée selon le tableau suivant. 32 1 2 3 4 5 4 5 6 7 8 9 8 9 10 11 12 13 12 13 14 15 16 17 16 17 18 19 20 21 20 21 22 23 24 25 24 25 26 27 28 29 28 29 30 31 32 1 Ainsi les trois premiers bits du bloc sortant sont le 32ème, le 1er et le 2ème bit du bloc en entrée. Chacune des huit fonctions de sélection, les S-Boxes, prend un bloc de 6 bits comme entrée et donne un bloc de 4 bits en sortie. La première fonction de sélection "S1" est représentée par la table suivante S1 Ligne No. 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15     0 1 2 3 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0  7  0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13 Le bloc en entrée de 8 bits "B" est traité comme suit : le premier bit et le dernier bit du bloc unis représentent un nombre compris entre 0 et 3 en base 2, appelé Bi, alors que les 4 bits restants du milieu représentent un nombre compris entre 0 et 15 en base 2, appelé "Bj". Par exemple, si le bloc "B" est "011011" : Bi = 01 = 1 en base 10 Bj = 1101 = 13 en base 10 Ainsi, Bi étant le numéro de la ligne de S1 et Bj étant le numéro de sa colonne, le bloc de 4 bits de sortie sera "5" en base 10 , donc "0101" en base 2. Les 8 fonctions de sélection S1, S2, S3, ..., S8 traitent chacune un des 8 blocs. Ces 8 blocs sont consolidés pour former qu'un seul bloc de 32 bits, lequel sera l'entrée pour une dernière permutation dans la fonction f. La permutation "P" sur le bloc de 32 bits est représentée par la table suivante : 16 7 20 21 29 12 28 17 1 15 23 26 5 18 31 10 2 8 24 14 32 27 3 9 19 13 30 6 22 11 4 25 Le résultat est un bloc de 32 bits. À la suite des 16 rounds, le bloc de pré-sortie est L16R16. Permutation finale Le contenu du bloc de pré-sortie, est permuté une dernière fois. Cette permutation correspond à l'inverse de la permutation initiale. 40 8 48 16 56 24 64 32 39 7 47 15 55 23 63 31 38 6 46 14 54 22 62 30 37 5 45 13 53 21 61 29 36 4 44 12 52 20 60 28 35 3 43 11 51 19 59 27 34 2 42 10 50 18 58 26 33 1 41 9 49 17 57 25 Ainsi, le premier bit du bloc final est le 40ème bit du bloc précédent, le deuxième bit égale le 8ème bit, etc.. Déchiffrement La permutation finale est l'inverse de la permutation initiale. On applique exactement le même algorithme, mais à l'inverse, en tenant bien compte que chaque itération du déchiffrement traite les mêmes paires de blocs utilisées dans le chiffrement. Rn-1 = Ln Ln-1 = Rn XOR f(Ln,Kn) Maintenant R16L16 et le bloc d'entrée dans la fonction de déchiffrement, et R0L0 est le bloc de pré-sortie, avant la permutation finale. Ainsi le bloc relatif à la clé K16 est utilisé dans la première itération et K1 dans la dernière. Considérations La recherche de failles a mis en relief la possibilité qu'il pourrait exister des relations linéaires ou quasi linéaires entre le texte clair et le texte chiffré du DES. Si cette possibilité se révélait vrai, le DES serait extrêmement vulnérable face aux attaques relatives aux relations linéaires.

Démonstration  DES Clé : Cryptage Décryptage Texte à traiter Résultats  Chiffrements par blocs  DES Identification Significative: DES, utilisant des sBox va être facile à repérer, soit dans la section DATA soit dans la section TEXT: SBox1 byte 14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7 byte 0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8 byte 4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0 byte 15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13 SBox2 byte 15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10 byte 3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5 byte 0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15...  Coté Cracking...  newDES Introduction En résumé, newDES utilise une clé qui est encryptée puis utilisée pour traiter le Plain Text. A l'inverse la séquence de déchiffrement réutilisera la clé, la décryptera, avant de passer au traitement du Cipher Text dans la même routine que précedement. Le principe de newDES est identique au Data Encryption Standard mais est plus simple à implanter. A la différence de DES, il n'utilise pas de SBox, mais un rotor. push offset Key call newDES_SetEncryptKey push offset plaintext push offset ciphertext call newDES_Crypt push offset Key call newDES_SetDecryptKey push offset ciphertext push offset plaintext call newDES_Crypt A la place des blocs du DES, on trouve un rotor qui , invisible sous Wdasm, aura ce look sous IDA 004010CE db 20h,89h,EFh,BCh,66h,7Dh,DDh,48h,D4h,44h,51h,25h db 56h,EDh,93h,95h,46h,E5h,11h,7Ch,73h,CFh,21h,14h db 7Ah,8Fh,19h,D7h,33h,B7h,8Ah,8Eh,92h,D3h,6Eh,ADh... soit " 32 137 239 188 102 125 221 72 212 68 81 37 86 237 147 149" en décimal. Une petite recherche rapide sur le net en utilisant cette chaîne permet d'identifier immédiatement le mode de chiffrement newDES. Chiffrement NewDES_Crypt_Decrypt pushad xor ebx, ebx xor ecx, ecx mov esi, ptrIn mov edi, ptrOut mov eax, dword ptr [esi] mov edx, dword ptr [esi+4] mov dword ptr [edi], eax mov dword ptr [edi+4], edx mov esi, offset NewDES_internal_Key mov ebp, 8 @@: mov eax, dword ptr [edi] mov edx, dword ptr [edi+4] xor eax, dword ptr [esi] mov cl, al ;cl = B0^K mov bl, ah ;bl = B1^K xor dl, byte ptr [NewDES_rotor+ecx] xor dh, byte ptr [NewDES_rotor+ebx] ror eax, 16 ror edx, 16 mov cl, al ;cl = B2^K mov bl, ah ;bl = B3^K xor dl, byte ptr [NewDES_rotor+ecx] xor dh, byte ptr [NewDES_rotor+ebx] mov eax, dword ptr [edi] ror edx, 16 ror eax, 8 mov dword ptr [edi+4], edx add esi, 4 xor dh, dl ;dh = B5^B4 xor dl, byte ptr [esi] ;dl = B4^K mov cl, dh mov bl, dl xor ah, byte ptr [NewDES_rotor+ecx] xor al, byte ptr [NewDES_rotor+ebx] ror edx, 16 ror eax, 16 xor dx, word ptr [esi+1] mov cl, dh mov bl, dl xor ah, byte ptr [NewDES_rotor+ecx] xor al, byte ptr [NewDES_rotor+ebx] add esi, 3 ror eax, 8 dec ebp mov dword ptr [edi], eax jnz @B mov eax, dword ptr [edi] mov edx, dword ptr [edi+4] xor eax, dword ptr [esi] mov cl, al ;cl = B0^K mov bl, ah ;bl = B1^K xor dl, byte ptr [NewDES_rotor+ecx] xor dh, byte ptr [NewDES_rotor+ebx] ror eax, 16 ror edx, 16 mov cl, al ;cl = B2^K mov bl, ah ;bl = B3^K xor dl, byte ptr [NewDES_rotor+ecx] xor dh, byte ptr [NewDES_rotor+ebx] ror edx, 16 mov dword ptr [edi+4], edx popad ret  Chiffrements par blocs  RijnDael Introduction Le chiffrement a une longueur de bloc variable, une longueur de clé variable et un nombre de rounds variables. Par contre, Rijndael version "AES" est restreint à des longueurs de blocs de 128, 192 et 256 bits avec une clé fixée à 128 bits. Algorithme Comme la plupart des chiffrements par blocs modernes, le chiffrement s'effectue en deux parties : une procédure d'expansion de la clé et la fonction principale de chiffrement. Chiffrement La fonction de chiffrement se divise en trois : une transformation initiale avec la clé (l'étape "Add Round Key", bloc XOR clé), une série de rounds puis une transformation finale. Le nombre de rounds s'établit en fonction de la taille des blocs et de la clé : · 9 rounds si la taille des blocs et de la clé sont de 128 bits, · 11 rounds si la taille des blocs ou de la clé est de 192 bits (maximum), · 13 rounds si la taille des blocs ou de la clé est de 256 bits. Dans un round, quatre transformations sont appliquées au bloc à chiffrer. La première étape est appelée "Byte Sub". Chaque octet des sous-blocs est alors substitué selon une S-Box. Cette opération augmente la non-linéarité des données. Ensuite, l'étape "Shift Row" décale les bits des sous-blocs. La taille des sous-blocs dépend de la taille des blocs. Par exemple, pour des blocs de 128 bits, les sous-blocs ont une taille de 16 bits : 1 5 9 13 2 6 10 14 3 7 11 15 4 8 12 16 1 5 9 13 14 2 6 10 11 15 3 7 8 12 8 4 Cette étape augmente la diffusion des données dans le round. En troisième lieu, l'étape appelée "Mix Column" est appliquée. L'opération utilisée est la multiplication d'une matrice aux sous-blocs de 16 bits, toujours dans le cas d'un bloc de 128 bits. La matrice est représentée par 1 5 9 13 2 6 10 14 3 7 11 15 4 8 12 16 Cette étape augmente la diffusion des données entre les rounds. À noter que les octets utilisés dans la multiplication sont traités comme des polynômes plutôt que des nombres. L'étape finale est appelée "Add Round Key". Cette étape est simplement l'addition des sous-clés aux sous-blocs correspondants. Déchifffement Le déchiffrement est l'inverse du chiffrement. Identification Significative SBox 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113...

Chiffrements par blocs  IDEA Introduction Développé en 1992, le chiffrement par blocs IDEA (International Data Encryption Algorithm) utilise des blocs de 64 bits et est contrôlé par une clé de 128 bits. Malgré le fait que IDEA n'est pas un chiffrement Feistel, le déchiffrement est effectué avec la même fonction que celle utilisée dans le chiffrement. L'algorithme a innové dans son domaine en utilisant des opérations de trois groupes algébriques différents. Le processus de chiffrement est le même que pour le déchiffrement, à moins d'une utilisation de différentes sous-clés, ce qui est rare. En gros, le processus se résume à huit étapes de chiffrement identiques, les rounds, suivies d'une transformation au bloc de sortie. Contrairement au DES et à Blowfish, IDEA n'utilise aucune S-Box. L'algorithme peut être utilisé avec les modes d'opération ECB, CBC, CFB et OFB. Sa vitesse est environ la même que le DES. Algorithme Chiffrement Les opérations utilisées sont le OU exclusif, l'addition modulo 216 (65 536) et la multiplication modulo 216 + 1 (65 537, qui est un nombre premier). Le bloc de 64 bits en entrée est tout d'abord divisé en quatre blocs de 16 bits chacun. À noter que toutes les opérations algébriques utilisées dans le chiffrement fonctionnent avec des blocs de 16 bits. Un processus produit, pour chacun des 8 rounds, 6 sous-clés de 16 bits chacune selon la clé de 128 bits. Avec quatre autres clés générées pour la transformation finale à la suite des huit rounds, un total de 52 sous-clés doit être généré. Détermination des sous-clés Les 52 sous-clés générées à partir de la clé de 128 bits sont produites comme suit : La clé de 128 bits est divisée en huit blocs. Ces huit blocs sont en fait les huit premières sous-clés utilisées dans le chiffrement. La clé de 128 bits est ensuite cycliquement décalée de 25 positions et divisée en huit blocs de 16 bits. Ces huit blocs sont les huit sous-clés suivantes utilisées dans le chiffrement. Le cycle est répété jusqu'à ce que les 52 sous-clés soient toutes générées. Utilisation des sous-clés de chiffrement : Round 1 K[1] , K[2] , K[3] , K[4] , K[5] , K[6] Round 2 K[7] , K[8] , K[9] , K[10] , K[11] , K[12] Round 3 K[13] , K[14] , K[15] , K[16] , K[17] , K[18] Round 4 K[19] , K[20] , K[21] , K[22] , K[23] , K[24] Round 5 K[25] , K[26] , K[27] , K[28] , K[29] , K[30] Round 6 K[31] , K[32] , K[33] , K[34] , K[35] , K[36] Round 7 K[37] , K[38] , K[39] , K[40] , K[41] , K[42] Round 8 K[43] , K[44] , K[45] , K[46] , K[47] , K[48]     Transformation finale K[49] , K[50] , K[51] , K[52] Texte clair (64 bits) Texte chiffré (64 bits)   OU-Exclusif sur 2 blocs de 16 bits Addition modulo 216 sur 2 blocs de 16 bits Multiplication modulo 216 + 1 sur 2 blocs de 16 bits Dans le premier round, les quatre premières sous-clés sont combinées avec tout d'abord deux blocs de 16 bits du texte clair selon l'addition modulo 216, et avec deux autres blocs de texte clair en utilisant la multiplication modulo 216 + 1. Les résultats sont ensuite traités plus loin, où deux autres sous-clés sont employées et l'opération du troisième groupe algébrique, le OU exclusif bit-à-bit, est utilisée. À la fin du premier round de chiffrement, quatre valeurs de 16 bits sont produites et elles sont utilisées comme valeurs d'entrée au deuxième round de chiffrement, dans un ordre interchangé. Le même processus s'effectue dans les sept rounds de chiffrement suivants, avec des sous-clés différentes pour chaque combinaison. Les quatre blocs de 16 bits produits par le dernier round, le huitième, sont combinés avec les quatre dernières sous-clés selon l'addition modulo 216 et la multiplication modulo 216. Le résultat final forme quatre blocs chiffrés de 16 bits, donc 64 bits de texte chiffré. Il est à noter que dans la multiplication de deux blocs de 16 bits modulo 216 + 1, un bloc de 16 bits ayant tout ses bits à 0 n'est pas interprété comme ayant une valeur totale de 0 mais plutôt une valeur de 216. En équations Soient A, B, C et D quatre blocs de 16 bits et 52 sous-clé K[1] à K[52]. (· est une multiplication et + est une addition) Avant d'effectuer le premier round   A = A · K[1]   B = B + K[2]   C = C + K[3]   D = D · K[4] Round 1   E = A XOR C   F = B XOR D   E = E · K[5]   F = F + E   F = F · K[6]   E = E + F   A = F XOR A C = F XOR C   B = E XOR B D = E XOR D   Tampon = B B = C C = Tampon Répéter sept autres fois en utilisant les sous-clés suivantes : K[7] à K[12] pour le deuxième round, ..., K[43] à K[48] pour le huitième round Après le huitième round   A = A · K[49]   B = B + K[50]   C = C + K[51]   D = D · K[52] Déchiffrement Le déchiffrement s'effectue essentiellement de la même manière que le chiffrement. La seule différence est que les 52 sous-clés sont générées de façon inverse au chiffrement. Aussi les blocs de texte chiffré doivent être traités dans l'ordre inverse du chiffrement pour inverser parfaitement le processus de chiffrement. Utilisation des sous-clés de déchiffrement, selon les sous-clés de chiffrement (Ex.: Kdéchiffrement[1] = 1 / Kchiffrement[49]) : Transformation initiale      1 / K[49], - K[50], - K[51], 1 / K[52]     Round 1 K[47], K[48], 1 / K[43], - K[45], - K[44], 1 / K[46] Round 2 K[41], K[42], 1 / K[37], - K[39], - K[38], 1 / K[40] Round 3 K[35], K[36], 1 / K[31], - K[33], - K[32], 1 / K[34] Round 4 K[29], K[30], 1 / K[25], - K[27], - K[26], 1 / K[28] Round 5 K[23], K[24], 1 / K[19] , - K[21] , - K[20] , 1 / K[22] Round 6 K[17], K[18], 1 / K[13] , - K[15] , - K[14] , 1 / K[16] Round 7 K[11], K[12], 1 / K[7], - K[9], - K[8], 1 / K[10] Round 8 K[5], K[6], 1 / K[1], - K[3], - K[2], 1 / K[4] Considérations La méthode de génération des sous-clés de l'IDEA est toujours régulière et donc pourrait être une faiblesse à l'algorithme. Cependant, il est considéré comme étant hautement sécuritaire, pour résoudre IDEA avec l'attaque en force il faudrait effectuer 2128, donc 1038 opérations.

Chiffrements par blocs  Tiny Encryption Algorithm Chiffrement Tiny Encryption Algorithm Valeur de clé aléatoire Key 1   Key 2  Key 3   Key 4   Coté Cracking  TEA - Extended TEA Introduction Identifier TEA est relativement facile dans la mesure où il utilise un Delta Number : 9E3779B9h. L'algorithme TEA ou celui de l'Extended TEA ne sont pas très différents. Dans les 2 cas, l'appel aux routine de codage ou de décodage se fera ainsi: push offset _Key push offset _data call TEA_encode push offset _Key push offset _data call TEA_decode Algorithme TEA (encode) 00405586 add edx, 9E3779B9h sum += DELTA 0040558C mov eax, edi 0040558E mov ecx, eax 00405590 mov ebx, edi 00405592 shl eax, 4 00405595 shr ebx, 00405598 add eax, dword_0_4145B7 0040559E add ebx, dword_0_4145BB 004055A4 add ecx, edx 004055A6 xor ecx, eax 004055A8 xor ecx, ebx 004055AA add esi, ecx ;y += (z<<4)+a^z+sum^(z>>5)+b 004055AC mov eax, esi 004055AE mov ebx, esi 004055B0 mov ecx, esi 004055B2 shl eax, 4 004055B5 shr ebx, 5 004055B8 add eax, dword_0_4145BF 004055BE add ebx, dword_0_4145C3 004055C4 add ecx, edx 004055C6 xor ecx, eax 004055C8 xor ecx, ebx 004055CA add edi, ecx ;z += (y<<4)+c^y+sum^(y>>5)+d 004055CC dec ebp 004055CD jnz short loc_0_405586 Algorithme Extended TEA (decode) push ebp mov ebx, ptrData mov edx, 0C6EF3720h mov esi, [ebx] mov edi, [ebx+4] mov ebp, 32 loop: mov eax, esi mov ebx, esi mov ecx, esi shl eax, 4 shr ebx, 5 mov ecx, edx xor eax, ebx and ecx, 3 add eax, edi mov ebx, [Key+4*ecx] add ebx, edx xor eax, ebx add edx, 9E3779B9h add esi, eax mov ecx, edx mov eax, esi mov ebx, esi shl eax, 4 shr ebx, 5 shr ecx, 11 xor eax, ebx and ecx, 3 mov ebx, edx add eax, esi add ebx, [Key+4*ecx] xor eax, ebx add edi, eax dec ebp jnz _loop valeur significative de l'initialisation du décodage z << 4 z >> 5 (z << 4 ^ z >> 5) sum&3 [(z << 4 ^ z >> 5) + z] [(z<<4^z>>5)+z]^[sum+k[sum&3]] sum += DELTA y += [(z<<4^z>>5)+z]^[sum+k[sum&3]] z << 4 z >> 5 (y << 4 ^ y >> 5) k[sum>>11 & 3] [(y << 4 ^ y >> 5) + y] k[sum>>11 & 3] [(y<<4^y>>5)+y]^[sum+k[sum>>11&3]] z += [(y<<4^y>>5)+y]^[sum+k[sum>>11&3]]  Coté Cracking  IDEA Introduction Je n'ai pas trouvé les routines de codage/décodage vraiment significatives, rendant par la même IDEA nettement plus difficile à identifier. Le schéma général est le suivant: push offset _Key call IDEA_ExpandKey push offset _data_in push offset _data_out call IDEA_encode push offset _Key call IDEA_ExpandKey call IDEA_InvertKey push offset _Key push offset _data call IDEA_decode Algorithme IDEA (encode) Initialisation des 4 blocs 16 bits :00406F7C mov bx, [esi] :00406F7F mov cx, [esi+2] :00406F83 mov di, [esi+4] :00406F87 mov bp, [esi+6] Multiplication modulo 216 + 1 sur 2 blocs de 16 bits: :00406F9A mov ax, bx :00406F9D mul word ptr [esi] :00406FA0 sub ax, dx :00406FA3 jnz short loc_0_406FAD les OU-Exclusif sur 2 blocs de 16 bits: :00407032 xor bx, ax x1 ^= x2 :00407035 xor bp, di x4 ^= x3 :00407038 xor ax, word_0_4146B1 x2 ^= s3 :0040703F xor di, word_0_4146AF x3 ^= s2  Quelques autres...  GOST, Misty-1, SkipJack Identification Significatives GOST 28147- 89 Chiffre symétrique par blocs de 64 bits utilisant une cléde 256 bits, développé dans l’ex- Union Soviétique, qui lui aussi utilise des SBox: sbox_1 db 0E4h,0EAh,0E9h,0E2h,0EDh,0E8h,0E0h,0EEh,0E6h db 0EBh,0E1h,0ECh,0E7h,0EFh,0E5h,0E3h,0B4h,0BAh db B9h,0B2h,0BDh,0B8h,0B0h,0BEh, 0B6h,0BBh,0B1h Par contre, il semblerait qu'il y ait de "vraie" sBox, et d'autres qui le serait moins... Misty est un algorithme développé par Mitsubishi Electric après qu'ils eurent cassé DES en 1994. Ci dessous vous trouverez la table d'odentification: s7 db 01bh,032h,033h,05ah,03bh,010h,017h,054h,05bh db 01ah,072h,073h,06bh,02ch,066h,049h,01fh,024h db 013h,06ch,037h,02eh,03fh,04ah,05dh,00fh,040h skipjack est un algorithme de chiffrement avec clés de 80 bits utilisant une F-Table byte permutation f_table db 0a3h,0d7h,009h,083h,0f8h,048h,0f6h,0f4h,0b3h db 021h,015h,078h,099h,0b1h,0afh,0f9h,0e7h,02dh db 04dh,08ah,0ceh,04ch,0cah,02eh,052h,095h,0d9h

Chiffrements par blocs  Blowfish Introduction Blowfish a été conçu par Bruce Schneier en 1993 comme étant une alternative aux algorithmes existants, en étant rapide et gratuit. Blowfish est sensiblement plus rapide que le DES. Il est un chiffrement Feistel, utilisant itérativement une fonction de chiffrement 16 fois. La grandeur des blocs est de 64 bits. Il peut prendre une longueur de clé variant entre 32 bits et 448 bits. Depuis sa conception il a été grandement analysé et est aujourd'hui considéré comme étant un algorithme de chiffrement robuste. Il n'est pas breveté et son utilisation est libre et gratuite. Cet algorithme peut être optimisé dans les applications matérielles, mais il est surtout utilisé dans des logiciels. Il y a deux parties dans l'algorithme : une première partie qui manipule l'expansion de la clé et une deuxième partie qui manipule le chiffrement des données. Algorithme Expansion de la clé La première étape dans l'algorithme est de séparer la clé originale en un ensemble de sous-clés. Plus précisément, une clé (qui ne doit pas avoir plus de 448 bits) est séparée en plusieurs sous-clés totalisant 4168 octets. Il y a aussi l'initialisation d'un tableau P et de quatre S-Boxes de 32 bits chacune. Le tableau P contient 18 sous-clés de 32 bits, alors que chaque S-Box contient 256 entrées. Les étapes suivantes sont utilisées pour calculer les sous-clés : · Initialisation du tableau P et des S-Box avec une chaîne de caractères fixe (chiffres composant la constante PI). · Opération XOR entre le tableau P (et ses 18 entrées) et les bits de la clé :      P[1] XOR (1er 32 bits de la clé),      P[2] XOR (2e 32 bits de la clé),      ...      P[18] XOR (Ne 32 bits de la clé) Lorsque les bits de la clé sont épuisés, on revient au premier 32 bits. · Utilisation de l'algorithme blowfish pour chiffrer la chaîne de caractères all-zero (chaîne de caractères fixe) en utilisant les sous-clés. · La sortie est maintenant P[1] et P[2]. · Chiffrement des nouveaux P[1] et P[2] avec les sous-clés modifiées. · La sortie est maintenant P[3] et P[4]. · Répéter 521 fois les deux dernières étapes afin de calculer les nouvelles sous-clés pour le tableau P et pour les quatre S-Box. Chiffrement Algorithme Note : l'entrée de 64 bits de texte clair est notée "x" et le tableau P est noté Pi/P[i], où "i" est l'itération. Début chiffrement      Divisé x en 2 : xL et xR      For i allant de 1 à 16 faire           xL = xL XOR P[i]           xR = F(xL) XOR xR           Permuter xL et xR      End For      Permuter xL et xR      xR = xR XOR P[17]      xL = xL XOR P[18]      x = xL + xR      Retourner x Fin chiffrement La fonction F( ) Début fonction F(Entrée : xL : 32 bits de données)      Divisé xL en 4 : a, b, c, d      Retourner ((S1,a + S2,b MOD 232) XOR S3,c) + S4,d MOD 232 Fin fonction F Considérations Mettre en application l'algorithme de Blowfish semble une option pratique pour le chiffrement de donnée étant donné qu'il est destiné à être rapide, compact, simple et relativement sécuritaire et convient très bien aux applications logicielles.

Demonstration  Blowfish This is a Java applet, you need Netscape or Internet Explorer to see it.  Coté Cracking  Blowfish Introduction l'appel aux routine de chiffrement ou de déchiffrement se feront sur un schéma de ce type: push size_of_Key push offset Key call Blowfish_SetKey push offset plain_text push offset encrypted_buf call Blowfish_Encrypt push size_of_Key push offset Key call Blowfish_SetKey push offset cipher_text push offset décrypted_buff call Blowfish_Decrypt BlowFish utilisant des P-box et des S-box, celles ci, toujours les mêmes, seront facile à repérer: _data:0040C000 unk_0_40C000 db 88h ; ê ; DATA XREF: sub_0_401083+9 PBox dd 243F6A88h, 85A308d3h, 13198A2Eh, 03707344h, A4093822h .... ce qui donne, dans IDA: _data:0040C000 db 88h _data:0040C001 db 6Ah _data:0040C002 db 3Fh _data:0040C003 db 24h _data:0040C004 db D3h _data:0040C005 db 08h _data:0040C006 db A3h _data:0040C007 db 85h... SBox1 dd D1310BA6h, 98DFB5ACh, 2FFD72DBh, D01ADFB7h, B8ELADEDh... SBox2 dd 4B7A70E9h, B5B32944h, DB75092Eh, C4192623h, AD6EA6B0h... SBox3 dd E93D5A68h, 948140F7h, F64C261Ch, 94692934h, 411520F7h... SBox4 dd 3A39CE37h, D3FAF5CFh, ABC27737h, 5AC52B1Bh, 5CB0679Eh... ce qui donne, dans IDA: _data:0040C048 db A6h _data:0040C049 db 0Bh _data:0040C04A db 31h _data:0040C04B db D1h _data:0040C04C db 0ACh _data:0040C04D db 0B5h _data:0040C04E db 0DFh _data:0040C04F db 98h...  Chiffrements par blocs  TwoFish Introduction Je n'ai pas passé assez de temps sur TwoFish pour être certain de ce que je vais avancer, mais il semblerait que la table utilisée par l'algorithme puisse être crée dynamiquement. Quand ce n'est pas le cas, voici ce à quoi elle ressemble: 0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 0x9A, 0x92, 0x80, 0x78, 0xE4, 0xDD, 0xD1, 0x38, 0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C, 0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48....

Chiffrements par blocs  RC2 - RC5 - RC6 Introduction RC2, RC5 et RC6 sont des algorithmes créés par Ronald Rivest pour la RSA Security. L'acronyme "RC" signifie "Ron's Code" ou "Rivest's Cipher". RC2 Le RC2 a été conçu en 1989. Il avait été programmé pour être efficace avec les processeurs de 16 bits comme remplacement au DES. Il s'opère sur des blocs de 64 bits. La grandeur de la clé est variable, de 1 octet (8 bits) à 128 octets (1024 bits). Habituellement, l'algorithme s'applique avec une clé de 64 bits. Le procédé nouveau qu'a apporté cet algorithme a été d'offrir aux utilisateurs la possibilité de choisir la grandeur de la clé. Cette propriété est maintenant offerte dans plusieurs chiffrements par blocs, étant primordiale dans les applications commerciales. Chiffrement Il y a deux parties dans l'algorithme, soit une procédure d'expansion de la clé et une procédure de chiffrement. Ces deux parties utilisent une table de substitution (S-Box) qui spécifie une permutation aléatoire d'entiers de 0 à 255. Le chiffrement est défini en gros par 2 opérations, appelées MIX et MASH, sur 4 vecteurs de 16 bits contenant au total 64 bits de texte clair. MIX : fonction de permutations et de substitutions MIXING : 4 fonctions MIX appliquées à chacun des 4 vecteurs de 16bits.     MASH : fonction de permutations et de substitutions MASHING : 4 fonctions MASH appliquées à chacun des 4 vecteurs de 16bits. Étapes :   Initialiser les 4 vecteurs de 16 bits chacun, ils contiennent un bloc de 64 bits de texte clair.   Procéder à l'expansion de la clé : initialiser les 64 sous-clés avec la clé.   Effectuer 5 fois la fonction MIXING (5 rounds).   Effectuer 1 fois la fonction MASHING (1 round).   Effectuer 6 fois la fonction MIXING (6 rounds).   Effectuer 1 round de fonction MASHING (1 round).   Effectuer 5 fois la fonction MIXING (5 rounds).   Le texte chiffré est dans les 4 vecteurs de 16 bits. Déchiffrement Le déchiffrement est exactement l'inverse du chiffrement. RC5 Le RC5 a été conçu en 1995. Il a l'avantage d'avoir une longueur de bloc de données variable, un nombre de rounds variable et une clé de longueur variable. Ainsi, l'utilisateur a le contrôle sur le rapport entre la vitesse d'exécution et la sécurité de son chiffrement. En général, une longue clé et un nombre élevé de rounds assurent une plus grande sécurité. La taille des blocs de données pour sa part accommode différentes architectures de systèmes. La simplicité de l'algorithme du RC5 rend son implémentation facile et, le plus important, rend son analyse plus aisée. De plus, la forte utilisation des décalages de bits (appelés rotations) dans le chiffrement prévient l'usage de la cryptanalyse linéaire et différentielle. En plus du mode EBC (Electronic Code Book), le RC5 est aussi utilisé avec le mode CBC (Cipher-Block Chaining). Chiffrement Comme pour le RC2, il y a deux parties dans l'algorithme, soit une procédure d'expansion de la clé et une procédure de chiffrement. Les opérations utilisées sont l'addition modulo 2(nombre de bits des blocs) (+), le OU-Exclusif (XOR) et le décalage de bits vers la gauche (<<<). En équations : Soient K[0], K[1], ..., K[n] les sous-clés dérivées de la procédure d'expansion de la clé et A et B les deux parties d'un bloc de texte clair à chiffrer.   A = A + K[0]   B = B + K[1]   Pour i allant de 1 jusqu'au nombre de rounds             A = ((A XOR B) <<< B) + K[2i]             B = ((B XOR A) <<< A) + K[2i + 1]   Fin Pour Déchiffrement Le déchiffrement est exactement l'inverse du chiffrement. RC6 Le RC6 a été créé en 1998. Il propose des améliorations au RC5 et, comme celui-ci, est fortement dépendant de la transformation de décalage de bits (rotation). Comme le RC5, il a l'avantage d'avoir une longueur de bloc de données variable, un nombre de rounds variable et une clé de longueur variable. Toutefois, il utilise la multiplication, ce qui augmente la diffusion dans chacun des rounds, donc la sécurité, et il a dû se conformer à des spécifications : opérer des blocs de 128 bits divisés en quatre dans le traitement et être hautement sécuritaire par rapport à sa complexité. RC6 a été soumis au NIST pour devenir le nouveau standard de la cryptographie avancée (Advanced Encryption Standard - AES). Chiffrement Comme pour le RC2 et le RC5, il y a deux parties dans l'algorithme, soit une procédure d'expansion de la clé et une procédure de chiffrement. Les opérations utilisées sont l'addition modulo 2(nombre de bits des blocs) (+), la multiplication modulo 2(nombre de bits des blocs) (x), le OU-Exclusif (XOR) et le décalage de bits vers la gauche (<<<). En équations : Soient K[0], K[1], ..., K[n] les sous-clés dérivées de la procédure d'expansion de la clé et A, B,C et D les quatre parties d'un bloc de texte clair de 128 bits à chiffrer.   B = B + K[0]   D = D + K[1]   Pour i allant de 1 jusqu'au nombre de rounds "r"             t = (B x (2B + 1)) <<< log2(nombre de bits des blocs)             u = (D x (2D + 1)) <<< log2(nombre de bits des blocs)             A = ((A XOR t) <<< u) + K[2i]             C = ((C XOR u) <<< t) + K[2i + 1]             (A,B,C,D) = (B,C,D,A)   Fin Pour   A = A + K(2r + 2)   C = C + K(2r + 3) Déchiffrement Le déchiffrement est exactement l'inverse du chiffrement. Considérations Les algorithmes de chiffrement RC2, RC5 et RC6 sont simples, donc très propices à la cryptanalyse. À noter que le RC2 est vulnérable aux attaques reliées à la clé (related-Key attacks) si les clés ne sont pas générées efficacement par un pseudo-générateur robuste de nombres aléatoires (PRNG).

Chiffrements par blocs  RC2 Introduction push size_ok_Key 1 < size < 128 push offset Key_entered call RC2_SetKey push offset plain push offset cipher call RC2_Encrypt push size_ok_Key push offset Key_entered call RC2_SetKey push offset cipher push offset out call RC2_Decrypt Chiffrement La routine de cryptage ou de décryptage seront de longues répétitions de séquences comme celles qui suit: 00405C02 and bp, dx 00405C05 and si, bx 00405C08 add ax, bp 00405C0B add si, word_0_41425C 00405C12 add ax, si 00405C15 rol ax, 1 00405C18 mov si, ax 00405C1B mov bp, dx 00405C1E not si 00405C21 and bp, ax 00405C24 and si, cx 00405C27 add bx, bp 00405C2A add si, word_0_41425E 00405C31 add bx, si 00405C34 rol bx, 2 00405C38 mov si, bx 00405C3B mov bp, ax 00405C3E not si S_Box Les sbox seront la signature de RC2: sbox db 217,120,249,196, 25,221,181,237, 40,233,253 db 121, 74,160,216,157,198,126, 55,131, 43,118 db 83,142, 98, 76,100,136, 68,139,251,162...  Chiffrements par blocs  RC4 Introduction Je ne sais pas si on peut réellement considérer le RC4 comme un algorithme de chiffrement. Il ressemble plutôt à un chiffrage basique, toute la "subtilité" du RC4 résidant dans le bidouillage entre votre clé et un table. push password length in bytes <1 et 128> push offset Key call _rc4_setKey La fonction setKey va d'abord initialiser une table. On peut raisonnablement supposer que dans certain cas la table sera déjà présente dans les DATA: 00406D2A mov eax, 0FFFEFDFCh 00406D2F mov ecx, 40h 00406D34 mov dword_0_4142D8[ecx*4], eax 00406D3B sub eax, 4040404h 00406D40 dec ecx 00406D41 jnz short loc_0_406D34 rc4Keytable: 01 02 03-04 05 06 07 08 09 0A 0B ................ 0C 0D 0E 0F 10 11 12 13-14 15 16 17 18 19 1A 1B ................ 1C 1D 1E 1F 20 21 22 23-24 25 26 27 28 29 2A 2B .... !"#$%&'()*+ 2C 2D 2E 2F 30 31 32 33-34 35 36 37 38 39 3A 3B ,-./0123456789:; 3C 3D 3E 3F 40 41 42 43-44 45 46 47 48 49 4A 4B <=>?@ABCDEFGHIJK 4C 4D 4E 4F 50 51 52 53-54 55 56 57 58 59 5A 5B LMNOPQRSTUVWXYZ[ 5C 5D 5E 5F 60 61 62 63-64 65 66 67 68 69 6A 6B \]^_`abcdefghijk 6C 6D 6E 6F 70 71 72 73-74 75 76 77 78 79 7A 7B lmnopqrstuvwxyz{ 7C 7D 7E 7F 80 81 82 83-84 85 86 87 88 89 8A 8B |}~............ 8C 8D 8E 8F 90 91 92 93-94 95 96 97 98 99 9A 9B ................ 9C 9D 9E 9F A0 A1 A2 A3-A4 A5 A6 A7 A8 A9 AA AB ................ AC AD AE AF B0 B1 B2 B3-B4 B5 B6 B7 B8 B9 BA BB ................ BC BD BE BF C0 C1 C2 C3-C4 C5 C6 C7 C8 C9 CA CB ................ CC CD CE CF D0 D1 D2 D3-D4 D5 D6 D7 D8 D9 DA DB ................ DC DD DE DF E0 E1 E2 E3-E4 E5 E6 E7 E8 E9 EA EB ................ EC ED EE EF F0 F1 F2 F3-F4 F5 F6 F7 F8 F9 FA FB ................ FC FD FE FF Cette table va ensuite être bidouillée avec la clé de cryptage que vous aurez choisi: xor eax, eax mov edi, ptrPass _Key_return: xor ebx, ebx mov esi , lPass jmp _new_Key _Key_loop: inc bl dec esi jz _Key_return _new_Key: mov dl, byte ptr [rc4Keytable+ecx] add al, byte ptr [edi+ebx] add al, dl mov dh, byte ptr [rc4Keytable+eax] mov byte ptr [rc4Keytable+ecx], dh mov byte ptr [rc4Keytable+eax], dl inc cl jnz _Key_loop En sortie, la table est "reconfigurée" en fonction de votre clé. Algorithme de Cryptage Il est suffisamment court pour être proposé dans son intégralité et suffisamment simple pour se passer de commentaire: _rc4_crypt mov edi, long_texte mov esi, ptr_texte _rc4_enc_loop: inc bl mov dl, byte ptr [rc4Keytable+ebx] add al, dl mov cl, byte ptr [rc4Keytable+eax] mov byte ptr [rc4Keytable+ebx], cl mov byte ptr [rc4Keytable+eax], dl add cl, dl mov cl, byte ptr [rc4Keytable+ecx] xor byte ptr [esi], cl inc esi dec edi jnz _rc4_enc_loop xor eax, eax mov edi, offset rc4Keytable mov ecx, 256/4 cld rep stosd _rc4_crypt endp RC4 étant basé sur un XOR entre le texte entré et votre clé, la routine de chiffrement fonctionne dans les deux sens, cryptage/decryptage.  Chiffrements par blocs  RC6 Identification significative La génération de la clé est sans doute la partie la plus significative dans l'identification du RC6: RC6 Key schedule Define P32 = B7E15163 (hex), Q32 = 9E3779B9 (hex) 00401B9C mov dword ptr [esi+58h], 0B7E15163h -> constante 00401BA3 lea eax, [esi+5Ch] 00401BA6 mov ecx, 23h 00401BAB mov edx, [eax-4] 00401BAE add eax, 4 00401BB1 sub edx, 61C88647h

Systèmes à clé publique Le chiffrement à clé publique, aussi appelé le chiffrement asymétrique, implique une paire de clés : une clé publique et une clé privée. La clé publique est publiée dans des annuaires et ainsi connue de tous alors que la clé privée n'est connue que de la personne à qui la paire appartient. Pour envoyer un texte chiffré à une personne, il faut utiliser la clé publique de cette personne et chiffrer le texte. Une fois reçu, le destinataire utilise sa clé privée correspondante pour retrouver le message clair. Les systèmes à clé publique les plus utilisés sont RSA et PGP. Le cracking RSA a été traité dans Crypto_for_newbies 1.  Logarithmes discrets Les principaux systèmes basés sur le problème du calcul des logarithmes discrets sont le protocole de Diffie-Hellman, le chiffrement ElGamal et les systèmes à courbe elliptique (Elliptic curve cryptosystems).  Systèmes à clé publique  ElGamal (courtesy of Lutin Noir) Un utilisateur A veut signer un message M. Il choisit d’abord un nombre premier p, puis deux nombres g et x inférieurs à p. Ensuite il calcule y : y = g^x mod p (^ = puissance) L’utilisateur A a maintenant ses clés publiques (p, g, y) et sa clé privée (x) qu’il ne doit pas diffuser. Désormais, il est en mesure de signer un message M, et un utilisateur B peut vérifier que c’est bien A qui a signé le message. Pour ce faire, A choisit un nombre k tel que k et (p-1) soient premiers entre eux. Ensuite il calcule : a = g ^ k mod p Puis il utilise l’algorithme d’Euclide pour résoudre l’équation suivante : M = (x*a + k*b) mod (p-1) Ou b = ( k ^ (-1) ) * ( M – x*a) mod (p-1) Maintenant l’utilisateur A a la signature du message M, c’est le couple (a,b). B peut maintenant vérifier que c’est bien A qui a signé M grâce aux clés publiques de A. Pour ce faire il doit vérifier que : y^a * a^b mod p = g ^ M mod p Si les deux membres de l’équation sont égaux alors la signature est valide et B sait que A a bien signé le message M. Supposons maintenant qu’un utilisateur C veuille se faire passer pour A et signer le message M. Plusieurs possibilités se présentent à lui (bien entendu dans la mesure où ceci est réalisable), il peut soit trouver la clé privée de A, soit forger une signature qui vérifiera l’équation Comment C peut-il trouver x ? Il lui suffit de résoudre y = g^x mod p : c’est le problème des logarithmes discrets (ou DLP).

Systèmes à clé publique  RSA Introduction Dans la majorité des programmes utilisant le RSA, vous trouverez une, ou des chaînes décimales ou hexadécimale du type: data:00404275 Public_Key db '10001',0 -> toujours un nombre premier data:0040427B Modulus db '8e701a4c793eb8b739166bb23b49e421',0 Algorithme 1. cryptage du message m pour obtenir le cipher c c = me mod(n), où (n,e) est la clé publique du destinataire. 2. décryptage du cipher c : m = cd mod(n), où (n,d) est la clé privée du destinataire. Chiffrement Il existe plusieurs Library permattant d'effectuer les opérations de chiffrement. MIRACL, Cryptolib, Crypto++ et FGint semblent être les plus utilisées. Vous en retrouverez en générale une trace dans les DATA: 0040CB18 aMiraclNotInitialised db 'MIRACL not initialised - no call to mirsys()',0Ah,0 0040CD58 aMiraclErrorFromRoutine db 0Ah 0040CD58 db 'MIRACL error from routine ',0  Systèmes à clé publique  Démonstration RSA Voici un peit exemple de cryptage RSA. Ecrit en javaScript, il est particulièrement lent, et donc limité au chiffrement d'une seule lettre. Choisissez 2 nombres premiers (P et Q)   5 7 11 13 17 19 23 29 31 37 3 5 7 11 13 17 19 23 Choisissez une lettre (Plain text)   A B C D E F G H I J Entrez le nombre premier (e)   Entrez le modulus (n)   Entrez le message crypté (cipher text)   Entrez le modulus (n)   Entrez la clé privée (d)

Fonctions de hachage Généralement, une fonction de hachage "H" transforme une entrée de données d'une dimension variable "m" et donne comme résultat une sortie de données inférieure et fixe "h" (h = H(m)). Évidemment, il doit être impossible de trouver m à partir de h. Ainsi, une fonction de hachage doit remplir quelques conditions de base : L'entrée peut être de dimension variable. La sortie doit être fixe (toujours de taille identique). H(m) doit être relativement facile à calculer. H(m) doit être une fonction à sens unique. H(m) doit être "sans collision". Les algorithmes de hachage jouent leur principal rôle dans la génération des signatures numériques, en étant habituellement plus rapides que les algorithmes de ces dernières. Dans ce cas, le résultat "h" est appelé "empreinte" (digest). Principaux algorithmes · Message Digest MD2, MD4 et MD5 · RACE Integrity Primitives Evaluation Message Digest RIPEMD-128 et RIPEMD-160 · Secure Hash Algorithm SHA0 et SHA1 (devenu le standard SHS)  Fonctions de hachage  MD4 MD5 SHA-1 Entrée: Calcul: Resultat:

Coté Cracking  MD 2-4-5/SHA 160-256/RipeMD 160-256-320 Introduction J'avais déjà eu l'occasion de présenter MD5 et SHA-256 dans crypto4newbies1. Sans y revenir en détail, il est bon de rappeler que ces trois fonctions de hachage sont toutes initialisée de la même façon: Initialisation des l'Algorithmes MD -> 128 bits / SHA -> 160 bits / RipeMD -> 160 -256 - 320 bits :00401224 mov dword_0_4140B4, 67452301h :0040122E mov dword_0_4140B8, EFCDAB89h :00401238 mov dword_0_4140BC, 98BADCFEh... soit 01 23 45 67 89 AB CD EF-FE DC BA 98 76 54 32 10 .#Eg........vT2. dans la fenêtre des Data's (le #Eg est significatif). La séquence sera d'autant plus longue (en bits) que le résultat du hash demandera de caractères en sortie. A noter: 67452301h = 1732584193d (vous pourriez tomber dessus dans les stings Data) Identification significative du SHA 256 bits mov dword ptr [_HASH_0] , 06a09e667h mov dword ptr [_HASH_1] , 0bb67ae85h mov dword ptr [_HASH_2] , 03c6ef372h mov dword ptr [_HASH_3] , 0a54ff53ah... Déchiffrement A moins de brute forcer la fonction (ce qui peut être très long), il n'y a pas d'algorithme de décryptage.