Annonce

**Yodark** · 24 décembre 2012, 16h44

Bon après une grosse optimisation voici :

Code:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define TAILLE_MAX 1000
void genereclef(char* clef, int longueur, char const *charset);

int main (int argc, char *argv[])
{
////////////////////JE DECLARE MON TABLEAU DE CHAR*
    static const char *charset[41] =
    {
        "", // Case 0
        "0123456789ABCDEF",
        "0123456789abcdef",
        "0123456789",
        "00123456789 ",
        "[email protected]#$%^&*()-_+=",
        "[email protected]#$%^&*()-_+= ",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/ ",
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ ",
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ",
        "[email protected]#$%^&*()-_+=",
        "[email protected]#$%^&*()-_+= ",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/ ",
        "[email protected]#$%^&*()-_+=",
        "[email protected]#$%^&*()-_+= ",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/ ",
        "abcdefghijklmnopqrstuvwxyz",
        "abcdefghijklmnopqrstuvwxyz ",
        "abcdefghijklmnopqrstuvwxyz0123456789",
        "abcdefghijklmnopqrstuvwxyz0123456789 ",
        "[email protected]#$%^&*()-_+=",
        "[email protected]#$%^&*()-_+= ",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/ ",
        "[email protected]#$%^&*()-_+=",
        "[email protected]#$%^&*()-_+= ",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/ ",
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ",
        "[email protected]#$%^&*()-_+=",
        "[email protected]#$%^&*()-_+= ",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/",
        "[email protected]#$%^&*()-_+=~`[]{}|\\:, »‘<>,.?/ "
    };

    int choix_menu = 0, choix_type = 0, longueur_clef = 0, longueur_min = 0, longueur_max = 0;
    unsigned long compteur = 0 , nbr_de_clefs = 0;
    char nom_fichier[100] = {'0'};

    FILE *fichier1 = NULL;
    FILE *fichier2 = NULL;
    FILE *fichierOUT = NULL;

    char fichier_in1[100] = { '0' };
    char fichier_in2[100] = { '0' };
    char fichier_out[100] = { '0' };
    char chaine[TAILLE_MAX] = "";

    system("color 1f");
    printf("  H4CK_TH3_W0RD5 0.5 by Lastwissh");
    printf("\n\n (In pop programmation we trust ^_^)");
    printf("\n\n          ****MENU****\n\n");
    printf("   1. Generation de Wordlist\n\n");
    printf("   2.. Optimisation de Wordlist\n\n :");
    scanf("%d", &choix_menu);

    switch(choix_menu)
    {

    case 1:

        printf("\n\n Quel type de clef souhaitez-vous generer ?\n\n");
        printf(" [1]  : MAJ + NUM (Type Hexadecimale)\n");
        printf("  [2]  : MIN + NUM (Type Hexadecimale)\n\n");
        printf("   [3]  : NUM\n");
        printf("    [4]  : NUM + Espace\n\n");
        printf("    [5]  : 14 Symboles\n");
        printf("   [6]  : 14 Symboles + Espace\n");
        printf("  [7]  : Tout les symboles\n");
        printf(" [8]  : Tout les symboles + Espace\n\n");
        printf(" [9]  : Alphabet MAJ\n");
        printf("  [10] : Alphabet MAJ + Espace\n");
        printf("   [11] : Alphabet MAJ + NUM\n");
        printf("    [12] : Alphabet MAJ + NUM + Espace\n");
        printf("     [13] : Alphabet MAJ + 14 Symboles\n");
        printf("      [14] : Alphabet MAJ + 14 Symboles + Espace\n");
        printf("      [15] : Alphabet MAJ + tout les Symboles\n");
        printf("     [16] : Alphabet MAJ + tout les Symboles + Espace\n");
        printf("    [17] : Alphabet MAJ + NUM + 14 Symboles\n");
        printf("   [18] : Alphabet MAJ + NUM + 14 Symboles + Espace\n");
        printf("  [19] : Alphabet MAJ + NUM + tout les Symboles\n");
        printf(" [20] : Alphabet MAJ + NUM + tout les Symboles + Espace\n\n");
        printf(" [21] : Alphabet MIN\n");
        printf("  [22] : Alphabet MIN + Espace\n");
        printf("   [23] : Alphabet MIN + NUM\n");
        printf("    [24] : Alphabet MIN + NUM + Espace\n");
        printf("     [25] : Alphabet MIN + 14 Symboles\n");
        printf("      [26] : Alphabet MIN + 14 Symboles + Espace\n");
        printf("      [27] : Alphabet MIN + Tout les Symboles\n");
        printf("     [28] : Alphabet MIN + Tout les Symboles + Espace\n");
        printf("    [29] : Alphabet MIN + NUM + 14 Symboles\n");
        printf("   [30] : Alphabet MIN + NUM + 14 Symboles + Espace\n");
        printf("  [31] : Alphabet MIN + NUM + Tout les symboles\n");
        printf(" [32] : Alphabet MIN + NUM + Tout les Symboles + Espace\n\n");
        printf(" [33] : Alphabet MIN + MAJ\n");
        printf("  [34] : Alphabet MIN + MAJ + Espace\n");
        printf("   [35] : Alphabet MIN + MAJ + NUM\n");
        printf("    [36] : Alphabet MIN + MAJ + NUM + Espace\n");
        printf("    [37] : Alphabet MIN + MAJ + NUM + 14 Symboles\n");
        printf("   [38] : Alphabet MIN + MAJ + NUM + 14 Symboles + Espace\n");
        printf("  [39] : Alphabet MIN + MAJ + NUM + Tout les Symboles\n");
        printf(" [40] : Alphabet MIN + MAJ + NUM + Tout les Symboles + Espace\n");
        printf("\n :");
        scanf("%d", &choix_type);

        if(choix_type <= 40 && choix_type >= 1)
        {

            printf("\n\nCombien de clefs souhaitez-vous generer ?\n\n :");
            scanf("%ld", &nbr_de_clefs);
            printf("\n\nLongeur de clefs minimum\n\n :");
            scanf("%d", &longueur_min);
            printf("\n\nLongeur de clefs maximum\n\n :");
            scanf("%d", &longueur_max);
            printf("\n\nVeuillez nommer le fichier de sortie\n\n :");
            scanf("%s", nom_fichier);

            srand(time(NULL));

            FILE* fichier = NULL; // fichier = NULL
            strcat(nom_fichier,".txt");
            fichier = fopen(nom_fichier, "w");

            if(fichier != NULL)
            {

                printf("\n\n GENERATION DE LA WORDLIST EN COURS\n");
                printf(" ...");

                char* clef = malloc(longueur_max + 2);
                while(compteur != nbr_de_clefs)
                {
                    longueur_clef = (rand() % (longueur_max - longueur_min + 1)) + longueur_min;
                    genereclef(clef, longueur_clef, charset[choix_type]);
                    compteur++;
                    fputs(clef , fichier);
                }
                free(clef);

                printf("\n LES CLEFS ONT PARFAITEMENT ETE GENEREES DANS LE FICHIER : %s\n\n", nom_fichier);

                fclose(fichier);
            }

            else
            {
                printf("Impossible d'ouvrir/creer le fichier %s", nom_fichier);
                exit(EXIT_FAILURE);
            }

            break;

        case 2: // Optimisation

            printf("\nSaisissez la premiere wordlist a fusionner(Sans l'extansion)\n   :");
            scanf("%s", fichier_in1);
            printf("\nSaisissez la deuxieme wordlist a fusionner(Sans l'extansion)\n   :");
            scanf("%s", fichier_in2);
            printf("\nVeuillez nommer le fichier de sortie   :");
            scanf("%s", fichier_out);

            strcat(fichier_in1, ".txt");
            strcat(fichier_in2, ".txt");
            strcat(fichier_out, ".txt");
            fichier1 = fopen(fichier_in1, "r");
            fichier2 = fopen(fichier_in2, "r");
            fichierOUT = fopen(fichier_out, "w");


            if (fichier1 != NULL && fichierOUT != NULL)
            {

                while (fgets(chaine, TAILLE_MAX, fichier1))
                {
                    fputs(chaine, fichierOUT);
                }

                fclose(fichier1);

            }
            else
            {
                printf("\nFichier introuvable\n");
            }

            if (fichier2 != NULL && fichierOUT != NULL)
            {

                while (fgets(chaine, TAILLE_MAX, fichier2))
                {
                    fputs(chaine, fichierOUT);
                }

                fclose(fichier2);
                fclose(fichierOUT);
                printf("\n\nFUSION TERMINER\n\n");

            }
            else
            {
                printf("\nFichier introuvable\n");
            }

            break; // Fin optimisation

        default:
            printf("\a\a\a");
            printf("\n\nErreur de saisi HIJO DE PUTA !!\n\n");
            return 0;
            break;

        } // fin du if choix_type

        else
        {
            printf("\a\a\a");
            printf("\n\nERREUR DE SAISI CONNARD\n\n");
        }

    } // fin du switch choix_menu

    return EXIT_SUCCESS;

}

