Décryptage de mots de passe avec la fonction crypt

**YoungDeveloppeur** · 18/05/2015, 22h07

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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:

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

**sambia39** · 19/05/2015, 20h09

Bonsoir

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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.

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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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 stdout :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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.

**SkyZoThreaD** · 20/05/2015, 00h54

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

Décryptage de mots de passe avec la fonction crypt

C

Discussions similaires

Partager

Partager