Systèmes à clé privée  Introduction

Les systèmes de cryptage à clés privées, appelé aussi système de cryptage symétrique, sont utilisés depuis déjà plusieurs siècles. C'est l'approche la plus authentique du chiffrement de donnée et mathématiquement la moins problématique. Dans ce type de système, la clé servant à chiffrer les données peut être facilement déterminée (à l'aide d'ordinateurs) si l'on connaît la clé servant à déchiffrer. Il est aussi facile de trouver la clé de déchiffrement en sachant la clé de chiffrement. Dans la plupart des systèmes symétriques, la clé de chiffrement est la même que la clé de déchiffrement. Autres termes anglais utilisés : Single-Key, one-Key, private-Key, conventional encryption, Cipher text (texte chiffré) Plain Text (texte déchiffré) Il y a deux catégories de systèmes à clé privée : les chiffrements par blocs et les chiffrements de flux.

Coté Cracking  Introduction

Introduction Face à des programmes utilisant des algorithmes de chiffrement, il est peu envisageable de lancer une attaque en Brute Force pour retrouver le texte d'origine. Pour autant, les SoftWares faisant recours à de tels algorithmes pour protéger les codes utilisateurs peuvent être plus ou moins facilement défait à condition: - d'identifier l'algorithme de chiffrement, à moins d'aimer se perdre dans du code... - de trouver la clé sans avoir recours au brute forcing - d'identifier les différents appels aux routines de traitement des valeurs entrées: - Initialisation d'un big number: - push 0 (mise à zero) - push address_big_number - call init_big_number (via -> VirtualAlloc) - conversion d'un big number: - push address_big_number - push 0Ah (si la conversion se fait en Base 10) - push address Plain_text (texte à convertir) - call conv_big_number - chiffrement d'un big number: - push address_return (ou push Key suivant les cas) - push address_big_number - call crypt_big_number Il est courant que les développeurs oublient que dans la fenêtre des DATA de SoftIce, ces valeurs (dont le "bon" serial) peuvent apparaître en clair, et devenir alors, à défaut d'une solution immédiate, le moyen de remonter la piste jusqu'aux appels aux routines ci-dessus. Une fois l'algorithme identifié, et la clé trouvée le reproduire à l'aide des LIB ou des sources que l'on trouve sur le NET, permet de créer le KeyGen espéré... Bonne journée Christal

Tool For Our Trade...  CrypTooL v 1.0

Identification des Signatures Significatives: CrypTooL permet d'effectuer des calculs sur des grands nombres (y compris les modulos), et effectue des cryptages RSA, BlowFish, TEA, Extended TEA, DES, NewDES, RC2, RC4 et IDEA. Ce tool n'est prévue pour fonctionner que sur des valeurs numériques, de préférences hexadécimales. Il effectue également la recherche de signatures de plusieurs Algorithmes comme MD 2, 4 et 5, SHA-160 et SHA-256, RipeMD 160, 256 et 320. Enfin, il permet de calculer ces mêmes hashs. L'objectif de cet outil est uniquement de confirmer vos doutes lorsque vous tomberez sur ce qui vous semblera des "big numbers". Il n'est pas conçu pour servir de moyen de chiffrement, mais les exemples en JavaScript de cette page devraient le compenser en partie. Ce texte, est livré avec quelques exemples de programmes ou de crackmes utilisant les algorithmes dont il est question ensuite. En espérant qu'il puisse vous servir un jour...

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é Permutation 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

Coté Cracking  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...

Chiffrement 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. 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 : 1. 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. 2. 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. 3.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)   o OU-Exclusif sur 2 blocs de 16 bits o Addition modulo 216 sur 2 blocs de 16 bits o 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 inter changé. 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

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

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

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

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

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

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

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

_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

push  size_of_Key    1 < size < 128	
push  offset Key_entered		
call  RC2_SetKey

push	  offset plain
push  offset out_cipher
call  RC2_Encrypt

push	  size_of_Key 	
push  offset Key_entered
call  RC2_SetKey

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

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

data:00404275 Public_Key db '10001',0  -> toujours un nombre premier
data:0040427B Modulus    db '8e701a4c793eb8b739166bb23b49e421',0

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ées 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.