void genereclef(char* clef, int longueur, char const *charset)
{
    int i = 0;
    for (i = 0; i < longueur; i++)
    {
        clef[i] = charset[(rand() % strlen(charset))] ;
    }
    clef[i]='\n';
    clef[i+1]='\0';
}

Encore en projet d'amélioration, je vais lui apporter plusieurs modes (suppressions des doublons, création de wordlist "intelligente" etc.. )
A noter : j'ai rajouté un mode pour fusionner deux wordlists.

**wafistos** · 12 février 2013, 21h21

Bonjour , j'ai essaye votre script il se trouve qu'il y a des doublant quand on choisi les numériques ?
pour être plus claire je voulais faire un dic de numéro de 1 --> 1000 et j'ai plusieurs numéros identiques merci de l’expliqué

**mactux** · 12 février 2013, 21h39

Encore en projet d'amélioration, je vais lui apporter plusieurs modes (suppressions des doublons, création de wordlist "intelligente" etc.. )

C'est pourtant précisé à la fin, et merci de venir te présenter dans la section adéquate.

**Yodark** · 12 février 2013, 22h33

@wafistos

Oui il y a des doublons, je vais améliorer mon code et faire un mode pour ôter les doublons, c'est prévu.
Mais bon si tu veux faire un dico de 1 à 1000 c'est très simple il n'y a cas incrémenter un variable et l'écrire dans un fichier en bouclant, d'ailleurs c'est une bonne idée pour le mode numérique.
Là en ce moment je suis un peu occupé sur d'autres projets mais j'y reviendrais sous peu.

