Générateur de clés sur 26 digits au format hexadécimal

Soyez le premier à donner votre avis sur cette source.

Snippet vu 6 525 fois - Téléchargée 21 fois

Contenu du snippet

Bonjour,

Pour m'amuser( parce que oui c'est marrant xD ), je me suis dis que je devrais créer un petit algorithme pour générer toutes les combinaisons de clés sur 26 digits au format hexadécimal.

A moins d'avoir un Supercalculateur et un disque dur d'environ beaucoup de To, il ne sera pas vraiment possible de tous générer/stocker.

Ceci dit, on peut réutiliser ce code pour générer certaines clés aléatoirement.

Il y a une petite interface, qui indique la progression du calcul, la taille courante du fichier stockant les clés, le temps de calculs écoulé, le temps de calcul restant ainsi que la vitesse de calcul du processeur. On peut voir ce que cela donne grâce à la petite image de présentation.

Source / Exemple :


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

void FORMAT_SECONDE(double CURRENT_TIME, double *YEAR, double *DAY, double *HOUR, double *MINUTE, double *SECONDE);
void ECRIRE( FILE *FICHIER, int VALEUR );

int main()
{

    // Paramètres affichage console
    system("title GENERATEUR CLES 26 DIGITS");
    system("COLOR 09");
    system("MODE CON COLS=60 LINES=19");

    // Variables representant chacun des 26 digits de la clef WEP codée en Hexadecimal, donc DXX prendra ses valeurs dans 0->15
    int D01, D02, D03, D04, D05, D06, D07, D08 , D09, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26;

    // Fichier de stockage des clés
    FILE *F0=fopen("CLE.txt","w");
    if (F0 == NULL)
    {
        printf("Echec du fopen sur file F0 (CLE.txt) : %s.\n", strerror(errno));
        exit(EXIT_FAILURE);
    }

    // On récupère la valeur de GetTickCount pour avoir la référence à 0 au commencement du bouclage
    double INIT_TIME=GetTickCount();

    // On initialise le compteur de boucles à 0. Il servira à faire apparaître des données sur l'avancement de la génération
    double COMPTEUR_BOUCLE=0;

    // Taille initiale du fichier de stockage des clés
    double TAILLE=0;

    // Valeur initiale de la variable de contrôle pour l'affichage des données résultantes de la génération
    double AFFICHER=0;

    // Nombres de clés WEP totales /1000000 ( petit artifice pour stocker la variable alors trop grande )
    double K=20282409603651670423947251.286016;

    // Début de la génération
    for ( D01=0 ; D01<16 ; D01++ )
        for ( D02=0 ; D02<16 ; D02++ )
            for ( D03=0 ; D03<16 ; D03++ )
                for ( D04=0 ; D04<16 ; D04++ )
                    for ( D05=0 ; D05<16 ; D05++ )
                        for ( D06=0 ; D06<16 ; D06++ )
                            for ( D07=0 ; D07<16 ; D07++ )
                                for ( D08=0 ; D08<16 ; D08++ )
                                    for ( D09=0 ; D09<16 ; D09++ )
                                        for ( D10=0 ; D10<16 ; D10++ )
                                            for ( D11=0 ; D11<16 ; D11++ )
                                                for ( D12=0 ; D12<16 ; D12++ )
                                                    for ( D13=0 ; D13<16 ; D13++ )
                                                        for ( D14=0 ; D14<16 ; D14++ )
                                                            for ( D15=0 ; D15<16 ; D15++ )
                                                                for ( D16=0 ; D16<16 ; D16++ )
                                                                    for ( D17=0 ; D17<16 ; D17++ )
                                                                        for ( D18=0 ; D18<16 ; D18++ )
                                                                            for ( D19=0 ; D19<16 ; D19++ )
                                                                                for ( D20=0 ; D20<16 ; D20++ )
                                                                                    for ( D21=0 ; D21<16 ; D21++ )
                                                                                        for ( D22=0 ; D22<16 ; D22++ )
                                                                                            for ( D23=0 ; D23<16 ; D23++ )
                                                                                                for ( D24=0 ; D24<16 ; D24++ )
                                                                                                     for ( D25=0 ; D25<16 ; D25++ )
                                                                                                         for ( D26=0 ; D26<16 ; D26++ )
                                                                                                             {

                                                                                                                     // Fonction qui envoit la valeur du digit en décimal, donne sa correspondance hexadécimal
                                                                                                                     ECRIRE(F0, D01);
                                                                                                                     ECRIRE(F0, D02);
                                                                                                                     ECRIRE(F0, D03);
                                                                                                                     ECRIRE(F0, D04);
                                                                                                                     ECRIRE(F0, D05);
                                                                                                                     ECRIRE(F0, D06);
                                                                                                                     ECRIRE(F0, D07);
                                                                                                                     ECRIRE(F0, D08);
                                                                                                                     ECRIRE(F0, D09);
                                                                                                                     ECRIRE(F0, D10);
                                                                                                                     ECRIRE(F0, D11);
                                                                                                                     ECRIRE(F0, D12);
                                                                                                                     ECRIRE(F0, D13);
                                                                                                                     ECRIRE(F0, D14);
                                                                                                                     ECRIRE(F0, D15);
                                                                                                                     ECRIRE(F0, D16);
                                                                                                                     ECRIRE(F0, D17);
                                                                                                                     ECRIRE(F0, D18);
                                                                                                                     ECRIRE(F0, D19);
                                                                                                                     ECRIRE(F0, D20);
                                                                                                                     ECRIRE(F0, D21);
                                                                                                                     ECRIRE(F0, D22);
                                                                                                                     ECRIRE(F0, D23);
                                                                                                                     ECRIRE(F0, D24);
                                                                                                                     ECRIRE(F0, D25);

                                                                                                                    // Une clé pèse 26 octets, à chaque tour de boucle on incrémente la taille du fichier de la taille d'une clé
                                                                                                                    TAILLE+=26;

                                                                                                                    // On convertit la taille en octets en Go ou Mo
                                                                                                                    double TAILLE_GO=TAILLE/(1024*1024);

                                                                                                                    // Variable qui compte le nombre de tours de boucles
                                                                                                                    COMPTEUR_BOUCLE++;

                                                                                                                    // Variable qui compte le temps écoulé depuis le début du programme en seconde
                                                                                                                    double CURRENT_TIME = (GetTickCount()-INIT_TIME)/1000;

                                                                                                                    // Variable qui compte la vitesse de calcul du processeur
                                                                                                                    double CALCUL_SEC   = COMPTEUR_BOUCLE/CURRENT_TIME;

                                                                                                                    // Variable qui compte le temps de calcul restant en seconde
                                                                                                                    double TIME_LEFT=(K-COMPTEUR_BOUCLE)/CALCUL_SEC;

                                                                                                                    double *ANNEES   = (double *)malloc(sizeof(double));
                                                                                                                    double *JOURS    = (double *)malloc(sizeof(double));
                                                                                                                    double *HEURES   = (double *)malloc(sizeof(double));
                                                                                                                    double *MINUTES  = (double *)malloc(sizeof(double));
                                                                                                                    double *SECONDES = (double *)malloc(sizeof(double));

                                                                                                                    // Fonction qui formate les secondes du temps écoulé en année, jour...
                                                                                                                    FORMAT_SECONDE(CURRENT_TIME, ANNEES, JOURS, HEURES, MINUTES, SECONDES);

                                                                                                                    double *TL_ANNEES   = (double *)malloc(sizeof(double));
                                                                                                                    double *TL_JOURS    = (double *)malloc(sizeof(double));
                                                                                                                    double *TL_HEURES   = (double *)malloc(sizeof(double));
                                                                                                                    double *TL_MINUTES  = (double *)malloc(sizeof(double));
                                                                                                                    double *TL_SECONDES = (double *)malloc(sizeof(double));

                                                                                                                    // Fonction qui formate le temps de calcul restant en année, jour...
                                                                                                                    FORMAT_SECONDE(TIME_LEFT, TL_ANNEES, TL_JOURS, TL_HEURES, TL_MINUTES, TL_SECONDES);

                                                                                                                    // Variable qui compte la progression totale du calcul
                                                                                                                    double PROGRESSION=(COMPTEUR_BOUCLE)/(10000*K);

                                                                                                                    // Si la taille actuelle du fichier qui stock les clés est superieure à la taille définit pour afficher
                                                                                                                    //l'état d'avancement du calcul, alors on affiche sinon on attend la nouvelle valeur d'affichage
                                                                                                                    if ( TAILLE_GO>AFFICHER )
                                                                                                                       {
                                                                                                                           printf("\n+ PROGRESSION         : %.30f %% \n\n+ TAILLE              : %.0f Mo \n\n+ CALCUL/S            : %.0f \n\n+ TEMPS DE TRAITEMENT : %.0f ANNEE \n                        %.0f JOUR \n                        %.0f HEURE \n                        %.0f MINUTE \n                        %.0f SECONDE \n\n+ TEMPS RESTANT       : %.0f ANNEE \n                        %.0f JOUR \n                        %.0f HEURE \n                        %.0f MINUTE \n                        %.0f SECONDE \n-----------------------------------------------------------", PROGRESSION, TAILLE_GO, CALCUL_SEC, *ANNEES, *JOURS, *HEURES, *MINUTES, *SECONDES, *TL_ANNEES , *TL_JOURS, *TL_HEURES, *TL_MINUTES, *TL_SECONDES );
                                                                                                                           AFFICHER+=10;
                                                                                                                       }

                                                                                                                    // On libère la mémoire allouée aussi tôt le calcul fait pour ne pas saturer la ram
                                                                                                                    free(ANNEES     );
                                                                                                                    free(JOURS      );
                                                                                                                    free(HEURES     );
                                                                                                                    free(MINUTES    );
                                                                                                                    free(SECONDES   );
                                                                                                                    free(TL_ANNEES  );
                                                                                                                    free(TL_JOURS   );
                                                                                                                    free(TL_HEURES  );
                                                                                                                    free(TL_MINUTES );
                                                                                                                    free(TL_SECONDES);

                                                                                                                    }
        fclose(F0);
}

