Outil de brut force du mot de passe EnableSecret Cisco
Sommaire
1 – Définition de l’exécutable
L’utilitaire EnableSecret vous permettra de retrouver le mot de passe « Enable Secret » de votre équipement Cisco. Pour cela, l’outil effectue un brut force ou un test de dictionnaire afin de retrouver le password correspondant.
L’un des grands points forts de cet outil est la possibilité de faire varier le dictionnaire en ajoutant avant et après des chiffres ou autres types de caractères.
2 – Screen shot
3 – Download
Nom : EnableSecret.exe
Mode : Console
Version : 1.1
Librairie : 3.12
Taille : 56 Ko
Auteur : _SebF
Date de création : 11 janvier 2007
Dernière compilation : 02 Juin 2007
4 – Suivi du développement
4.1 – Problème restant
4.2 – RoadMap
4.3 – Suivi du projet
- V1.1.3.12
Modification de la valeur de la constante #define TAILLE_MAX_MOT à 300. Lorsqu’un mot dans le dico était trop long, ça faisait déborder la mémoire et ainsi, les correspondances suivantes étaient toutes fausses. - V1.0.3.12
Création du projet Cmd, Level 4, compilation en mode Release.
5 – Code source
5.1 – EnableSecret.cpp
// ********************************************
// Nom : EnableSecret.cpp
// Auteur : sebastien.fontaine@authsecu.com.pas.de.spam
// Date de création : 11 Janvier 2007
// version : 1.0.3.12
// Licence : Cette executable est libre de toute utilisation.
// La seule condition existante est de faire référence
// au site http://www.authsecu.com afin de respecter le travail d'autrui.
// ********************************************
// ********************************************************
// Les includes
// ********************************************************
// Il faut ajouter dans les proprités du projet => C++ => Command Line :
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairieSocket"
#include "LibrairieSocket.h"
#include "conio.h" // Nécessaire pour le getch()
#include "md5.version.crypt.h"
// ********************************************************
// Les Librairies
// ********************************************************
// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void gestion_des_arguments(int argc, char* argv[]);
void hash_brute_force(void);
void hash_dictionnaire(void);
DWORD WINAPI interception_des_touches(LPVOID lpParameter);
void affichage_des_statistiques(void);
void sauvegarde(void);
void chargement(char *);
void variation_majuscule(char *);
void cryptage(char *);
char * md5_crypt(const char *, const char *);
// ********************************************************
// Les constantes
// ********************************************************
#define TAILLE_MAX_MOT 20 // Définit la tallie maximal du mot en claire
#define NB_DE_FICHIER 4096 // Définir le nombre de fichier qui recevront les hash
#define PROFONDEUR_DU_TABLEAU 80000 // Définit le la taille de chaque char* du tableau
// ********************************************************
// Les variables
// ********************************************************
char enable_secret[1000]; // Chaine complète de l'enable secret
char salt[7]; // Première partie de enable_secret
char password_crypte[22]; // Chaine MD5 de enable_secret
char * mot_hasher; // Chaine de caractere hashé
char *tableau_des_caracteres; // Tableau possédant les caractères à tester
char *tableau_des_caracteres_variant; // Tableau possédant les caractères à varier
bool sortie_boucles; // Booléan permettant de synchroniser les deux thread (touche et hash)
int compteur; // Compte le nombre de hash effectué
// *2 sinon plantage sur des mot de 12 caracteres en mode dico+variation. Pas trouvé la solution
char mot_brut_force[TAILLE_MAX_MOT*2]; // Mot en claire dans la fonction brute force
char mot_dictionnaire[TAILLE_MAX_MOT]; // Mot en claire dans la fonction dicotionnaire
char chaine_de_demarrage[TAILLE_MAX_MOT]; // Chaine contenant le mot à démarrer en cas de reprise
int heure_de_depart; // Définit l'heure de départ du traitement
unsigned short longueur_maxi; // Longueur maximal de la chaine en brut force
bool dicionnaire_active; // Active le brut force à partir d'un dictionnaire
char *fichier_du_dico; // Nom du fichier pour lire le dictionnaire
char *fichier_a_sauvegarder; // Nom du fichier pour sauvegarder la position
unsigned short nombre_de_variation_avant; // Définit le nombre de caractere a varié avant les mots
unsigned short nombre_de_variation_apres; // Définit le nombre de caractere a varié après les mots
bool view; // Active l'affichage
bool minuscule; // Active la variation du disctionnaire majuscule minuscule
bool la_chaine_est_trouvee; // Indique si le mot de passe à été décrypté
FILE *pointeur_vidage_dico; // Déclare le pointeur de fichier pour lire le dictionnaire
int main (int argc, char* argv[])
{
DWORD id_du_thread_touche; // Id du thread touche
initiation_des_variables();
gestion_des_arguments(argc,argv);
printf ("\nPassword crypté : %s",enable_secret);
// ********************************************************
// Vérifie le format du password
// ********************************************************
if ( (strlen(enable_secret)!=30) || (strncmp(enable_secret,"$1$",3)) || (enable_secret[7]!='$') )
{
printf ("\nFormat du password incorrect");
exit(0);
}
// ********************************************************
// Séparation du password
// ********************************************************
strncpy(salt,enable_secret,8);
salt[8]='\0';
strncpy(password_crypte,enable_secret+8,22);
password_crypte[22]='\0';
// ********************************************************
// Appel de la fonction interception_des_touches dans un process différent
// ********************************************************
CreateThread(NULL,0,interception_des_touches,NULL,0,&id_du_thread_touche);
Sleep(1); // Permet d'être sur que l'affichage suivant aura lieu (l'autre process pourrais terminer en moin d'une seconde)
// ********************************************************
// Prend les chaine à haser soit du mode brut force ou du dico
// ********************************************************
if (dicionnaire_active==true)
hash_dictionnaire();
else
hash_brute_force();
// ********************************************************
// Affiche le resultat de sortie
// ********************************************************
if (la_chaine_est_trouvee==true)
printf("\nYes, the password was found. It's : %s",mot_brut_force);
else
printf("\nSorry, but the password was not found");
printf("\n");
}
void initiation_des_variables(void)
{
// ********************************************************
// Affichage de la banniere
// ********************************************************
printf("\nCisco5 - Brut Force all Cisco Password 5 (enable secret) - Version 1.0.3.12");
printf("\nCreate on January 11, 2007, Last compilation on January 16, 2007");
printf("\nCreated by sebastien.fontaine@authsecu.com");
printf("\n");
// ********************************************************
// Initialisation des options générales
// ********************************************************
view=false;
// ********************************************************
// Initialisation du Password
// ********************************************************
strcpy(enable_secret,"$1$8.K7$PjHq5g/20wsd05yj5EAwl/");
// ********************************************************
// Initiation brut force
// ********************************************************
longueur_maxi=20;
tableau_des_caracteres="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789*$%!";
fichier_a_sauvegarder="save.txt";
// ********************************************************
// Initiation des statistiques
// ********************************************************
heure_de_depart=GetTickCount();
compteur=0;
// ********************************************************
// Initiation du dico
// ********************************************************
dicionnaire_active=false;
fichier_du_dico="dictionnary.txt";
nombre_de_variation_avant=0;
nombre_de_variation_apres=0;
tableau_des_caracteres_variant="0123456789";
minuscule=false;
sortie_boucles=false;
la_chaine_est_trouvee=false;
}
void gestion_des_arguments(int argc,char* argv[])
{
char *caractere_non_convertit;
int i;
// ********************************************************
// Affichage de l'aide
// ********************************************************
if ( (argc>1) && (strcmp(argv[1],"-?")==0) || (argc==1) )
{
printf("\n");
printf("\nGENERAL OPTIONS");
printf("\n-? This help");
printf("\n-view View the results Default: %d (1 => Activate)",view);
printf("\n\nPASSWORD");
printf("\n-password Enable Secret Defaut: None");
printf("\n");
printf("\nBRUT FORCE");
printf("\n-maximum_length Maximum caracters Default: %d",longueur_maxi);
printf("\n-characters Separate with \"\" Default: %s",tableau_des_caracteres);
printf("\n-save_name Name of save file Default: %s",fichier_a_sauvegarder);
printf("\n-load_name Name of load file Default: (specify one name for activate the load)");
printf("\n");
printf("\nDICTIONNARY");
printf("\n-dictionnary Test dictionnary Default: %d (1 => Activate)",dicionnaire_active);
printf("\n-file_name_dico Name of the file Default: %s",fichier_du_dico);
printf("\n-variable_before Lenght of variant Default: %d",nombre_de_variation_avant);
printf("\n-variable_after Lenght of variant Default: %d",nombre_de_variation_apres);
printf("\n-variable_characters Separate with \"\" Default: %s",tableau_des_caracteres_variant);
printf("\n-capital_letter Maj/min variation Default: %d",minuscule);
printf("\n\nSAMPLE");
printf("\nEnableSecret -password $1$/oqx$.3HyeKPEryag7w3u4H0n0/ ");
printf("\n\n");
exit(0);
}
// ********************************************************
// Récupération des arguments
// ********************************************************
for (i=1;i<argc;i=i+1)
{
// ********************************************************
// Choix généraux
// ********************************************************
if ( (stricmp(argv[i],"-view")==0) || (stricmp(argv[i],"/view")==0) )
if (strtod(argv[i+1],&caractere_non_convertit)==0)
view=false;
else
view=true;
// ********************************************************
// Options PASSWORD
// ********************************************************
if ( (stricmp(argv[i],"-password")==0) || (stricmp(argv[i],"/password")==0) )
strcpy(enable_secret,argv[i+1]);
// ********************************************************
// Choix brut force
// ********************************************************
if ( (stricmp(argv[i],"-maximum_length")==0) || (stricmp(argv[i],"/maximum_length")==0) )
longueur_maxi=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
if ( (stricmp(argv[i],"-characters")==0) || (stricmp(argv[i],"/characters")==0) )
tableau_des_caracteres=argv[i+1];
if ( (stricmp(argv[i],"-save_name")==0) || (stricmp(argv[i],"/save_name")==0) )
fichier_a_sauvegarder=argv[i+1];
if ( (stricmp(argv[i],"-load_name")==0) || (stricmp(argv[i],"/load_name")==0) )
chargement(argv[i+1]);
// ********************************************************
// Choix Dictionnaire
// ********************************************************
if ( (stricmp(argv[i],"-dictionnary")==0) || (stricmp(argv[i],"/dictionnary")==0) )
if (strtod(argv[i+1],&caractere_non_convertit)==0)
dicionnaire_active=false;
else
dicionnaire_active=true;
if ( (stricmp(argv[i],"-file_name_dico")==0) || (stricmp(argv[i],"/file_name_dico")==0) )
fichier_du_dico=argv[i+1];
if ( (stricmp(argv[i],"-variable_before")==0) || (stricmp(argv[i],"/variable_before")==0) )
nombre_de_variation_avant=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
if ( (stricmp(argv[i],"-variable_after")==0) || (stricmp(argv[i],"/variable_after")==0) )
nombre_de_variation_apres=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
if ( (stricmp(argv[i],"-variable_characters")==0) || (stricmp(argv[i],"/variable_characters")==0) )
tableau_des_caracteres_variant=argv[i+1];
if ( (stricmp(argv[i],"-capital_letter")==0) || (stricmp(argv[i],"/capital_letter")==0) )
if (strtod(argv[i+1],&caractere_non_convertit)==0)
minuscule=false;
else
minuscule=true;
}
}
void hash_brute_force(void)
{
int tableau_compteur[256]; // Permet de suivre l'incrémentation des caractères du mot
unsigned int compteur_de_sortie;
unsigned int i,j;
unsigned nombre_de_caractere;
// ********************************************************
// Initialisation du tableau
// ********************************************************
if (chaine_de_demarrage[0]=='\0')
{
for (i=0;i<256;i++)
tableau_compteur[i]=-1;
tableau_compteur[0]=0;
}
else
{
// ********************************************************
// Reprend les positions du mot de démarrage
// ********************************************************
for (i=0;i<strlen(chaine_de_demarrage);i++)
for (j=0;j<strlen(tableau_des_caracteres);j++)
if (chaine_de_demarrage[i]==tableau_des_caracteres[j])
tableau_compteur[strlen(chaine_de_demarrage)-1-i]=j;
// ********************************************************
// Fini le tableau des position par -1
// ********************************************************
for (i=(int)strlen(chaine_de_demarrage);i<256;i++)
tableau_compteur[i]=-1;
// ********************************************************
// Copy le mot de démarrage dans le mot_brut_force qui sera traité
// ********************************************************
memcpy(mot_brut_force,chaine_de_demarrage,strlen(chaine_de_demarrage));
}
// ********************************************************
// Boucle
// ********************************************************
while (!sortie_boucles&&!la_chaine_est_trouvee)
{
// ********************************************************
// Initialisation des compteurs de suivi
// ********************************************************
compteur_de_sortie=0;
nombre_de_caractere=0;
// ********************************************************
// Compte le nombre de caractere à afficher
// ********************************************************
for (i=0;i<longueur_maxi;i++)
if (tableau_compteur[i]!=-1)
nombre_de_caractere++;
// ********************************************************
// Recupération du mot en inverse
// ********************************************************
for (i=0;i<nombre_de_caractere;i++)
if (tableau_compteur[i]!=-1)
mot_brut_force[nombre_de_caractere-1-i]=tableau_des_caracteres[tableau_compteur[i]];
mot_brut_force[nombre_de_caractere]='\0';
if ( (nombre_de_variation_avant!=0) && (nombre_de_variation_apres!=0) )
// ********************************************************
// Ajoute le mot du dictionnaire au début et à la fin
// ********************************************************
{
size_t len_brut=strlen(mot_brut_force);
size_t len_dico=strlen(mot_dictionnaire);
char brut[100];
strcpy(brut,mot_brut_force);
if (len_brut<=nombre_de_variation_avant)
{
memcpy(mot_brut_force+len_brut,mot_dictionnaire,len_dico);
mot_brut_force[len_brut+len_dico]='\0';
}
else
{
memcpy(mot_brut_force+nombre_de_variation_avant,mot_dictionnaire,len_dico);
memcpy( mot_brut_force+ nombre_de_variation_avant+ len_dico,brut+nombre_de_variation_avant, len_brut-nombre_de_variation_avant);
mot_brut_force[len_dico+len_brut]='\0';
}
}
else if (nombre_de_variation_avant!=0)
// ********************************************************
// Ajoute le mot du dictionnaire à la fin
// ********************************************************
{
memcpy(mot_brut_force+ strlen(mot_brut_force), mot_dictionnaire,strlen(mot_dictionnaire));
mot_brut_force[strlen(mot_brut_force)+strlen(mot_dictionnaire)]='\0';
}
else if (nombre_de_variation_apres!=0)
// ********************************************************
// Ajoute le mot du dictionnaire au début
// ********************************************************
{
memcpy(mot_brut_force+ strlen(mot_dictionnaire), mot_brut_force,strlen(mot_brut_force)+1);
memcpy(mot_brut_force,mot_dictionnaire,strlen(mot_dictionnaire));
mot_brut_force[strlen(mot_dictionnaire)+strlen(mot_brut_force)]='\0';
}
// ********************************************************
// Incrémentation du tableau
// ********************************************************
for (i=0;i<longueur_maxi;i++)
{
if (compteur_de_sortie==i)
tableau_compteur[i]++;
if (tableau_compteur[i]==(int)strlen(tableau_des_caracteres))
{
tableau_compteur[i]=0;
compteur_de_sortie++;
}
}
// ********************************************************
// Condition de sortie
// ********************************************************
if (compteur_de_sortie==longueur_maxi)
sortie_boucles=true;
// ********************************************************
// Cryptage du mot
// ********************************************************
cryptage(mot_brut_force);
// ********************************************************
// Comparaison
// ********************************************************
if (strcmp(mot_hasher,enable_secret)==0)
la_chaine_est_trouvee=true;
}
// ********************************************************
// Initialise la condition de boucle pour la prochaine utilisation (cas du disco variant)
// ********************************************************
sortie_boucles=false;
}
void hash_dictionnaire(void)
{
size_t positionnement_du_retour_charriot;
bool est_ce_une_lettre=false;
// ********************************************************
// Ouverture du dictionnaire en mode lecture et mode texte
// ********************************************************
pointeur_vidage_dico=fopen(fichier_du_dico,"rt");
// ********************************************************
// Boucle parcourrant le dicotionnaire
// ********************************************************
while(!feof(pointeur_vidage_dico)&&!la_chaine_est_trouvee)
{
// ********************************************************
// Récupération de la ligne en cours
// ********************************************************
fgets(mot_dictionnaire,400,pointeur_vidage_dico);
// ********************************************************
// Supprime le retour charriot à la fin des lignes
// ********************************************************
positionnement_du_retour_charriot=strlen(mot_dictionnaire)-1; // Permet d'éviter d'utiliser deux fois strlen
if (mot_dictionnaire[positionnement_du_retour_charriot]==10)
mot_dictionnaire[positionnement_du_retour_charriot]='\0';
// ********************************************************
// Définit si le premier caractère est une lettre
// ********************************************************
if ( (mot_dictionnaire[0]>=65)&&(mot_dictionnaire[0]<=90) || (mot_dictionnaire[0]>=97)&&(mot_dictionnaire[0]<=122) )
est_ce_une_lettre=true;
else
est_ce_une_lettre=false;
if ( (nombre_de_variation_avant!=0) || (nombre_de_variation_apres!=0) )
// ********************************************************
// Varation du mot en ajoutant des caracteres à la fin
// ********************************************************
{
tableau_des_caracteres=tableau_des_caracteres_variant;
longueur_maxi=nombre_de_variation_avant+nombre_de_variation_apres;
strcpy(mot_brut_force,mot_dictionnaire); // La sauvegarde se base sur mot_brut_force
// ********************************************************
// Test le mot du dictionnaire avant de passer à sa variation
// ********************************************************
cryptage(mot_dictionnaire);
// ********************************************************
// Passe à sa variation si c'est pas trouvé
// ********************************************************
if (strcmp(mot_hasher,enable_secret)!=0)
// ********************************************************
// Variation du mot
// ********************************************************
hash_brute_force();
}
else if (minuscule==true)
// ********************************************************
// Varation du mot en modifiant toutes les lettres Minuscule et Majuscule
// ********************************************************
{
strcpy(mot_brut_force,mot_dictionnaire); // La sauvegarde se base sur mot_brut_force
variation_majuscule(mot_dictionnaire);
}
else
{
// ********************************************************
// Pas de varation. Traitement normal du mot
// ********************************************************
strcpy(mot_brut_force,mot_dictionnaire); // La sauvegarde se base sur mot_brut_force
cryptage(mot_dictionnaire);
}
// ********************************************************
// Comparaison
// ********************************************************
if (strcmp(mot_hasher,enable_secret)==0)
la_chaine_est_trouvee=true;
}
}
DWORD WINAPI interception_des_touches(LPVOID lpParameter)
{
int i;
int depart_de_la_mesure;
int compteur_courrant;
// ********************************************************
// Affichage des possibilités
// ********************************************************
printf ("\n(s)-Statistiques (b)backup (q)-Quit\n\n");
// ********************************************************
// Boucle d'interception des touches
// ********************************************************
while (sortie_boucles==false)
{
switch (getch())
{
case 's':
affichage_des_statistiques();
printf("\nWord per second : .");
depart_de_la_mesure=GetTickCount();
compteur_courrant=compteur;
for (i=0;i<10;i++)
{
Sleep(300);
printf(".");
}
printf(" %d/s\n", ((1000*(compteur-compteur_courrant))/ (GetTickCount()-depart_de_la_mesure)));
break;
case 'q':
printf("\n");
sauvegarde();
sortie_boucles=true;
break;
case 'b':
sauvegarde();
break;
}
}
return 0;
}
void affichage_des_statistiques(void)
{
int jour,heure,minute,seconde;
int tempo;
// ********************************************************
// Calcul des variables
// ********************************************************
tempo=(GetTickCount()-heure_de_depart);
jour=tempo/(1000*60*60*24);
heure=(tempo%(1000*60*60*24))/(1000*60*60); // % signifie modulo. c'est à dire le reste de la division entière
minute=(tempo%(1000*60*60))/(1000*60);
seconde=(tempo%(1000*60))/(1000);
// ********************************************************
// Affichage des statistiques
// ********************************************************
printf("\nTest number : %d",compteur);
printf("\nLast word : %s",mot_brut_force);
printf("\nTime from begin : %d day and %.2d:%.2d:%.2d",jour,heure,minute,seconde);
}
void sauvegarde(void)
{
FILE *pointeur_du_fichier_sauvegarde; // Déclare le pointeur de fichier pour enregistrer la position
// ********************************************************
// Ouverture du fichier
// ********************************************************
pointeur_du_fichier_sauvegarde=fopen(fichier_a_sauvegarder,"w");
// ********************************************************
// Ecris les poisitions
// ********************************************************
fprintf(pointeur_du_fichier_sauvegarde,"%d\n",longueur_maxi);
fprintf(pointeur_du_fichier_sauvegarde,"%s\n",mot_brut_force);
fprintf(pointeur_du_fichier_sauvegarde,"%d\n",compteur);
fprintf(pointeur_du_fichier_sauvegarde,"%d",GetTickCount()-heure_de_depart);
// ********************************************************
// Ferme le fichier
// ********************************************************
fclose(pointeur_du_fichier_sauvegarde);
// ********************************************************
// Message d'information
// ********************************************************
printf ("Sauvegarde du mot %s effectuee dans le fichier : %s\n", mot_brut_force,fichier_a_sauvegarder);
}
void chargement(char * fichier_a_charger)
{
char *caractere_non_convertit;
FILE *pointeur_du_fichier_chargement; // Déclare le pointeur de fichier pour enregistrer la position
char contenu_de_la_ligne[400]="";
// ********************************************************
// Ouverture du dictionnaire en mode lecture et mode texte
// ********************************************************
pointeur_du_fichier_chargement=fopen(fichier_a_charger,"rt");
// ********************************************************
// Récupération de la ligne 1 : La longueur Maxi
// ********************************************************
fgets(contenu_de_la_ligne,400,pointeur_du_fichier_chargement);
longueur_maxi=(unsigned short)strtod(contenu_de_la_ligne,&caractere_non_convertit);
// ********************************************************
// Récupération de la ligne 2 : Le mot de démarrage
// ********************************************************
fgets(chaine_de_demarrage,400,pointeur_du_fichier_chargement);
chaine_de_demarrage[strlen(chaine_de_demarrage)-1]='\0'; // Supprime le retour charriot
// ********************************************************
// Récupération de la ligne 3 : Le compteur
// ********************************************************
fgets(contenu_de_la_ligne,400,pointeur_du_fichier_chargement);
compteur=(int)strtod(contenu_de_la_ligne,&caractere_non_convertit);
// ********************************************************
// Récupération de la ligne 4 : Le temps
// ********************************************************
fgets(contenu_de_la_ligne,400,pointeur_du_fichier_chargement);
heure_de_depart=(int)strtod(contenu_de_la_ligne,&caractere_non_convertit);
printf("\nMot : %s",chaine_de_demarrage);
printf("\ncompteur : %d",compteur);
printf("\nTemps : %d",heure_de_depart);
// ********************************************************
// Ferme le fichier
// ********************************************************
fclose(pointeur_du_fichier_chargement);
}
void variation_majuscule(char * mot_a_varier)
{
size_t longueur;
unsigned compteur_tampon;
unsigned int i,j;
unsigned int tampon;
char * mot_en_cours_de_variation;
mot_en_cours_de_variation=(char *)malloc(100);
longueur=strlen(mot_a_varier);
compteur_tampon=2<<(longueur-1); // Equivalent à (int)pow(2,longueur); (2 exposant longueur)
// ********************************************************
// Passe la chaine en minuscule
// ********************************************************
strcpy(mot_a_varier,strlwr(mot_a_varier));
// ********************************************************
// Boucle parcourrant toutes les combinaisons
// ********************************************************
for (i=0;i<compteur_tampon;i++)
{
strcpy(mot_en_cours_de_variation,mot_a_varier);
for (j=0;j<longueur;j++)
{
tampon=i;
tampon=tampon>>j;
tampon=tampon&1;
if ( (tampon==1) && (mot_en_cours_de_variation[j]>=97) && (mot_en_cours_de_variation[j]<=122) )
mot_en_cours_de_variation[j]=mot_en_cours_de_variation[j]-32;
}
// ********************************************************
// Cryptage du mot varié
// ********************************************************
cryptage(mot_en_cours_de_variation);
// ********************************************************
// Comparaison
// ********************************************************
if (strcmp(mot_hasher,enable_secret)==0)
{
// ********************************************************
// Permet que ce soit le mot en cour de variation qui sera affiché comme trouvé
// ********************************************************
strcpy(mot_brut_force,mot_en_cours_de_variation);
// ********************************************************
// Quitte la boucle FOR
// ********************************************************
break;
}
}
}
void cryptage(char * tampon_mot_de_passe)
{
// ********************************************************
// Cryptage MD5 avec le Salt
// ********************************************************
mot_hasher=md5_crypt(tampon_mot_de_passe,salt);
// ********************************************************
// Affichage du Hash
// ********************************************************
if (view==true)
printf("%s-%s\n",tampon_mot_de_passe,mot_hasher);
// ********************************************************
// Incrémente le compteur pour connaitre le nombre de hash effectué
// ********************************************************
compteur++;
}
char * md5_crypt(const char * pw, const char * salt)
{
static char base64[]=
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
struct MD5_CONTEXT outer_context, inner_context;
MD5_DIGEST digest;
unsigned pwl=strlen(pw);
unsigned l;
unsigned i, j;
char *p;
static char buffer[100];
if (*salt == '$' && salt[1] == '1' && salt[2] == '$')
salt += 3;
for (l=0; l<8 && salt[l] && salt[l] != '$'; l++);
md5_context_init(&inner_context);
md5_context_hashstream(&inner_context, pw, pwl);
md5_context_hashstream(&inner_context, salt, l);
md5_context_hashstream(&inner_context, pw, pwl);
md5_context_endstream(&inner_context, pwl*2+l);
md5_context_digest(&inner_context, digest);
md5_context_init(&outer_context);
md5_context_hashstream(&outer_context, pw, pwl);
md5_context_hashstream(&outer_context, "$1$", 3);
md5_context_hashstream(&outer_context, salt, l);
for (i=pwl; i; )
{
j=i;
if (j > 16) j=16;
md5_context_hashstream(&outer_context, digest, j);
i -= j;
}
j=pwl*2+l+3;
for (i=pwl; i; i >>= 1)
{
md5_context_hashstream(&outer_context, (i & 1) ? "": pw, 1);
++j;
}
md5_context_endstream(&outer_context, j);
md5_context_digest(&outer_context, digest);
for (i=0; i<1000; i++)
{
j=0;
md5_context_init(&outer_context);
if (i & 1)
{
md5_context_hashstream(&outer_context, pw, pwl);
j += pwl;
}
else
{
md5_context_hashstream(&outer_context, digest, 16);
j += 16;
}
if (i % 3)
{
md5_context_hashstream(&outer_context, salt, l);
j += l;
}
if (i % 7)
{
md5_context_hashstream(&outer_context, pw, pwl);
j += pwl;
}
if (i & 1)
{
md5_context_hashstream(&outer_context, digest, 16);
j += 16;
}
else
{
md5_context_hashstream(&outer_context, pw, pwl);
j += pwl;
}
md5_context_endstream(&outer_context, j);
md5_context_digest(&outer_context, digest);
}
strcpy(buffer, "$1$");
strncat(buffer, salt, l);
strcat(buffer, "$");
p=buffer+strlen(buffer);
for (i=0; i<5; i++)
{
unsigned char *d=digest;
j= (d[i] << 16) | (d[i+6] << 8) | d[i == 4 ? 5:12+i];
*p++= base64[j & 63] ; j=j >> 6;
*p++= base64[j & 63] ; j=j >> 6;
*p++= base64[j & 63] ; j=j >> 6;
*p++= base64[j & 63];
}
j=digest[11];
*p++ = base64[j & 63]; j=j >> 6;
*p++ = base64[j & 63];
*p=0;
return (buffer);
}
6 – Les vidéos
6.1 - What is a brute force attack ?
Cette video en anglais vous présente ce qu'est un brute force. There are sophisticated and complex attacks that can be launched against various modern cryptosystems. But you could also just try banging the door down. A brute force attack consists of an attack just repeatedly trying to break a system: for example, by guessing passwords. However, brute force attacks can be somewhat sophisticated and work at least some of the time.
7 – Discussion autour de l’outil de brut force du mot de passe EnableSecret Cisco
Vous pouvez poser toutes vos questions, faire part de vos remarques et partager vos expériences à propos de l’outil de brut force du mot de passe EnableSecret Cisco. Pour cela, n’hésitez pas à laisser un commentaire ci-dessous :
Commentaire et discussion