Cordialement.

**Sony** · 11 juillet 2013, 17h18

Merci c'est vraiment super je l'utilise régulièrement

**Yodark** · 11 juillet 2013, 22h23

Merci ça fait plaisir.

**SAKAROV** · 11 juillet 2013, 23h28

@Sony: le bouton thanks sous le post à remercier est fait pour ça

**fred** · 23 juillet 2013, 23h01

Salut Lastwissh,

J'attendais de tes nouvelles, mais comme je reste pas longtemps ce soir, je te propose une solution (réflexion) sur la suppression de doublon.

Code:

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

#define MAX 200

int count(FILE *f); /* compte le nombre de lignes */
char **create(int n); /* Crée le tableau à deux dimensions */
FILE *open(char *name, char *mode); /* Ouverture sécuritaire du fichier */
int read(FILE *f, char **tab, int lines); /* Lis et ajoute les lignes dans le tableau */
void display(char **tab, int taille); /* Affiche le tableau */
void freec(char **tab, int taille); /* libération mémoire de chaque chaine */
int is_present(char **tab, char *chaine, int taille); /* vérifier la présence de chaine dans tab */

int main(void)
{
    FILE *fic = open("test.txt", "r");
    int nb_line = count(fic);
    int t;

    char **res = create(nb_line);

    t = read(fic, res, nb_line);

    display(res, t);

    freec(res, t);
    free(res);

    return 0;
}