void ECRIRE( FILE *FICHIER, int VALEUR )
{

     // Si la valeur du digit est inférieure à 9 sa correspondance hexadecimale de change pas
     if ( VALEUR<=9 )
        {
              fprintf(FICHIER, "%d", VALEUR);
        }

     // Si la valeur du digit est supérieure à 9, on cherche la lettre correspandante.
     if ( VALEUR>9 )
        {

                          if ( VALEUR==10 )
                          {
                                            fprintf(FICHIER,"A");
                          }

                          if ( VALEUR==11 )
                          {
                                            fprintf(FICHIER,"B");
                          }

                          if ( VALEUR==12 )
                          {
                                            fprintf(FICHIER,"C");
                          }

                          if ( VALEUR==13 )
                          {
                                            fprintf(FICHIER,"D");
                          }

                          if ( VALEUR==14 )
                          {
                                            fprintf(FICHIER,"E");
                          }

                          if ( VALEUR==15 )
                          {
                                            fprintf(FICHIER,"F");
                          }

        }
}

void FORMAT_SECONDE(double TIME, double *YEAR, double *DAY, double *HOUR, double *MINUTE, double *SECONDE)
{
     double K_YEAR   = 31536000;
     double K_DAY    = 86400   ;
     double K_HOUR   = 3600    ;
     double K_MINUTE = 60      ;

  • YEAR = floor( TIME/K_YEAR );
  • DAY = floor( (TIME - (*YEAR)*K_YEAR )/K_DAY );
  • HOUR = floor( (TIME - (*YEAR)*K_YEAR - (*DAY)*K_DAY )/K_HOUR );
  • MINUTE = floor( (TIME - (*YEAR)*K_YEAR - (*DAY)*K_DAY - (*HOUR)*K_HOUR)/K_MINUTE );
  • SECONDE = TIME - (*YEAR)*K_YEAR - (*DAY)*K_DAY - (*HOUR)*K_HOUR - (*MINUTE)*K_MINUTE;
}

Conclusion :


En l'état, le code n'est peut être pas très utile, peut être un peu formateur ou pas. Mais il peut être réutiliser/détourner à votre propre objectif.

A vous de juger. Cordialement.

A voir également

Ajouter un commentaire Commentaires
Messages postés
6
Date d'inscription
samedi 28 octobre 2006
Statut
Membre
Dernière intervention
25 avril 2010

Salut,

Tu as 8 malloc dans 26 for imbriques, cherches une autre methode pour virer ses malloc tu verra que ca ira baucoup mais alors beaucoup plus vite ;)
Messages postés
3983
Date d'inscription
jeudi 14 juillet 2005
Statut
Membre
Dernière intervention
30 juin 2013
14
Est-ce que ça ne serait pas plus simple de remplacer ta fonction ECRIRE() par un bête fprintf(FICHIER,"%x",VALEUR); ?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.