Crunch -> Pattern

[EvaExe]

Bonjour a vous,

je feuillette internet depuis quelques heures déja, mais je n'ai pas trouvé de réponse claire a ma question, et le man de crunch..bha j'ai du mal

C'est tres simple,

Je souhaite généré un dico, (evidement..)
cependant je veut qu'il respect un pattern précit,

XXXX XXXX XX XXXX

ou X est un char alphanumerique A-A a-a 0-9 en respectant les " " espace
Est ce que qulqu'un aurait une piste ?

Grand merci,

[EvaExe]

Apres encore quelques recherches, et discutions sur IRC,
je vais me lancer dans la création de ce script.

[b0fh]

Code HASKELL :

import Control.Monad
import System.Environment

charmap '@' = ['a'..'z']
charmap '%' = ['0'..'9']
charmap '^' = ['!'..'/'] ++ [':'..'@'] ++ ['['..'`']
charmap ',' = ['A'..'Z']
charmap  x  = [x]

main = getArgs >>= mapM_ (mapM_ putStrLn . mapM charmap)

Code :

ghc -O3 --make gogole.hs

Code :

$ ./gogole --@--
--a--
--b--
--c--
...

Code :

$ ./gogole @%@
a0a
a0b
...
a0z
a1a
a1b
...

(Edité pour accepter plusieurs patterns en argument)

[EvaExe]

Merci pour l'info !!
Jvais d'ab essayer de créer un script en C pour faire le job,
mais je pense que ton idée sera bien meilleur,
je testerais les deux

---

Je vient de faire un petit bout de code,
pour une clef a 5 Variable pouvant prendre 256 valeurs chacune
je débute, ALORS ON NE SE MOQUE PAS !!! hain !

Code :

