[C/C++] BruteForce

[InstinctHack]

[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