begin process at 2010 03 18 22:19:07
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths et Algorithmes

 > GENERATEUR DE MOT PAR INCREMENTATION

GENERATEUR DE MOT PAR INCREMENTATION


 Information sur la source

Attention: ce code a été marqué comme suspect par un admin, il peut donc être dangereux. Ce code a été laissé sur le site dans un but pédagogique, ne l'exécutez pas si vous ne comprenez pas son contenu!
Note :
Aucune note
Catégorie :Maths et Algorithmes Classé sous :LEXIQUE, PERMUTATION, STRING, INCREMENTATION, CHAINE Niveau :Débutant Date de création :11/03/2009 Date de mise à jour :06/04/2009 11:36:30 Vu :3 572

Auteur : elguevel

Ecrire un message privé
Site perso
Commentaire sur cette source (12)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
Cette class permet de renvoyer un mot à partir d'un autre avec une permutation du dernier caractère depuis une liste de caractère (sous forme de chaine). Une fois que le dernier caractere à été permuté jusqu'a la fin de cette liste, on permute le dernier caractère -1, et ainsi de suite.

En gros en partant de "a" nous aurons :
-> b, c,..., z, aa, ab, ac,..., az, ba, bb, bc,..., aaa, aab, aac,...,aaaa, aaab, ...