char key0[4];
char key1[4];
char key[4];
char key[4];
int cpt0=0;
int cpt1=0;
int cpt2=0;
int cpt3=0;
int cpt4=0;
char allval[256]; //Contient tout les char alphanumerique (unique)
while !end {
//teste une a une toute les combinaisons possible
if (cpt0 >= 256)
    {
    cpt0=0;
    cpt1++;
    }else{
if (cpt1 >= 256)
    {
    cpt1=0;
    cpt2++;
    }else{
if (cpt2 >= 256)
    {
    cpt2=0;
    cpt3++;
    }
    }else{
if (cpt4 >= 256)
    {
    cpt3=0;
    cpt4++:
    }else{
if (cpt4 >= 256){
    end=true;
}
cpt0++;
}
//Insertion du char unique dans chaque case
key[o]=alval[cpt0];
key[1]=alval[cpt1];
key[2]=alval[cpt2];
key[3]=alval[cpt3];
key[4]=alval[cpt4];
//return les char testé
cout>>key[0],key[1],key[2],[key3],key[4];
}

[supersnail]

Je crois que ton code ne compile pas :')

Sinon quitte à faire du C++ (coucou "cout" :>), autant utiliser std:tring plutôt que des tableaux de char. Et au passage, je vois pas trop quel algorithme t'essaies d'implémenter pour le coup.

PS: essaie d'indenter ton code, c'est plus facile à lire pour nos yeux :p

[EvaExe]

En fait je voudrais créer une chaine de caractère de longeur 5 char qui prend tour a tour toute les valeurs possible sans redondances
ex :
aaaaa
baaaa
bbaaa
.....
zUw*9

Un algo de brute force pour faire simple;
je vais regarder std:tring

merci,

[notfound]

Un petit bout de code en C, en récursif.
Ça faisait un bail que j'avais pas codé en C et j'avoue avoir galérer, donc ça vaut ce que ça vaut

[spoiler]
>>> gcc crunch_is_not_a_chocolat.c -o CRU -O3 ; time ./CRU 5 5 > /dev/null

real 0m0.712s
user 0m0.710s
sys 0m0.000s

Code C :


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

static const char charset[] =
        "abcdefghijklmnopqrstuvwxyz";
//      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
//      "0123456789";

void dict(char *word, int index, int max_local);


int maxlen;
int main(int argc, char **argv){
    int i = atoi(argv[1]);
    maxlen = atoi(argv[2]);
    char *buf = malloc(maxlen + 1);
    for (i ; i <= maxlen; ++i){
        memset(buf, 0, maxlen + 1);
        dict(buf, 0, i);
    }
    free(buf);
    return 0;
}


void dict(char *word, int index, int max_local){
        int i;
        const int sizeCharset = sizeof(charset);
        for ( i=0 ; i<sizeCharset-1 ; ++i){
            word[index] = charset[i];
            if (index == max_local - 1){
                printf("%s\n", word);
                if (max_local == maxlen+1) exit(0);
            }
            else dict(word, index + 1, max_local);
        }
}
 

[/spoiler]

[EvaExe]

Voila, j'ai fais un code lent mais fonctionelle,
J'ai absolument voullut terminer mon travaille avant de m'inspirer du votre
En tout cas merci,
[spoiler]

Code C :


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;

int main(void)
{
    bool end=false;
    int cpt0=-1;
    int cpt1=0;
    int cpt2=0;
    int cpt3=0;
    int cpt4=0;
    char key[5];
    static const char charset[] =
        "abcdefghijklmnopqrstuvwxyz";
    while (!end)
    {
//teste une a une toute les combinaisons possible
        if (cpt0 >= 27)
        {
            cpt0=0;
            cpt1++;
        }
        else
        {
            cpt0++;
        };

        if (cpt1 >= 27)
        {
            cpt1=0;
            cpt2++;
        }

        if (cpt2 >= 27)
        {
            cpt2=0;
            cpt3++;
        }

        if (cpt3 >= 27)
        {
            cpt3=0;
            cpt4++;
        }

        if (cpt4 >= 27)
        {
            end=true;
        };

/*Insertion du char unique dans chaque case*/
        key[0]=charset[cpt0];
        key[1]=charset[cpt1];
        key[2]=charset[cpt2];
        key[3]=charset[cpt3];
        key[4]=charset[cpt4];

        cout<<key[0]<<key[1]<<key[2]<<key[3]<<key[4]<<endl;
    };
};


 

[/spoiler]

[EvaExe]

Nous voici enfin sur la ...fin
J'ai finalisé le script, optimisé (je crois xD)
J'ai pu le pipe avec aircrack, (merci a gruik)
il faut que le script sorte en cout ou stdout ect..

Du coup, je le poste, même si c'est nul, je suis fier de mwa !

Le script genere 18char alphanumérique pour creer une clef unique a chaque foi.
Il suit le pattern suivant XXXX XXXX XXXX XX

[spoiler]

Code C :


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;

int main(void)
{
     static const char charset[] =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    int cpt[19];
    bool end=false;
    int x;

    for(x=0; x<19; x++)
    {
        cpt[x]=0;
    };


    while (!end)
    {
//teste une a une toute les combinaisons possible
        if (cpt[0] >= 64)
        {
            cpt[0]=0;
            cpt[1]++;
            if (cpt[1] >= 64)
            {
                cpt[1]=0;
                cpt[2]++;


                if (cpt[2] >= 64)
                {
                    cpt[2]=0;
                    cpt[3]++;


                    if (cpt[3] >= 64)
                    {
                        cpt[3]=0;
                        cpt[4]++;
                        if (cpt[4] >= 64)
                        {
                            cpt[4]=0;
                            cpt[5]++;
                            if (cpt[5]>=64)
                            {
                                cpt[5]=0;
                                cpt[6]++;
                                if(cpt[6]>=64)
                                {
                                    cpt[6]=0;
                                    cpt[7]++;
                                    if(cpt[7]>=64)
                                    {
                                        cpt[7]=0;
                                        cpt[8]++;

                                        if(cpt[8]>=64)
                                        {
                                            cpt[8]=0;
                                            cpt[9]++;
                                            if(cpt[9]>=64)
                                            {
                                                cpt[9]=0;
                                                cpt[10]++;
                                                if(cpt[10]>=64)
                                                {
                                                    cpt[10]=0;
                                                    cpt[11]++;
                                                    if(cpt[11]>=64)
                                                    {
                                                        cpt[11]=0;
                                                        cpt[12]++;
                                                        if(cpt[12]>=64)
                                                        {
                                                            cpt[12]=0;
                                                            cpt[13]++;
                                                            if(cpt[13]>=64)
                                                            {
                                                                cpt[13]=0;
                                                                cpt[14]++;
                                                                if(cpt[14]>=64)
                                                                {
                                                                    cpt[14]=0;
                                                                    cpt[15]++;

                                                                    if(cpt[15]>=64)
                                                                    {
                                                                        cpt[15]=0;
                                                                        cpt[16]++;
                                                                        if(cpt[16]>=64)
                                                                        {
                                                                            cpt[16]=0;
                                                                            cpt[17]++;
                                                                            if(cpt[17]>=64)
                                                                            {
                                                                                cpt[17]=0;
                                                                                cpt[18]++;

                                                                                if(cpt[18]>=64)
                                                                                {
                                                                                    end=true;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }



            else
            {
                cpt[0]++;
            };




            cout<<charset[cpt[0]]<<charset[cpt[1]]<<charset[cpt[2]]<<charset[cpt[3]]<<' '
                <<charset[cpt[4]]<<charset[cpt[5]]<<charset[cpt[6]]<<charset[cpt[7]]<<' '
                <<charset[cpt[8]]<<charset[cpt[9]]<<charset[cpt[10]]<<charset[cpt[11]]<<' '
                <<charset[cpt[12]]<<charset[cpt[13]]<<charset[cpt[14]]<<charset[cpt[15]]<<' '
                <<charset[cpt[16]]<<charset[cpt[17]]<<endl;

};
};
 

[/spoiler]