Générateur de clés sur 26 digits au format hexadécimal
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.
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.
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
- Générateur de clés sur 26 digits au format hexadécimal
- Delphi format - Conseils pratiques -Delphi
- Couleur hexadecimal - Forum C# / .NET
- Générateur de nombre ✓ - Forum PHP
- Generateur de nom de jeu ✓ - Forum Flash
- Générateur de lettre ✓ - Forum VB.NET
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.