Source

  • /***************************************************************************************************************
  • * ElgStringIterator - v1.1
  • * -----------------------------------------------------------------------------------------------------
  • * Generation de chaine par permutation lineaire depuis une liste de caractere
  • *
  • * Ecrit par LEVEUGLE Damien
  • * Elguevel software (c) 2009
  • * http://elguevel.free.fr/
  • *
  • * -----------------------------------------------------------------------------------------------------
  • * v1.0 : release
  • * v1.1 : Modification des termes utilisés
  • * Modification du main
  • */
  • class ElgStringIterator
  • {
  • /******************************************************************************************************************
  • * Constructeur *
  • ******************************************************************************************************************/
  • // Constructeur par defaut
  • public ElgStringIterator() throws Exception
  • {
  • // Par defaut on se sert de tous les caractères
  • // Ps : Cette liste peut être personnalisée via "setCaracteres()"
  • _caracteres = this.EGL_SI_CHAR_MINUSCULE +
  • this.EGL_SI_CHAR_MAJUSCULE +
  • this.EGL_SI_CHAR_NUMERIQUE +
  • this.EGL_SI_CHAR_SPECIAUX;
  • }
  • /******************************************************************************************************************
  • * Constantes *
  • ******************************************************************************************************************/
  • // Listes de caractères prédefinies
  • public static final String EGL_SI_CHAR_MINUSCULE = "abcdefghijklmnopqrstuvwxyz";
  • public static final String EGL_SI_CHAR_MAJUSCULE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  • public static final String EGL_SI_CHAR_NUMERIQUE = "0123456789";
  • public static final String EGL_SI_CHAR_SPECIAUX = "!$%&/()=?";
  • /******************************************************************************************************************
  • * Attributs *
  • ******************************************************************************************************************/
  • private String _caracteres; // Caractères utilisés pour la generation de la chaine
  • /******************************************************************************************************************
  • * Proprietes *
  • ******************************************************************************************************************/
  • // Accesseur sur _caracteres
  • public String getCaracteres()
  • {
  • return _caracteres;
  • }
  • // Mutateur sur _caracteres
  • public void setCaracteres( String valeur )
  • {
  • _caracteres = valeur;
  • }
  • /******************************************************************************************************************
  • * Methodes *
  • ******************************************************************************************************************/
  • // Cherche dans la liste "_caracteres" le caractere demande, et renvoi le suivant
  • // Nb : S'il s'agit du dernier caractere on repasse en debut de liste
  • private char prochainCaractere(char caractere) throws Exception
  • {
  • char resultat;
  • char premierCaractere = this._caracteres.charAt(0);
  • char dernierCaractere = this._caracteres.charAt(this._caracteres.length() - 1);
  • int position = this._caracteres.indexOf(caractere);
  • if (caractere == dernierCaractere)
  • resultat = premierCaractere;
  • else
  • resultat = this._caracteres.charAt( position + 1 );
  • return resultat;
  • }
  • // Genere chaine suivante
  • public String chaineSuivante(String chaineOrigine) throws Exception
  • {
  • String chaineNouvelle = ""; // Resultat (nouvelle chaine generee)
  • int iterateur; // Iterator
  • int increment; // Memorise position dans la chaine
  • int pointeurPosition; // Memorise position dans la chaine
  • char premierCaractere = this._caracteres.charAt(0); // Premier caractere de la liste de caracteres
  • char dernierCaractere = this._caracteres.charAt(this._caracteres.length() - 1); // Dernier caractere de la liste de caracteres
  • if ( chaineOrigine.trim().equals("") ) return new String("") + premierCaractere;
  • pointeurPosition = chaineOrigine.length();
  • increment = 0;
  • // Calcul positions
  • while (pointeurPosition > 0)
  • {
  • if (chaineOrigine.charAt(pointeurPosition - 1) != dernierCaractere)
  • {
  • increment = pointeurPosition - 1;
  • break;
  • }
  • pointeurPosition--;
  • if (pointeurPosition == 0)
  • {
  • pointeurPosition--;
  • break;
  • }
  • }
  • // Generation mot de passe
  • if (pointeurPosition < 0)
  • {
  • for (iterateur = 0; iterateur < (chaineOrigine.length() + 1); iterateur++)
  • chaineNouvelle = chaineNouvelle + premierCaractere;
  • }
  • else
  • {
  • if (increment == 0)
  • chaineNouvelle = new String("") + this.prochainCaractere(chaineOrigine.charAt(increment) );
  • else
  • chaineNouvelle = chaineOrigine.substring(0, increment) + this.prochainCaractere(chaineOrigine.charAt(increment));
  • for (iterateur = increment + 1; iterateur < (chaineOrigine.length()); iterateur++)
  • chaineNouvelle = chaineNouvelle + premierCaractere;
  • }
  • return chaineNouvelle;
  • }
  • /******************************************************************************************************************
  • * Entry point (Test) *
  • ******************************************************************************************************************/
  • public static void main( String[] args )
  • {
  • String maChaine = "";
  • int niveauProfondeur = 0;
  • System.out.println("\n----------------------------------------------------------");
  • System.out.println(" ElgStringIterator - Generateur de chaine par permutation");
  • System.out.println(" Ecrit par LEVEUGLE Damien");
  • System.out.println(" Elguevel software (c) 2009");
  • System.out.println("----------------------------------------------------------\n");
  • try
  • {
  • ElgStringIterator monObjet = new ElgStringIterator();
  • // Trop d'arguments
  • if ( args.length < 3 )
  • {
  • // Si au moins 1 ou 2 arguments
  • if ( args.length > 0 )
  • {
  • // Recupere niveau profondeur (sinon infini)
  • try
  • {
  • niveauProfondeur = (int) Integer.valueOf( args[0] );
  • }
  • catch ( NumberFormatException nfe )
  • {
  • System.out.println("\tErreur : Niveau de profondeur invalide !\n");
  • System.exit(1);
  • }
  • // Recupere chaine de depart
  • if ( args.length > 1 ) maChaine = args[1];
  • }
  • // Affichage chaines
  • while ( niveauProfondeur == 0 || niveauProfondeur >= maChaine.length() )
  • {
  • maChaine = monObjet.chaineSuivante( maChaine ); // Recupere chaine, et renvoi la suivante
  • System.out.println( "-> " + maChaine );
  • }
  • }
  • else
  • {
  • System.out.println("\tUsage : ElgStringIterator <longueure max.> <chaine de depart>\n" );
  • }
  • }
  • catch( Exception ex )
  • {
  • System.out.println("Erreur : " + ex.toString() );
  • }
  • }
  • }
