Discussion :

[_ruz_]

Bonjour, j'avais trouvé le script d'un bruteforce sur le net récemment, je me suis creusé la tête plusieures heures et rien n'y fait, je n'arrive pas a comprendre la logique derrière.

Voici le script:
(On admet un form "Main", un bouton "Button", une textbox "Textbox")

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
Public Class Main
 
    Const dico As String = "abcdefghijklmnopqrstuvwxyz"
 
    Private Sub Button_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button.Click
        Dim t As Integer
        t = 1
 
        While True
            AllKey("", t)
            t += 1
        End While
    End Sub
 
    Private Sub AllKey(ByVal Pass As String, ByVal Lg As Integer)
 
        Dim i As Integer
        If Pass.Length < Lg Then
            For i = 0 To dico.Length - 1
                AllKey(Pass & dico.Substring(i, 1), Lg)
            Next i
        Else
            TextBox.Text = Pass
            Application.DoEvents()
        End If
 
    End Sub
 
End Class

J'ai compris que si l'on modifie la valeur de t, le bruteforce commencera avec t caractères.

Merci beaucoup à ceux qui peuvent m'éclaircir, bonne soirée

[clementmarcotte]

Bonjour,

L'idée de base de la récursivité est de permettre à une procédure de s'appeler elle-même. L'image qui me viens en tête, c'est un individu qui se clone une première fois et ensuite le clone engendre automatiquement un second clone et le second clone engendre automatiquement un troisième et ainsi de suite. Quand le dernier clone a terminé son ouvrage, il fait rapport à l'avant-dernier et il disparaît. L'avant-dernier transmet son propre rapport et le rapport du denier, à son précédent, et disparaît à son tour; et le cycle continue. Si bien qu'à la fin de tout, il ne reste que le tout premier qui a reçu tout les rapports et qui termine le travail.

La récursivité permet en théorie de réduire sérieusement l'activité de codage, mais est très gourmande en ressources.

[Pol63]

la récursivité permet de coder certaines choses facilement
ca correspond en quelque sorte à une boucle contenant une boucle contenant une boucle etc... n fois
en théorie impossible à écrire autrement car on ne peut pas ajouter des boucles à l'exécution

bref dans ton cas Allkey va creer une chaine de caractère de x caractères, et sur ton button_click la boucle va faire que ca va demander tous les mots de passe de 1 (t) caractères, puis 2 puis 3
concrètement au 1er appel de allkey, la chaine est vide et lg vaut 1
lg est le paramètre de longueur en court de test
ca passe dans le if, pass.length vaut 0 donc ca passe dans la 1ère branche (then)
là ca va appeler allkey (donc elle même) mais avec de nouveaux paramètres, une nouveau string est créé dans la boucle for pour chaque lettre du dico
donc 26 appels à allkey vont être appelé successivement
mais ils vont bien être résolus chacun leur tour
le 1er tour va envoyer "a",1
là ca passe dans le if, pass.length vaut 1 et n'est donc pas inférieur à lg donc on passe dans le else, ca affiche le pass, puis logiquement ca arrive au end sub
les appels sont dépilés on revient à la ligne Next i
et ca appelle allkey avec "b",1

une fois les 26 combinaisons faites ca revient à button_click, qui augemente t de 1 (=2 donc) t équivaut à lg dans la sub
là ca devient plus interressant au niveau de la récursivité
pass.length vaut à nouveau 0
donc on va appeler allkey "a",1
pass.length vaut 1 dans le nouvel appel, donc ca rajoute "a", allkey est alors appelé avec "aa",1
pass.length vaut 2 donc ca écrit et ca sort
là au niveau d'avant on avait "a", on est au 2ème tour de boucle donc ca appelle allkey avec "ab",1
etc...

ca ne doit pas être très clair ^^, donc fait du pas à pas et regarde la fenêtre pile des appels en même temps
regarde les variables évoluer et tu devrais mieux comprendre

chaque appel à une méthode est empilé, et en sortie ca dépile pour revenir à la ligne d'exécution de l'appelant
même si AllKey est plusieurs fois à la suite dans la pile, les variables sont biens des variables différente pour chaque élément de la pile


pour reprendre l'image des clones, quand ca cherche les combinaisons de 3 caractères le 1er clone créé 26 clones en leur donnant une lettre à chacun (a-...-z), ces 26 clones vont chacun créer 26 clones en leur disant de rajouter un lettre (aa.az-...-za.zz) etc..
et le dernier clone écrit dans le textbox (dans ton code il n'y a pas de remonté à l'appelant initial, mais la récursivité peut s'écrire comme ca (peut etre conseillé d'ailleurs))
et au niveau de l'ordre d'exécution, les 26 clones ne sont pas créé en même temps, chaque clone finit une branche avant d'en entamer une autre
a
aa
aaa
<fin>
aab
<fin>
(...)
aaz
<fin>
<fin>
ab
aba
<fin>
...

[Invité]

règle infaillible pour comprendre du code : le débogage