char **create(int n)
{
    char **tab = NULL;

    tab = malloc(sizeof(char *) * n);
    if (tab == NULL)
        exit(EXIT_FAILURE);

    return tab;
}

FILE *open(char *name, char *mode)
{
    FILE *file = fopen(name, mode);
    if (file == NULL)
    {
        perror("");
        exit(EXIT_FAILURE);
    }

    return file;
}

int count(FILE *f)
{
    char *p = NULL;
    char line[MAX] = {0};
    int counter = 0;

    while ((p=fgets(line, MAX, f)) != NULL)
        counter += 1;

    fseek(f, 0, 0);

    return counter;
}

int read(FILE *f, char **tab, int lines)
{
    char *p = NULL;
    char line[MAX];

    int i, j=0;
    for (i=0; i<lines; i++)
    {
        p = fgets(line, MAX, f);
        if (p != NULL)
        {
            p = strchr(line, '\n');
            if (p != NULL)
                *p = '\0';

            if (!is_present(tab, line, j))
            {
                tab[j] = strdup(line);
                j += 1;
            }
        }
    }
    fclose(f);
    return j;
}

void display(char **tab, int taille)
{
    int i;
    for (i=0; i<taille; i++)
        printf("%s\n", tab[i]);
}

void freec(char **tab, int taille)
{
    int i;
    for (i=0; i<taille; i++)
    {
        free(tab[i]);
    }

}

int is_present(char **tab, char *chaine, int taille)
{
    int i, n;

    if (taille == 0)
        return 0;

    for (i=0; i<taille; i++)
    {
        n = strcmp(tab[i], chaine);
        if (n == 0)
            return 1;
    }

    return 0;
}

Bonne soirée...

**Yodark** · 24 juillet 2013, 02h16

Oui, merci

En fait, là je suis dessus

J'avais pensé à ça pour compter le nombre de lignes :

Code:

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

int main(){
int cmpt = 0;
char nom_fichier[100] = {'0'}, c;
printf("\n\nNom fichier : ");
scanf("%s", nom_fichier);
FILE *FP;
FP = fopen(nom_fichier, "r+");

  if(FP == NULL){
      printf("Erreur !");
      return 0;
  }
  else {
      while((c = fgetc(FP)) != EOF){
            if (c == '\n') {
            cmpt++;
             }
       }
      printf("\n\nNombre de lignes = %d\n\n", cmpt);
   } 

return 0;
}

Ta solution a l'air meilleure, mais j'ai lu que fgets se stoppait au premier ' '
Alors du coup j'ai du mal à comprendre...

Quoi qu'il en soit je vais étudier ton code avec attention.
Encore merci

**fred** · 24 juillet 2013, 10h36

Salut

En fait ma solution est meilleure car plus simple, mais elle n'est pas plus efficace.

Cependant le simple c'est souvent au dépend de l'efficacité.

Ma façon de faire est tout de même souhaitable, car je lis directement le nombre de lignes, alors que toi c'est caractère par caractère, ce qui obligé la détection du caractère '\n'.

Tu as une boucle while qui détecte la fin du fichier, comme moi en ce qui concerne fgets, donc sur le principe, toi aussi tu t'arrêtes non pas à la 1ère ligne, mais au 1er caractère avec fgetc.

Sinon, tu ne comptes pas me mettre tout le code juste dans le main(...) tout de même ?

EDIT :