/***************************************************************************************************************
 *    ElgStringIterator - v1.1
 *  -----------------------------------------------------------------------------------------------------
 *    Generation de chaine par permutation lineaire depuis une liste de caractere
 *
 *    Ecrit par LEVEUGLE Damien
 *    Elguevel software (c) 2009
 *    http://elguevel.free.fr/
 *
 *  -----------------------------------------------------------------------------------------------------
 *    v1.0 : release
 *    v1.1 : Modification des termes utilisés
 *           Modification du main
 */
class ElgStringIterator
{

    /******************************************************************************************************************
     *  Constructeur                                                                                                  *
     ******************************************************************************************************************/

    // Constructeur par defaut
    public ElgStringIterator() throws Exception
    {
        // Par defaut on se sert de tous les caractères
        // Ps : Cette liste peut être personnalisée via "setCaracteres()"
        _caracteres = this.EGL_SI_CHAR_MINUSCULE +
                      this.EGL_SI_CHAR_MAJUSCULE +
                      this.EGL_SI_CHAR_NUMERIQUE +
                      this.EGL_SI_CHAR_SPECIAUX;
    }


    /******************************************************************************************************************
     *  Constantes                                                                                                    *
     ******************************************************************************************************************/

    // Listes de caractères prédefinies

    public static final String EGL_SI_CHAR_MINUSCULE = "abcdefghijklmnopqrstuvwxyz";
    public static final String EGL_SI_CHAR_MAJUSCULE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    public static final String EGL_SI_CHAR_NUMERIQUE = "0123456789";
    public static final String EGL_SI_CHAR_SPECIAUX  = "!$%&/()=?";


    /******************************************************************************************************************
     *  Attributs                                                                                                     *
     ******************************************************************************************************************/

    private String _caracteres;         // Caractères utilisés pour la generation de la chaine


    /******************************************************************************************************************
     *  Proprietes                                                                                                    *
     ******************************************************************************************************************/

    // Accesseur sur _caracteres
    public String getCaracteres()
    {
        return _caracteres;
    }

    // Mutateur sur _caracteres
    public void setCaracteres( String valeur )
    {
        _caracteres = valeur;
    }


    /******************************************************************************************************************
     *  Methodes                                                                                                      *
     ******************************************************************************************************************/

    // Cherche dans la liste "_caracteres" le caractere demande, et renvoi le suivant
    // Nb : S'il s'agit du dernier caractere on repasse en debut de liste
    private char prochainCaractere(char caractere) throws Exception
    {
        char resultat;

        char premierCaractere = this._caracteres.charAt(0);
        char dernierCaractere = this._caracteres.charAt(this._caracteres.length() - 1);

        int position = this._caracteres.indexOf(caractere);

        if (caractere == dernierCaractere)
            resultat = premierCaractere;
        else
            resultat = this._caracteres.charAt( position + 1 );

        return resultat;
    }

    // Genere chaine suivante
    public String chaineSuivante(String chaineOrigine) throws Exception
    {
        String chaineNouvelle = "";               // Resultat (nouvelle chaine generee)

        int iterateur;                            // Iterator
        int increment;                            // Memorise position dans la chaine
        int pointeurPosition;                     // Memorise position dans la chaine

        char premierCaractere = this._caracteres.charAt(0);                                    // Premier caractere de la liste de caracteres
        char dernierCaractere = this._caracteres.charAt(this._caracteres.length() - 1);        // Dernier caractere de la liste de caracteres

        if ( chaineOrigine.trim().equals("") ) return new String("") + premierCaractere;

        pointeurPosition = chaineOrigine.length();
        increment = 0;

        // Calcul positions
        while (pointeurPosition > 0)
        {
            if (chaineOrigine.charAt(pointeurPosition - 1) != dernierCaractere)
            {
                increment = pointeurPosition - 1;
                break;
            }

            pointeurPosition--;

            if (pointeurPosition == 0)
            {
                pointeurPosition--;
                break;
            }
        }

        // Generation mot de passe
        if (pointeurPosition < 0)
        {
            for (iterateur = 0; iterateur < (chaineOrigine.length() + 1); iterateur++)
                chaineNouvelle = chaineNouvelle + premierCaractere;
        }
        else
        {
            if (increment == 0)
                chaineNouvelle = new String("") + this.prochainCaractere(chaineOrigine.charAt(increment) );
            else
                chaineNouvelle = chaineOrigine.substring(0, increment) + this.prochainCaractere(chaineOrigine.charAt(increment));

            for (iterateur = increment + 1; iterateur < (chaineOrigine.length()); iterateur++)
                chaineNouvelle = chaineNouvelle + premierCaractere;
        }

        return chaineNouvelle;
    }


