[C/C++] BruteForce

[InstinctHack]

Salut,

Je vous interdit de dire que je radote :p Mon code en python marchais super, mais j'aurais voulu obtenir une réponse avant que mes dents tombent :>
Alors je propose de trancrire mon code en C ou C++

Les codes sont testés sur une machine portable IntelPentium Dual-Core inside avec 2go de ram

khaled@loopinfinity:~/$ dmesg | grep BogoMIPS
[ 0.004006] Calibrating delay loop (skipped), value calculated using timer frequency.. 3990.35 BogoMIPS (lpj=7980700)
[ 0.084099] Total of 2 processors activated (7980.70 BogoMIPS).

Les options de compilations sont les suivantes :

Code :

gcc -std=c99 -lssl -lcrypto file.c -o file

Et les calculs réalisés sont :
20 2
10 10

En Python

J'ai refait le code en python, mais sans déléguer la génération de l'itérateur :

Code PYTHON :


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import time
try:
        longueur_chaine_max=int(input("longueur maximun de la chaine : "))
except:
        print("parametre invalide")
else:
        if longueur_chaine_max>0:
                try:
                        longueur_alphabet=int(input("longueur alphabet : "))
                except:
                        print("parametre invalide")
                else:
                        if longueur_alphabet>0:
                                """
                                        L'algo commence vraiment ici
                                        donc les variables sont :
                                                longueur_alphabet
                                                longueur_chaine_max
                                                et longueur_chaine_actuelle
                                """
                                longueur_chaine_actuelle=1
                                combinaison=0
                                start=time.time()
                                while longueur_chaine_actuelle<=longueur_chaine_max:#on parcours toutes les longueurs de chaine possibles
                                        print("Génération de la liste de longueur : "+str(longueur_chaine_actuelle))#un petit message
                                        liste=longueur_chaine_actuelle*[0]#on genere une liste de x zéro, de la longueur de la chaine actuelle
                                        print(liste)#on affiche la combinaison
                                        combinaison+=1
                                        while len([element for element in liste if element==longueur_alphabet-1])!=longueur_chaine_actuelle:#tant que tout les elements de la chaine actuelle ne sont pas égaux à la longeur de l'alphabet-1 (on commence à compter à partir de -1)
                                                liste[-1]+=1#on rajoute une unité au dernier element
                                                for cle,valeur in enumerate(liste):#on parcours les elements
                                                        cle=-(1+cle)#on inverse la cle pour parcourir le tableau à l'invers
                                                        if liste[cle]==longueur_alphabet:#si la valeur dépasse la valeur possible (bah oui, on commence à 0 donc...)
                                                                liste[cle]=0#on la remet à zéro
                                                                liste[cle-1]+=1#et on rajoute la retenu
                                                print(liste)#on affiche la combinaison
                                                combinaison+=1
                                        longueur_chaine_actuelle+=1
                                print(str(combinaison)+" combinaisons générées en "+str(round(time.time()-start,2))+" secondes.")

                        else:
                                print("parametre invalide")
        else:
                print("parametre invalide")
 

2097150 combinaisons générées en 104.11 secondes.

Code C de Khaled

Code C :


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int verif(int *tableau, int tailleTableau,int valeur)
{
        int i;
        for (i = 0 ; i < tailleTableau ; i++)
        {
                if(tableau[i]!=valeur)
                {
                        return -1;
                }
        }
        return 1;
}

void affiche(int *tableau, int tailleTableau,char hash)
{
        char alphabet[]="abcdefghijklmnopqrstuvwxyz";
        char plaintext[200]="";
        int i;
        for(i=0;i<tailleTableau;i++)
        {
                plaintext[i]=alphabet[tableau[i]];
        }
}

int main(int argc, char *argv[])
{
        int longueur_chaine_max = 0;
        int longueur_alphabet=0;
        int longueur_chaine_actuelle=1;
        int *liste;
        int i;
        int parcours;
        char hash;
        printf("Longueur maximun de la chaine : ");
        scanf("%d", &longueur_chaine_max);
        printf("Longueur de l'alphabet :  ");
        scanf("%d", &longueur_alphabet);
        printf("Hash : ");
        scanf("%s", &hash);

        printf("\n");
        while(longueur_chaine_actuelle<=longueur_chaine_max)
        {
                printf("chaine de longueur : %d\n",longueur_chaine_actuelle);
                liste = malloc(longueur_chaine_actuelle * sizeof(int));
                if (liste == NULL){exit(0);}
                for (i = 0 ; i < longueur_chaine_actuelle ; i++){liste[i]=0;}

                affiche(liste,longueur_chaine_actuelle,hash);
                while(verif(liste,longueur_chaine_actuelle,longueur_alphabet-1)!=1)
                {
                        liste[longueur_chaine_actuelle-1]++;
                        for(i=0;i<longueur_chaine_actuelle;i++)
                        {
                                parcours=longueur_chaine_actuelle-1-i;
                                if(liste[parcours]>=longueur_alphabet)
                                {
                                        liste[parcours]=0;
                                        liste[parcours-1]++;
                                }
                        }
                        affiche(liste,longueur_chaine_actuelle,hash);
                }
                free(liste);
                longueur_chaine_actuelle++;
        }
        return 0;
}
 

user 0m0.584s
user [error]


Code C de Gruik

Code C :


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

int main (int argc, char **argv) {
        int pass_len = atoi(argv[1]);
        char *alphabet = (argv[2]);

        if (argc != 3 || pass_len == 0) {
                printf ("Usage  :\n\t%s <pass size> <alphabet>\n", argv[0]);
                return -1;
        }

        int alpha_len = strlen(alphabet);
        unsigned long long nb_iterations = pow(alpha_len, pass_len);

        char *pass_chaine = calloc(pass_len, sizeof(char)); // pour l'output uniquement
        int *pass_interne = calloc(pass_len, sizeof(int));  // pour travailler dessus
        int pos, i;

        /* 1 seule boucle */
        for (i = 0; i < nb_iterations; i++) {
                /* on remplit pass_chaine a l'aide de pass_interne */
                for (pos = 0; pos < pass_len; pos++) pass_chaine[pos] = alphabet[pass_interne[pos]];
                /* on affiche */
                printf ("%s\n", pass_chaine);
                pos--;  // pos = pass_len - 1

                /* on calcule le prochaine pass_interne comme si on faisait simplement "+1" */
                while (1) { /* on veut incrementer le caractere tout a droite */
                        if (pass_interne[pos] != alpha_len-1) { /* si il est != 'z' en gros */
                                pass_interne[pos]++; /* alors on l'incremente betement et on sort du while pour boucler */
                                break;
                        } else { /* sinon on remet la lettre sur 'a' et on voit avec la lettre a sa gauche
                                                et ainsi de suite jusqu'a ce qu'on puisse enfin incrementer */
                                pass_interne[pos] = 0;
                                pos--;
                        }
                }
        }

        /* on libere les ressources */
        free (pass_interne);
        free (pass_chaine);

        return 0;
}
 

Code :

gcc -Wall gruik.c -o gruik -lm
./gruik
Segmentation fault (core dumped)

[gruik]

Code :

$ ./bf-orig
Longueur maximun de la chaine : 5
Longueur de l'alphabet :  6

chaine de longueur : 1
0
chaine de longueur : 2
00
chaine de longueur : 3
000
chaine de longueur : 4
0000
chaine de longueur : 5
00000
9330 combinaisons testées

y'a pas comme un souci avec ton code C ?

[Sh4dows]

Cool, enfin un peu de C
Regardons ça de plus près ...

[Creepy_p0ney]

j'ai fait un code un peu barbare qui génère un dictionnaire de mots de 5 lettres.

Code C :


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

int main(void)
{
        char alphabet[26]="abcdefghijklmnopqrstuvwxyz";
        FILE *fichier;
        fichier=fopen("bruteforce.txt","w+");
        for(int j=0;j<26;j++)
        {
               
                for(int k=0;k<26;k++)
                {
                        for(int i=0;i<26;i++)
                        {
                                for(int l=0;l<26;l++)
                                {                              
                                        for(int m=0;m<26;m++)
                                        {
                                                fprintf(fichier,"%c",alphabet[j]);
                                                fprintf(fichier,"%c",alphabet[k]);
                                                fprintf(fichier,"%c",alphabet[i]);
                                                fprintf(fichier,"%c",alphabet[l]);
                                                fprintf(fichier,"%c",alphabet[m]);
                                                fprintf(fichier,"\n");
                                        }
                                }
                        }
                       
                }
                       
        }
}
 