Voici le code avec écriture sur le fichier des dictionnaires sans doublon.

Il n'y a rien de dur niveau algorithme, le plus chiant si je puis dire, c'est la gestion de mémoire en C qui est assez demandeuse de rigueur de code.

Code:

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

#define MAX 200

int count(FILE *f); /* compte le nombre de lignes */
char **create(int n); /* Crée le tableau à deux dimensions */
FILE *open(char *name, char *mode); /* Ouverture sécuritaire du fichier */
int read(FILE *f, char **tab, int lines); /* Lis et ajoute les lignes dans le tableau */
void display(char **tab, int taille); /* Affiche le tableau */
void freec(char **tab, int taille); /* libération mémoire de chaque chaine */
int is_present(char **tab, char *chaine, int taille); /* vérifier la présence de chaine dans tab */
void write(FILE *f, char **tab, int taille);

int main(void)
{
    FILE *fic = open("test.txt", "r");
    int nb_line = count(fic);
    int t;

    char **res = create(nb_line);

    t = read(fic, res, nb_line);

    display(res, t);

    fic = open("test_cp.txt", "w");
    write(fic, res, t);

    freec(res, t);
    free(res);

    return 0;
}

char **create(int n)
{
    char **tab = NULL;

    tab = malloc(sizeof(char *) * n);
    if (tab == NULL)
        exit(EXIT_FAILURE);

    return tab;
}

FILE *open(char *name, char *mode)
{
    FILE *file = fopen(name, mode);
    if (file == NULL)
    {
        perror("");
        exit(EXIT_FAILURE);
    }

    return file;
}

int count(FILE *f)
{
    char *p = NULL;
    char line[MAX] = {0};
    int counter = 0;

    while ((p=fgets(line, MAX, f)) != NULL)
        counter += 1;

    fseek(f, 0, 0);

    return counter;
}

int read(FILE *f, char **tab, int lines)
{
    char *p = NULL;
    char line[MAX];

    int i, j=0;
    for (i=0; i<lines; i++)
    {
        p = fgets(line, MAX, f);
        if (p != NULL)
        {
            p = strchr(line, '\n');
            if (p != NULL)
                *p = '\0';

            if (!is_present(tab, line, j))
            {
                tab[j] = strdup(line);
                if (tab[j] == NULL)
                {
                    fprintf(stderr, "Error allocation");
                    exit(EXIT_FAILURE);
                }
                else
                   j += 1;
            }
        }
    }
    fclose(f);
    return j;
}

void display(char **tab, int taille)
{
    int i;
    for (i=0; i<taille; i++)
        printf("%s\n", tab[i]);
}

void freec(char **tab, int taille)
{
    int i;
    for (i=0; i<taille; i++)
    {
        free(tab[i]);
    }

}

int is_present(char **tab, char *chaine, int taille)
{
    int i, n;

    if (taille == 0)
        return 0;

    for (i=0; i<taille; i++)
    {
        n = strcmp(tab[i], chaine);
        if (n == 0)
            return 1;
    }

    return 0;
}

void write(FILE *f, char **tab, int taille)
{
    char *p = NULL;
    int i;
    size_t n;

    for (i=0; i<taille; i++)
    {
        p = strchr(tab[i], '\0');
        if (p != NULL)
            *p = '\n';

        n = strlen(tab[i]);
        fwrite(tab[i], 1, n, f);
    }

    fclose(f);
}

**fred** · 25 juillet 2013, 12h12

Bon j'ai modifié mon code, j'avais une petite erreur de mémoire bien casse bonbon

Code:

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

#define MAX 200

int count(FILE *f); /* compte le nombre de lignes */
char **create(int n); /* Crée le tableau à deux dimensions */
FILE *open(char *name, char *mode); /* Ouverture sécuritaire du fichier */
int read(FILE *f, char **tab, int lines); /* Lis et ajoute les lignes dans le tableau */
void display(char **tab, int taille); /* Affiche le tableau */
void freec(char **tab, int taille); /* libération mémoire de chaque chaine */
int is_present(char **tab, char *chaine, int taille); /* vérifier la présence de chaine dans tab */
void write(FILE *f, char **tab, int taille); /* écrit le tableau dans le fichier */

int main(void)
{
    FILE *fic = open("test.txt", "r");
    int nb_line = count(fic);
    int t;

    char **res = create(nb_line);

    t = read(fic, res, nb_line);

    display(res, t);

    fic = open("test_cp.txt", "w");
    write(fic, res, t);

    freec(res, nb_line);
    free(res);

    return 0;
}

char **create(int n)
{
    char **tab = NULL;
    int i;

    tab = malloc(sizeof(char *) * n);
    if (tab == NULL)
        exit(EXIT_FAILURE);

    for (i=0; i<n; i++)
    {
        tab[i] = malloc(MAX);
        if (tab[i] == NULL)
            exit(EXIT_FAILURE);
    }


    return tab;
}

FILE *open(char *name, char *mode)
{
    FILE *file = fopen(name, mode);
    if (file == NULL)
    {
        perror("");
        exit(EXIT_FAILURE);
    }

    return file;
}

int count(FILE *f)
{
    char *p = NULL;
    char line[MAX] = {0};
    int counter = 0;

    while ((p=fgets(line, MAX, f)) != NULL)
        counter += 1;

    fseek(f, 0, 0);

    return counter;
}

int read(FILE *f, char **tab, int lines)
{
    char *p = NULL;
    char line[MAX] = {0};
    size_t n;

    int i, j=0;
    for (i=0; i<lines; i++)
    {
        p = fgets(line, MAX, f);
        if (p != NULL)
        {
            p = strchr(line, '\n');
            if (p != NULL)
                *p = '\0';

            if (!is_present(tab, line, j))
            {
                n = strlen(line) + 1;
                p = memcpy(tab[j], line, n);
                if (p == NULL)
                {
                    fprintf(stderr, "Error allocation");
                    exit(EXIT_FAILURE);
                }
                j += 1;
            }
        }
    }

    fclose(f);

    return j;
}

void display(char **tab, int taille)
{
    int i;
    for (i=0; i<taille; i++)
        printf("%s\n", tab[i]);
}

void freec(char **tab, int taille)
{
    int i;
    for (i=0; i<taille; i++)
        if(tab[i] != NULL)
            free(tab[i]);
}

int is_present(char **tab, char *chaine, int taille)
{
    int i, n;

    if (taille == 0)
        return 0;

    for (i=0; i<taille; i++)
    {
        n = strcmp(tab[i], chaine);
        if (n == 0)
            return 1;
    }

    return 0;
}

void write(FILE *f, char **tab, int taille)
{
    char *p = NULL;
    int i;
    size_t n;

    for (i=0; i<taille; i++)
    {
        p = strchr(tab[i], '\0');
        if (p != NULL)
        {
            *p = '\n';
            *(p+1) = '\0';
        }

        n = strlen(tab[i]);
        fwrite(tab[i], 1, n, f);
    }

    fclose(f);
}

**Sony** · 09 novembre 2013, 11h21

Pourrait-il exister un générateur d'e-mail avec Gmail, Yahoo, ... ?

**fred** · 10 novembre 2013, 10h14

Un générateur d'emails, que veux-tu dire? Quel serait son intérêt ?

**mad-attack** · 10 novembre 2013, 10h37

Envoyé par fred Voir le message

Quel serait son intérêt ?

Pour les utilisateurs de sentry nba , sa peut être fort intéressant , car ils ont besoin de combo list , wordlist

Au cas ou tu ne serais ce que c'est sentry nba voici une explication vidéo
==> http://www.youtube.com/watch?v=xO41utHvA_8

Annonce

Générateur de Wordlist

Générateur de Wordlist

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire