Décryptage de mots de passe avec la fonction crypt

Bonsoir,

pour un projet de C, je dois écrire un programme qui casse les mots de passe de la forme [a-z0-9] pouvant aller de 1 à 8 caractères.

J'ai réalisé le code qui me permet de trouver des mots de passe de 1 caractère
Code:

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 1 #include <unistd.h> /* pour crypt * 2 #include <stdio.h> /* pour printf */ 3 #include <string.h> /* pour strcmp et strlen */ 4 int main(void) 5 { 6 int i = 0; 7 int longueur = 36; 8 char chaine[2] = {'x','\0'}; 9 char tableau[36] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p' ,'q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9'}; 10 11 char hachedpwdWithoutSalt [] = 12 "0HHtSA4cVzz0G2I.gswgTG93A8rvH5HCyWsjdMfomNSfiPmsPXGqq5EYfLlS1rEf9bOl6Ho8w1zdV/C2sv /B/."; 13 14 for (i=0; i<longueur; i++) 15 { 16 chaine[0] = tableau[i]; 17 18 if ( strcmp( crypt(chaine, "$6$QSX8hjVa$") + strlen("$6$QSX8hjVa$"), 19 hachedpwdWithoutSalt ) 20 == 0 ){ 21 printf("mdp du root craque ----> %s\n", chaine); 22 break; 23} 24 else 25 printf("mdp du root pas encore craque!!\n"); 26 } 27 return 0; 28 }
J'ai également un fichier texte comportant les mots de passe hachés que je dois donc décrypter:

Citation:

Longueur 1:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: 0HHtSA4cVzz0G2I.gswgTG93A8rvH5HCyWsjdMfomNSfiPmsPXGqq5EYfLlS1rEf9bOl6Ho8w1zdV/C2sv/B/.

Longueur 2:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: gNPp/B3vf8UUotZQ8kB9MbZvC9XWBSU6yEykbEGSYoaW2Z7NEfcivrWWt9kPSuWB0TwdzbO51lRqRCBVmNYgR0

Longueur 3:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: Sb6pCN8KN1u9aUfYOLt2cQx4l61YHBz7kjTFS0A7pdDs1r0Xmm3nW7meyy9Fyt6e.JhkbN4zwaHC6whN9vP/..

Longueur 4:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: R..F1fyDnsTOy1g8jk5eupizgPcpkt1uZnFF0BP0bjEuhVbA01J3LFjzVdh.nuSDmFbHShDaYXQK.5OC47Tr70

Longueur 4:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: Oj9IAu50jSsAAm62MOo63Ea4p1o8DC0zcR6I8N5f4jRgE0Bv0WRFEJwO4hGxAAMyOF2ON5Dwze2InWV9nDWVm1

Longueur 5:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: nWgWe1FPL5XZqbEkdrkAX2bLfxvtD84rHaJ2jV7V.34U0txSUdYDC7PTDooxHIi0uJc7XcyUqgPfYIFPGiApE0

Longueur 6:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: FGFMnq/y2zcEKz2NLVoWolGI7bG3s.bxf0NJFYunhng7bCGhfAbtmsqcsaCW5tIFPBh0XVSrQxfW66XwUCYQ8.

Longueur 6:
type et salt: $6$_SX5gjVa$
mdp haché sans salt: H3YBkLGM.OhpGRMtlwplT.wClyZEyhWhO1JB0GqmiM603CRYjL5tLU8IWhje1oSW7URGOIRVf/gPVIXWr37WK1

Longueur 7:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: Iqh9UUWWMXzf7hzZ309httUrebuH1vCGirtR0r3i0RFvH0wc0UaQVnUXMOdUbQsBM1ssmdbaUzcyvPTfRB4km0

Longueur 8:
type et salt: $6$QSX8hjVa$
mdp haché sans salt: R6oPGKiym3490f4q9P5I1MIeAXVpL8KP%9EssLtusurP2aezPMdq9vgo3qWguWrFfctdkQXO2iXqI8ks5NCplD/

Pour la longueur 1 j'ai trouvé le mot de passe "h"
Pour la longueur 2 j'ai trouvé le mot de passe "j5"
Pour la longueur 3 j'ai trouvé lemot de passe "f47" (mais je n'en suis pas sûr)