    /******************************************************************************************************************
     *  Entry point (Test)                                                                                            *
     ******************************************************************************************************************/

    public static void main( String[] args )
    {
        String maChaine = "";
        int    niveauProfondeur = 0;

        System.out.println("\n----------------------------------------------------------");
        System.out.println(" ElgStringIterator - Generateur de chaine par permutation");
        System.out.println(" Ecrit par LEVEUGLE Damien");
        System.out.println(" Elguevel software (c) 2009");
        System.out.println("----------------------------------------------------------\n");

        try
        {

            ElgStringIterator monObjet = new ElgStringIterator();

            // Trop d'arguments
            if ( args.length < 3 )
            {

                // Si au moins 1 ou 2 arguments
                if ( args.length > 0 )
                {
                    // Recupere niveau profondeur (sinon infini)
                    try
                    {
                        niveauProfondeur = (int) Integer.valueOf( args[0] );
                    }
                    catch ( NumberFormatException nfe )
                    {
                        System.out.println("\tErreur : Niveau de profondeur invalide !\n");
                        System.exit(1);
                    }

                    // Recupere chaine de depart
                    if ( args.length > 1 ) maChaine = args[1];
                }

                // Affichage chaines
                while ( niveauProfondeur == 0 || niveauProfondeur >= maChaine.length() )
                {
                    maChaine = monObjet.chaineSuivante( maChaine ); // Recupere chaine, et renvoi la suivante
                    System.out.println( "-> " + maChaine );
                }

            }
            else
            {
                System.out.println("\tUsage : ElgStringIterator <longueure max.> <chaine de depart>\n" );
            }

        }
        catch( Exception ex )
        {
            System.out.println("Erreur : " + ex.toString() );
        }

    }

}

 Conclusion

Pour les tests :
----------------
Compilation : javac ElgBruteForce.java
Execution   : java ElgBruteForce <LONG. MAX> <CHAINE DEPART>

-> les parametres entre "<...>" sont facultatifs.


 Historique

31 mars 2009 21:44:14 :
Changement du titre de la source
06 avril 2009 11:36:30 :
Mise à jours des termes utilisés

 Sources de la même categorie

TEST DE PRIMALITÉ OPTIMISÉ par Julien39
Source avec Zip CLASSE MATRICE par frankladen11
Source avec Zip Source avec une capture RÉSOLUTION D'ÉQUATION GRÂCE AU CALCUL DES DÉTERMINANTS par frankladen11
Source avec Zip TYPE DE DONNÉES ABSTRAIT GRAPHE par smutsonberg
Source avec Zip Source avec une capture SIMPLEXE ET DUAL par MrRenaud

 Sources en rapport avec celle ci

NOMBRE D'OCCURENCE D'UNE CHAINE DE CARACTÈRE DANS TOUS LES F... par deadhand
Source avec Zip PARSEUR STRING/HTML HTML/STRING par rem02
Source avec Zip CRYPT par Timor
Source avec Zip Source avec une capture CALCULER UNE ÉQUATION MATHÉMATIQUE COMPLEXE DANS UN STRING E... par DeadlyPredator
Source avec Zip COMBINATOIRE : COMBINAISONS SIMPLES ET PERMUTATIONS SIMPLES. par lrequena

Commentaires et avis

Commentaire de exar le 12/03/2009 07:05:15

Hello !

Est-il normal, dans ta capture d'écran, que le mot de passe que tu donnes en paramètre soit "toto" et qu'il trouve "totp" ?

Commentaire de elguevel le 12/03/2009 12:02:00

Tout à fait, c'est même "le but" de la source ...

