Fonction brute force multi thread avec l'exemple d'utilisation qui met en oeuvre le calcul du pourcentage, du débit et du te

Description

Cette fonction permet d'effectuer un Brute Force (technique consistant à tester toutes les combinaisons de lettres) simple mais aussi un brute force multi-thread.
Le brute force multi-Thread vous sera utile si vous devez faire un test à chaque nouvelle combinaison trouvée et que ce test implique l'attente d'une réponse (la réponse d'un serveur par exemple), je m'explique : si vous êtes dans ce cas-là et que vous n'utilisez qu'un seul thread, vous devez par exemple attendre 2 secondes entre chaque mots de passe et donc la capacité de votre ordinateur n'est pas utilisée au maximum !
Alors que si vous vous servez de plusieurs threads (par exemple 20 threads), vous irez 20 fois plus vite !
La fonction permet :
-de choisir les caractères à utiliser dans le brute force.
-de choisir le nombre maximum de caractères générés.
-de reprendre le brute force à partir d'une chaîne de caractères.
L'exemple d'utilisation de la fonction (donc le programme) permet de calculer :
-le pourcentage effectué.
-le débit (nombre de combinaison trouvés par secondes)
-le temps restant.

Tous les tests nécessaires au bon fonctionnement du programme sont aussi présents dans l'exemple, donc normalement, il ne doit y avoir aucun bug... à part la limitation du nombre maximum de caractères générés ! (je n'y ai trouvé aucune solution, mais ne vous inquiètez pas, vous pouvez quand même effectuer un brute force contenant 36 caractères avec maximum 9 caractères générés).

Les fonctions permettant de lancer un simple thread et un multi thread sont différentes, le code se trouvant si dessous ne permet que de faire un brute force simple....

Et vous pouvez utiliser librement cette fonction (avec son exemple) si elle vous plaît !

Source / Exemple :


Procedure TMain.BruteForce(Caracteres: ShortString; NbCarMax, NbCarBegin: SmallInt; StartFrom: ShortString);
Var I: Integer;
    Chaine: Array of Char;
    StrChaine: ShortString;
    NumeroPossibility, NbPossibilities: Extended;
begin
        // Calcul du nombre de possibilités
        NbPossibilities:=0;
        For I:=NbCarBegin To NbCarMax do
                NbPossibilities:=NbPossibilities+Power(Length(Caracteres), I);
        // Si on doit commencer à partir d'une chaîne, compter le nombre de possibilités déjà effectuées
        NumeroPossibility:=0;
        For I:=1 To Length(StartFrom) do
                NumeroPossibility:=NumeroPossibility + (Pos(StartFrom[I], Caracteres)-1) * Power(Length(Caracteres), Length(StartFrom)-I );
        For I:=1 To Length(StartFrom)-1 do
                NumeroPossibility:=NumeroPossibility + Power(Length(Caracteres), I);
        // Mettre toutes les variables à 0
        SetLength(Chaine, NbCarMax);
        // Regarder à partir de quelle chaine il faut commencer
        // La Chaine à la fin de la boucle va ressembler à ça par ex : "#0#0#0#0#0#0a" ou "#0#0testa"
        For I:=0 To NbCarMax-1 do
        begin
                // Si il faut reprendre à partir d'une chaîne
                If (Length(StartFrom)>0) and (I>=NbCarMax-Length(StartFrom)) Then
                        Chaine[I]:=StartFrom[I-(NbCarMax-Length(StartFrom)-1)]
                else begin
                        If I>=NbCarMax-NbCarBegin Then
                                Chaine[I]:=Caracteres[1]
                                else
                                Chaine[I]:=Chr(0);
                end;
        end;

        While (NumeroPossibility<NbPossibilities) and (StopSimpleBruteForce=False) do
        begin
                // Si on est en mode pause
                While PauseSimpleBruteForce=True do
                        Sleep(1000);

                // Ajouter une possibilitée essayée
                NumeroPossibility:=NumeroPossibility+1;

                // Monter un "string" avec la chaine du tableau
                // Je ne sais pas comment effectuer un "Copy" pour directement mettre dans le string
                // et donc, cette technique fait paumer du temps (le for)
                For I:=0 To NbcarMax-1 do
                        If Chaine[I]<>chr(0) Then StrChaine:=StrChaine+Chaine[I];

                // C'EST ICI QU'IL FAUT METTRE LES DIFFERENTS TESTS SUR CHAQUE CHAINE
                // LA CHAÎNE EST "StrChaine"
		// La progression peut être représetée comme ça : NumeroPossibility/NbPossibilities

                // Trouver une autre chaîne
                StrChaine:='';
                For I:=NbcarMax-1 downto 0 do
                begin
                        If Pos(Chaine[I], Caracteres)<Length(Caracteres) Then
                        begin
                                Chaine[I]:=Caracteres[Pos(Chaine[I], Caracteres)+1];
                                Break;
                        end else begin
                                Chaine[I]:=Caracteres[1];
                        end;
                end;

                // Laisser les évênements extérieur se dérouler
                Application.ProcessMessages;
        end;
end;

Conclusion :


J'ai besoin d'aide (pour améliorer la performance du code) : savez-vous comment faire pour convertir un tableau de caractères en string (le tableau contient des caractères nuls au début de la chaîne et je ne veux pas qu'ils soient inclus dans la convertion) ?
Le tableau ressemble à ça par ex : "#0, #0, [a], [b], [c]" et je veux le convertir en ça : "abc" sans utiliser de boucle car ça ralenti.
Si vous avez une solution, vous seriez cool de me la communiquer...

Pour information, normalement, je vais créer un programme utilisant cet exemple permettant de retrouver le mot de passe d'une adresse email...

Voilà, sinon, vous pouvez commenter et noter, ça serait sympa à vous !

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.