[InstinctHack]

@gruik moi ça marche, reteste le code que j'ai mis (j'ai peut-etre pas remis le code bien)

@Sh4dows si ça vous motive pour qu'on fasse des trucs ensemble, je fait du c sans problème, je comblerais mes lacunes en plus

@Creepy_p0ney mon code est justement fait pour éviter tous ses boucles, d'accord il ne t'affiche que des nombres, mais en finale, tu as un identificant pour la position de la lettre dans l'alphabet, faux juste creer une table de correspondance comme ASCII, et puis ça voilà

Mon code affiche les caractères au lieu des valeurs (mais le charset est codé en dur, j'aimerais faire comme mon code en python, mais j'ai pas les connaisances pour :p je vais continuer mes recherches)

[gruik]

en 1 seule boucle, le code fait le job mais il est potentiellement pas super propre pour autant, en revanche il est commenté et le principe est assez simple;

on stocke le pass non pas sous la forme d'un tableau de char mais d'un tableau de int, qui représentent en fait pour chaque lettre du pass l'index dans l'alphabet, à partir de là on a plus qu'à faire comme lorsque l'on compte manuellement en décimal; on incrémente le chiffre des unités, si il est à '9' on le remet à '0' et on essaye d'incrémenter le chiffre des dizaines à la place etc.

as usual le plugin code du fofo est pas terrible, je mets donc une copie ici pour plus de lisibilité

Code C :


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

int main (int argc, char **argv) {
        int pass_len = atoi(argv[1]);
        char *alphabet = (argv[2]);

        if (argc != 3 || pass_len == 0) {
                printf ("Usage  :\n\t%s <pass size> <alphabet>\n", argv[0]);
                return -1;
        }

        int alpha_len = strlen(alphabet);
        unsigned long long nb_iterations = pow(alpha_len, pass_len);

        char *pass_chaine = calloc(pass_len, sizeof(char)); // pour l'output uniquement
        int *pass_interne = calloc(pass_len, sizeof(int));  // pour travailler dessus
        int pos, i;

        /* 1 seule boucle */
        for (i = 0; i < nb_iterations; i++) {
                /* on remplit pass_chaine a l'aide de pass_interne */
                for (pos = 0; pos < pass_len; pos++) pass_chaine[pos] = alphabet[pass_interne[pos]];
                /* on affiche */
                printf ("%s\n", pass_chaine);
                pos--;  // pos = pass_len - 1

                /* on calcule le prochaine pass_interne comme si on faisait simplement "+1" */
                while (1) { /* on veut incrementer le caractere tout a droite */
                        if (pass_interne[pos] != alpha_len-1) { /* si il est != 'z' en gros */
                                pass_interne[pos]++; /* alors on l'incremente betement et on sort du while pour boucler */
                                break;
                        } else { /* sinon on remet la lettre sur 'a' et on voit avec la lettre a sa gauche
                                                et ainsi de suite jusqu'a ce qu'on puisse enfin incrementer */
                                pass_interne[pos] = 0;
                                pos--;
                        }
                }
        }

        /* on libere les ressources */
        free (pass_interne);
        free (pass_chaine);

        return 0;
}
 

edit: je viens de voir ton dernier code Khaled, il semble fonctionner comme prévu
edit2: aussi je précise au cas où un exemple d'invocation pour lancer le miens :

Code :

$ ./pouet.exe 3 abc
aaa
aab
aac
aba
abb
(...)
cbb
cbc
cca
ccb
ccc
$ ./pouet.exe 4 01
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

[Creepy_p0ney]

gruik pas mal ton code, c'est ce que je cherchais à faire masi je savais pas comment

[InstinctHack]

@gruik compile pas chez moi ton code

khaled@loopinfinity:~/LIFE/Informatique/Programmation/C/bruceforce$ gcc gruik.c -o gruik
/tmp/ccWwMAoj.o: In function `main':
gruik.c.text+0x7a): undefined reference to `pow'
collect2: error: ld returned 1 exit status

sinon comparatif de deux algos ?

[Sh4dows]

Code :