Si on considère le code suivant :

ElgBruteForce monBrutForce = new ElgBruteForce();
String motdepasse = "toto";

// On fait juste 10 iteration pour l'exemple
for( int i = 0; i < 10; i++ )
{
    motdepasse = monBrutForce.nextPassword( motdepasse );
    System.out.println( motdepasse );
}

tu aura comme résultat :

totp
totq
totr
tots
tott
totu
totv
totw
totx
toty

Si on part de Zero (pas de mot de passe), et qu'on utilise le jeu de caractère "0" et "1", soit (par exemple) le code suivant :

ElgBruteForce monBrutForce = new ElgBruteForce();

monBrutForce.setCaracteres("01");
String motdepasse = "";

for( int i = 0; i < 10; i++ )
{
   motdepasse = monBrutForce.nextPassword( motdepasse );
   System.out.println( motdepasse );
}

On obtient :

0
1
00
01
10
11
000
001
010
011

Le but étant d'incrementer le dernier caractère, et une fois toutes les possibilité atteinte, incrementé le caractère suivant et refaire un tour complet sur le premier et ainsi de suite ...

J'ai l'impression que c'est pas clair pour tout le monde !?

En tout cas je parle ici de brute force, mais l'utilisation pourrait être tout autre, pour faire de l'incrementation de nom de fichier par exemple ...

Commentaire de exar le 12/03/2009 12:55:19

Oui, OK, c'est plus clair !  Peut-être aurais-tu du appeler ta source "Incrémenteur de string" ou quelque chose dans le genre.

Commentaire de elguevel le 12/03/2009 13:46:36

Effectivement ... le titre laisse plus penser à un brute force complet, qui m'a en plus couté un message d'avertissement.

Faut que je change tout çà ...

Merci pour les commentaires ;-)

Commentaire de coucou747 le 15/03/2009 08:23:11

salut

c'est un iterateur sur les permutations des parties d'une chaine.

Commentaire de bringyoudown le 16/03/2009 18:15:49

si je comprends bien tu compare avec listecaracteres et tu recupere le mot de passe avec getcaracteres?
je crois pas que c'est si simple que ca, autre chose s tu accede au mot de passe pour quoi alors faire du brute force

Commentaire de elguevel le 16/03/2009 21:31:14

non setCaracteres defini le jeu de caractere utilisé pour generer les mots, le mot de passe lui est renvoyé directement par la methode "nextPassword()".

Le brut force c'est simplement un type d'application qui peut etre fait avec une source comme celle ci, mais dans le cas d'un brute force non on ne connait pas le mot de passe, l'application permet juste de le retrouver en en faisant en serie puis en les testants.

Commentaire de Madvin le 01/04/2009 16:27:59

Salut !

Cette source n'est certainement pas de niveau "Initié". Un débutant est capable de la comprendre.
De plus, effectivement il est dommage que les mots "BruteForce" et "Password" aient été utilisés dans le code (faut quand même avouer que les mots clés catégorisant ton code sont plutôt douteux =/), sachant qu'il s'agit de l'implémentation d'un algorithme générique simple. D'autant plus que cela provoque des incompréhensions. La notion "d'incrémentation de chaines de caractères" me semble plus claire, et plus du tout ambiguë quand à la finalité de cette source.
Tu pourrais également faire passer en paramètre du main le nombre d'incrémentations à faire (par défaut 1). Cela éviterait de modifier le code source de ta classe à chaque fois.
Sinon un bon point sur la présentation du code qui est bien claire et indentée.

Commentaire de coucou747 le 01/04/2009 16:43:39

incrementer une chaine, ca ne veut rien dire... tu peux par contre parler d'incrementer un nombre ecrit dans une base.

en fait, si tu veux une definition de ton algo, on peut dire un truc genre :
soit E un alphabet, renvoyer un iterateur qui parcourt E* dans l'ordre suivant : soit deux mots ma et mb de tailles ta et tb, ma est avant mb si ta < tb ou si (ma = mb et strcmp(ma, mb) < 0)