Mon but serait désormais de permettre à l'utilisateur d'entrer une longueur comprise entre 1 & 8, et selon la longueur choisie, la script ira chercher le hach du mot de passe et le comparera au salt afin de trouver le mot de passe de longueur N (où N étant la longueur choisie par l'utilisateur).

J'espère que quelqu'un pourra m'aider car je ne suis que débutant en C, et j'avoue que je ne vois pas trop comment m'y prendre.

Merci, toute aide que vous pourrez m'apporter sera bonne à prendre :D

2 pièce(s) jointe(s)

Bonsoir
Citation:
Envoyé par YoungDeveloppeur
Bonsoir,

pour un projet de C, je dois écrire un programme qui casse les mots de passe de la forme [a-z0-9] pouvant aller de 1 à 8 caractères.

J'ai réalisé le code qui me permet de trouver des mots de passe de 1 caractère
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 9 char tableau[36] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p' ,'q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9'}; 11 char hachedpwdWithoutSalt [] = 12 "0HHtSA4cVzz0G2I.gswgTG93A8rvH5HCyWsjdMfomNSfiPmsPXGqq5EYfLlS1rEf9bOl6Ho8w1zdV/C2sv /B/."; 13 14 for (i=0; i<longueur; i++) 15 { 16 chaine[0] = tableau[i]; 17 18 if ( strcmp( crypt(chaine, "$6$QSX8hjVa$") + strlen("$6$QSX8hjVa$"), 19 hachedpwdWithoutSalt ) 20 == 0 ){ 21 printf("mdp du root craque ----> %s\n", chaine); 22 break; 23} 24 else 25 printf("mdp du root pas encore craque!!\n"); 26 } 27 return 0; 28 }
J'ai de sérieux doutes sur les instructions écrites, il est fort probable que cela donne pas les bons mots de passe.
Exemple simple de déchiffrement le code qui est à revoir.
Code:

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 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 /** * @Autheur: SAMBIA39 * @Licence: GPLv3 * @Mail: admin@xjagercodes.com */ #define _XOPEN_SOURCE #define _SIZE_MDP_ 20 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <time.h> /* constante du gen hashage */ const char t_str_salt[] = "0123456789" "abcdefghijklmnopqrstuvwyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; /* * Fonction gen hash */ char *f_Gen_hash_crypt( const char *ptr_src ){ char *ptr = NULL; /* pointeur hash */ char t_salt[6]; /* tab salt */ static int i_seed; /* variable seed random */ if( (NULL) == ptr_src ){ fprintf(stderr,"Erreur aucun mots de passe fournie\n"); return( NULL ); } ptr = (char*)calloc( _SIZE_MDP_, sizeof(char) ); if( (NULL) == ptr ){ fprintf( stderr, "Erreur Allocation mot de passe %s\n", strerror(errno) ); return( NULL ); } /* seed random */ if( !i_seed ){ i_seed = 1; srand( (unsigned int)time(NULL) ); } /* Création du salt */ t_salt[0] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[1] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[2] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[3] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[4] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[5] = '\0'; strcpy( ptr, crypt( ptr_src, t_salt ) ); return( ptr ); } int main( void ){ char t_salt[6]; /* Tab grain de sel */ char t_mdp_clear[_SIZE_MDP_]; /* Tab mots de passe clear */ char *ptr_mdp_chff = NULL; /* Pointeur sur hash mdp */ /* Generation du hash | chiffrement du mots */ strcpy( t_mdp_clear, "sambia39" ); ptr_mdp_chff = f_Gen_hash_crypt( t_mdp_clear ); if( (NULL) == ptr_mdp_chff ){ fprintf( stderr, "Erreur generation hash\n" ); return( EXIT_FAILURE ); } /* Dechiffrement du mdp */ /* Création du salt avec le hash mdp */ t_salt[0] = ptr_mdp_chff[0]; t_salt[1] = ptr_mdp_chff[1]; t_salt[2] = ptr_mdp_chff[2]; t_salt[3] = ptr_mdp_chff[3]; t_salt[4] = ptr_mdp_chff[4]; t_salt[5] = '\0'; /* Comparaison du mots de passe */ if( (0) == strcmp( crypt( t_mdp_clear, t_salt), ptr_mdp_chff) ) printf(">> le mots de passe à été trouver\n" ); else printf(">> ! aucun mots de passe trouver\n" ); /* Free des allocation */ free( ptr_mdp_chff ); ptr_mdp_chff = NULL; return( EXIT_SUCCESS ); }
Dans mon exemple j'utilise l'hash du mot de passe pour créer mon grain de sel afin de générer un nouveaux hash et faire une comparaison lexicale avec l'ancienne et si cela correspond alors, j'estime avoir trouvé les bons mots de passe.
Hors dans votre exemple vous générer des hashs avec le caractère fournies par la boucle for et vous faites une comparaison par la suite avec un autres argument qui n'est pas le hash d'origine et cette méthode ne garantie pas une forte probabilité que vous trouviez le bon mot de passe de plus, la comparaison est soumise à l'échec dès le départ donc pas forcement de bon mots de passe.

Citation:

Envoyé par YoungDeveloppeur

J'ai également un fichier texte comportant les mots de passe hachés que je dois donc décrypter:
Pour la longueur 1 j'ai trouvé le mot de passe "h"
Pour la longueur 2 j'ai trouvé le mot de passe "j5"
Pour la longueur 3 j'ai trouvé lemot de passe "f47" (mais je n'en suis pas sûr)

Mon but serait désormais de permettre à l'utilisateur d'entrer une longueur comprise entre 1 & 8, et selon la longueur choisie, la script ira chercher le hach du mot de passe et le comparera au salt afin de trouver le mot de passe de longueur N (où N étant la longueur choisie par l'utilisateur).

Ici on est dans un cas dit "d'attaque par dictionnaire" et il vous est tout à fait possible avec une modification légère du code source donné en exemple ( ci-dessus ) de déchiffrer les mots de passe chiffrer.

Le principe est simple il faut lire les mots ou les phrases du fichier X ( dictionnaire de mots de passe ) et générer un hash du mot de passe et comparer celle-ci aux hashs d'origine qui vous ont été fournies. Dans le cas où ces deux valeurs sont identiques on peut en conclure que l'on a trouvé les bons mots de passe.
Mais attention en comprend également que cette technique n'est pas fiable à 100%, car elle dépend fortement des mots qui ce trouve dans le dictionnaire exemple si j'ai µop14#@^$£_é25 comme mot de passe il est clair que l'attaque par dictionnaire échouera à coups sûrs sauf cas d'une attaque par brute force.
pour se prémunir de ce type d'attaque, il est toujours conseillé de saisir des mots de passe qui ne sont pas susceptibles d'exister dans un dictionnaire de mots de passe exemple: admin, toor, root, 1234, 0000.

Afin d'illustrer ce que j'avance voici un exemple.
Je tiens avant tout à m'excuser auprès de tous les membres du forum dont le pseudo figure dans mon pseudo dictionnaire et au l'administrateur du forum. Mon exemple est purement d'ordre pédagogique et je décline toute responsabilité de la façon dont le code source sera employé directement ou indirectement sous n'importe quelle forme à des fins inappropriées

Le but de l'exemple qui suit est très simple un peut comme ce qui vous a été demander, c'est de déchiffrer le pseudo adéquat pour se connecter à une variante du site http://www.developpez.net en s'aidant de l'hash du pseudo préalablement acquis ( générer préalablement pour l'exemple) pour cela je possède une liste de non d'utilisateurs (méga copié-collé) nommé brutus.mdp(brutus.mdp.tar.gz) et je dois trouver le bon pseudo pour me connecter.
Code:

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 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 /** * @Autheur: SAMBIA39 * @Licence: GPLv3 * @Mail: admin@xjagercodes.com */ #define _XOPEN_SOURCE #define _SIZE_MDP_ 20 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <time.h> /* constante du gen hashage */ const char t_str_salt[] = "0123456789" "abcdefghijklmnopqrstuvwyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; /* * Fonction gen hash */ char *f_Gen_hash_crypt( const char *ptr_src ){ char *ptr = NULL; /* pointeur hash */ char t_salt[6]; /* tab salt */ static int i_seed; /* variable seed random */ if( (NULL) == ptr_src ){ fprintf(stderr,"Erreur aucun mots de passe fournie\n"); return( NULL ); } ptr = (char*)calloc( _SIZE_MDP_, sizeof(char) ); if( (NULL) == ptr ){ fprintf( stderr, "Erreur Allocation mot de passe %s\n", strerror(errno) ); return( NULL ); } /* seed random */ if( !i_seed ){ i_seed = 1; srand( (unsigned int)time(NULL) ); } /* Création du salt */ t_salt[0] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[1] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[2] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[3] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[4] = t_str_salt[ rand() % (int)(sizeof(t_str_salt) -1) ]; t_salt[5] = '\0'; strcpy( ptr, crypt( ptr_src, t_salt ) ); return( ptr ); } int main( void ){ FILE *pFile = NULL; /* Fichier brutus */ char t_salt[6]; /* Salt */ char *ptr_hash = NULL; /* pointeur hash */ char *ptr_verif_mdp = NULL; /* pointeur verif mot */ char t_mdp_clear[_SIZE_MDP_]; /* Tab mdp clear */ char t_mdp_hash[_SIZE_MDP_]; /* Tab mdp gen hash */ /* Alloc ptr verification */ ptr_verif_mdp = (char*)calloc( _SIZE_MDP_, sizeof(char) ); if( (NULL) == ptr_verif_mdp ){ fprintf(stderr,"Erreur Allocation verif mdp %s\n", strerror(errno) ); return( EXIT_FAILURE ); } /* pré traitement */ strcpy( t_mdp_clear, "sambia39"); strcpy( t_mdp_hash, f_Gen_hash_crypt("sambia39") ); strncpy( t_salt, t_mdp_hash, 4 ); t_salt[5] = '\0'; /* Affichage */ printf("(Brutus traitement)-------------\n"); printf(">> (Brutus_Clear):%s\n", t_mdp_clear); printf(">> (Brutus_salt):%s\n", t_salt ); printf(">> (Brutus_hash):%s\n", t_mdp_hash ); printf("-------------\n"); /* Ouverture du dictionnaire */ pFile = fopen( "brutus.mdp", "r" ); if( (NULL) == pFile ){ free( ptr_verif_mdp ); ptr_verif_mdp = NULL; fprintf( stderr, "Erreur aucun dictionnaire d'attaque fournie %s\n", strerror(errno) ); return( EXIT_FAILURE ); } /* Attaque par dictionnaire */ while( (NULL) != fgets( ptr_verif_mdp, _SIZE_MDP_, pFile ) ){ ptr_verif_mdp[ strlen( ptr_verif_mdp ) -1 ] = '\0'; ptr_hash = crypt( ptr_verif_mdp, t_salt ); printf(">>(Brutus): %s\t:%s(hash)| %s(hash mdp)", ptr_verif_mdp, ptr_hash, t_mdp_hash ); if( (0) == strcmp( ptr_hash, t_mdp_hash) ){ printf("\n-------------\n"); printf(">>(Brutus_MDP):%s (conforme) \n", ptr_verif_mdp ); fclose( pFile ); pFile = NULL; free( ptr_verif_mdp ); ptr_verif_mdp = NULL; return ( EXIT_SUCCESS ); } printf("( pas comforme )\n"); } /* close du fichier */ fclose( pFile ); pFile = NULL; /* Affichage si pas de mots de passe trouver */ printf("-------------\n"); printf(">>(Brutus)\t:Aucun mots de passe trouver\n"); /* Free des allocation */ free( ptr_verif_mdp ); ptr_verif_mdp = NULL; return( EXIT_SUCCESS ); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 (Brutus traitement)------------- >> (Brutus_Clear):sambia39 >> (Brutus_salt):vCr0 >> (Brutus_hash):vCr0v/HgM28h6 ....... >>(Brutus): rdurupt :vCQNFJS0mtH3A(hash)| vCr0v/HgM28h6(hash mdp)( pas comforme ) >>(Brutus): Roland :vCxDzAwEYXSz2(hash)| vCr0v/HgM28h6(hash mdp)( pas comforme ) >>(Brutus): Chastain :vC0pbq5YwNSrU(hash)| vCr0v/HgM28h6(hash mdp)( pas comforme ) >>(Brutus): romulus001 :vCDTupqOJfZng(hash)| vCr0v/HgM28h6(hash mdp)( pas comforme ) >>(Brutus): roswina :vCTIzF/VDhTDk(hash)| vCr0v/HgM28h6(hash mdp)( pas comforme ) >>(Brutus): sambia39 :vCr0v/HgM28h6(hash)| vCr0v/HgM28h6(hash mdp) ------------- >>(Brutus_MDP):sambia39 (conforme)
Pour effectuer d'autres teste à titre fun, voici les hashs de pseudo susceptible de déchiffrer le fichier aux formats zip ci-joint (brutus_mdp_secure.zip)
Code:

1 2 3 4 5 6 7 8 9 10 k9mjH1IhDF6rk k9u02SnRz7QO6 k9ukTmxdS/wrg k9MXo8he0oflI k9zYIDvXWp2Js k9JX4YGJ9P.NM k9wevCG.SiBXg k9fTJz2o4SpJE k98MQ7IifvftU
Citation:

Envoyé par YoungDeveloppeur

J'espère que quelqu'un pourra m'aider car je ne suis que débutant en C, et j'avoue que je ne vois pas trop comment m'y prendre.
Merci, toute aide que vous pourrez m'apporter sera bonne à prendre :D

Faut dire que j'ai légèrement donné pas mal d'indice et d'exemple à toit de faire le nécessaire l'adapter à ton sujet de façon différente.
je suis tout comme toi un débutant car j'estime que ce langage n'a pas encore fini de surprendre je suis un éternel apprenti du langage C.
d'ailleurs le code contient certainement des erreurs qui sûrement vont provoquer la colère de certains membres du forum.

à bientôt.

Une réponse de cette qualité c'est pas commun. Chapeau l'artiste 8-)