root@VPS1-Debian:/home/sh4dows# ./a.out 5
Usage  : ./a.out <pass size> <alphabet>
root@VPS1-Debian:/home/sh4dows# ./a.out
Segmentation fault
root@VPS1-Debian:/home/sh4dows# ./a.out 2 "az"
aa
az
za
zz
*** glibc detected *** ./a.out: munmap_chunk(): invalid pointer:
...
Aborted

J'ai corrigé les petits bug, a l'exception de l'erreur glibc qui arrive quand tu free pass_interne.

Code C :


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

int     main (int argc, char *argv[])
{
  int   pass_len;
  char  *alphabet;

  if (argc < 2 +1 || atoi(argv[1]) <= 0 || strlen(argv[2]) <= 0) {
    printf ("Usage  : %s <pass size> <alphabet>\n", argv[0]);
    return -1;
  }
  pass_len = atoi(argv[1]);
  alphabet = argv[2];
  int   alpha_len = strlen(alphabet);
  unsigned long long nb_iterations = pow(alpha_len, pass_len);
  char *pass_chaine;
  if ((pass_chaine = calloc(pass_len, sizeof(char))) == NULL) // pour l'output uniquement
      return (1);
  int *pass_interne;
  if ((pass_interne = calloc(pass_len, sizeof(int))) == NULL)  // pour travailler dessus
    return (1);
  int pos, i;

  /* 1 seule boucle */
  for (i = 0; i < nb_iterations; i++) {
    /* on remplit pass_chaine a l'aide de pass_interne */
    for (pos = 0; pos < pass_len; pos++) pass_chaine[pos] = alphabet[pass_interne[pos]];
    /* on affiche */
    printf ("%s\n", pass_chaine);
    pos--;  // pos = pass_len - 1

    /* on calcule le prochaine pass_interne comme si on faisait simplement "+1" */
    while (1) { /* on veut incrementer le caractere tout a droite */
      if (pass_interne[pos] != alpha_len-1) { /* si il est != 'z' en gros */
        pass_interne[pos]++; /* alors on l'incremente betement et on sort du while pour boucler */
        break;
      } else { /* sinon on remet la lettre sur 'a' et on voit avec la lettre a sa gauche
                  et ainsi de suite jusqu'a ce qu'on puisse enfin incrementer */
        pass_interne[pos] = 0;
        pos--;
      }
    }
  }

  /* on libere les ressources */
  //free (pass_interne);
  free (pass_chaine);

  return 0;
}
 

Khaled, pour compiler il faut ajouter la lib math du coup

Code :

gcc *.c -lm

[gruik]

faut linker avec la lib math

Code :

gcc -Wall gruik.c -o gruik -lm

sinon pour ce qui est du comparatif globalement on utilise tous les deux la même technique, la différence c'est que tu fais pleins de malloc/free dans des boucles là où j'en fait que 2 au début et à la fin uniquement, potentiellement ça peut faire perdre pas mal de temps à ton algo, difficile à dire, perso j'aurais plus tendance à peaufiner le code pour qu'il fonctionne 100% correctement (c'est pas le cas du mien par exemple, mais il est plus souple, j'ai pas regardé pour le tiens) et ensuite seulement chercher l'optimisation éventuelle, sachant que c'est très contextuel
une bonne façons d'aller vite c'est de pas faire de printf ou de rediriger dans un fichier déjà...

edit: nice sh4dows, thx

[InstinctHack]

root@loopinfinity:/home/khaled/LIFE/Informatique/Programmation/C/bruceforce# gcc -Wall gruik.c -o gruik -lm
root@loopinfinity:/home/khaled/LIFE/Informatique/Programmation/C/bruceforce# ./gruik
Segmentation fault (core dumped)

Bon, sinon un md5 en C, ça se calcule comment ?

[Sh4dows]

Il faut utiliser la libmd5, ou alors faire le hashage à la main.
Je te recommande la première méthode

[InstinctHack]

Edit : found

[balis]

Essaye de link la biblio de MD5 dans le compilo c'est quelque chose du genre md5.lib autre du genre et non avec SSL

EDIT : Essaye aussi md5.a dans libm aussi

[gruik]

test.c.text+0x3d): undefined reference to `MD5'

9 fois sur 10 c'est qu'il linker avec la lib adéquate Khaled, comme pour la lib math -lm, en l'occurence pour openssl c'est -lssl ou -lcrypto il me semble
ça se trouve facilement sur google ça