On pourrait aussi dire que c'est un iterateur qui est construit a partir des iterateurs In avec n dans N, In = les permutations d'une chaine de E^n dans l'ordre lexicographique.

toujours avec l'alphabet E, tu peux dire que tu fais un iterateur sur les representations en base E des nombres entiers de 0 a l'infini.

avec cette derniere definition, tu peux parler d'incrementation de ton nombre en base E si tu veux. Mais ca laisse penser qu'on fait des convertions de bases, donc j'aime pas trop cette def.

Commentaire de elguevel le 01/04/2009 18:55:42

Je prend tres bonne notes de vos commentaires, je ne sais donc toujours pas comment nommer cette source simplement (çà ne reste qu'un titre)... :-/

Madvin> Je vais améliorer (dès que je trouve le temps) la source pour qu'elle soit plus facilement parametrable, et oui "Initié" est une erreur de ma part, çà n'a rien a faire à ce niveau.

Je vais egalement revoir le vocabulaire que j'utilise (en fait c'est un extrait d'un autre code, du coup ce n'est plus bien adapté).

Merci pour vos commentaires, j'aime la critique !

Commentaire de Madvin le 02/04/2009 14:26:03

@coucou747 : Tu as tout à fait raison. C'est effectivement un abus de langage et ta définition de la chose mathématiquement est bien évidemment plus juste. Néanmoins je ne pense pas qu'il faille présenter la chose mathématiquement comme tu le fais car ça compliquerait VRAIMENT la chose cette fois-ci ! C'est destiné à des débutants, faut pas oublier... et je crois pas qu'ils apprécieraient ce genre de définition !! =p... ^__^

Commentaire de coucou747 le 02/04/2009 14:39:40

:D c'est vrai qu'il y a trois ans, si on m'avait parle de permutations lexicogaphiques, je serais retourner faire du php :D

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

Convertir une chaine String en tableau de byte [ par JuS ] Bonjour,Je cherche à convertir une chaine de caractere String en un tableau de byte pour pouvoir correspondre en client/serveur à l'aide de sockets.Vo Extraction nombre d'un String [ par maxinfos ] Bonjour,voilà, j'ai un String contenant une chaine de caractère du style : "123.0 145.1 120.4 18 " etc ...j'aimerai appel de class en JAVA ds un package Tomcat 4.1.30 [ par coyote_fx ] Bonjour à tous bien voilà j'ai encore des problèmes.Non non ne me zappé pas.J'ai toujours des problème pour importer java.Voilà ma page JSP fait appel test de validité sur des string [ par dardo3 ] Bonjour tout le mondeProblemeje déclare une chaine de caracterestring xensuite je demande a l'utilisateur de rentrer une réponsesystem.out.print("entr Applet et BD MySQL [ par remidub ] Bonjour,j'ai un problème qui me gène depuis quelques temps,Je voudrai réaliser une applet qui lit des valeurs dans une base de données MySQL.J'ai char ecriture/lecture donnee num / texte dans fichier.txt [ par anisotrope ] Bonjour je voudrais ecrire et lire des donnees sous la forme suivante par exemple :5.5 , 3.01.5 , 2.0...Voila ce que j'ai ecris pour l'ecriture :publi tableau chaine de caracter [ par loupiti ] bonjour,je veux creer un tableau de chaine de caractere mais je n'y arrive pas String chaine[]=new String[2]; chaine={"Lsi", "Ms"};pouvez vous me di String avec ' remplacer par " \' " [ par BeebopMcFly ] Voila mon prb, g une chaine de caract&#232;re qui contient des quotes... natuellement j'aimerais transformer &#231;a en \' !! J'ai bien parcouru les f chaine de caractere [ par zhebulonn ] Bonjour, J'ai un probleme pour utiliser les chaines de caractere. En fait, je voudrais creer un JButton ayant pour nom un String donn&#233; en param&# tableau de car => string [ par monstor_rox ] Bonjour je voudrai savoir comment passer un tableau de caract&#232;re en string&nbsp;&nbsp;&nbsp;string&nbsp;chaine;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; try


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

Photothèque

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,889 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales