-2
votes

Script de force brute avec des boucles sans itertools

Nouveau à Python. Travailler sur des boucles. Essayer de construire une force brute simple sans utiliser de modules prêts. Voici le code:

[1]
[2]
[3]
[1, 1]
[1, 2]
[1, 3]
[2, 1]
[2, 2]
[2, 3]
and so on to the pass_len

python loops brute-force

0 commentaires

3 Réponses :

0
votes

Est-ce ce que vous recherchez?

numbers=[1,2,3]
password = [0]
pass_len = 3

for i in numbers :
    password [0] = i
    print (password)
password.append (0)
for n in range (1, pass_len + 1) :
    password [0] = n
    for i in numbers :
        password [1] = i
        print (password)

0 commentaires

0
votes

C'est le code que j'ai proposé. Il faut une approche différente à l'aide de générateurs, mais il vérifiera automatiquement toutes les solutions possibles. La seule importation est SYS pour échapper à la boucle imbriquée à la fin du code.

import sys
numbers = (1,2,3)
password_to_guess = (1,3)

def permutations(iterable, r = None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    if r > n:
        return
    indices = list(range(n))
    cycles = list(range(n, n-r, -1))
    yield tuple(pool[i] for i in indices[:r])
    while n:
        for i in reversed(range(r)):
            cycles[i] -= 1
            if cycles[i] == 0:
                indices[i:] = indices[i+1:] + indices[i:i+1]
                cycles[i] = n - i
            else:
                j = cycles[i]
                indices[i], indices[-j] = indices[-j], indices[i]
                yield tuple(pool[i] for i in indices[:r])
                break
        else:
            return

def perm_list():
    for i in range(len(numbers)):
        yield permutations(numbers , i)

perm_list = perm_list()

for i in perm_list:
    for j in i:
        if j == password_to_guess:
            print(f"{j} is the password")
            sys.exit()

1 commentaires

La fonction de permutation est celle contenue dans un module, mais elle n'est vraiment qu'une fonction que vous pouvez écrire.

0
votes

Profondeur naïf simple Première recherche Fonction récursive. Pas bon pour la performance ou les mots de passe de grande longueur.

travaux en prenant une liste et en vous appelant avec rec (liste + [... chaque élément en numéros]) code>, donc: rec ([]) code> va à son tour Call Rec ([] + [1]), Appelle Rec ([1] + [1]), Appelle Rec ([1,1] + [1]), retourne après [1,1,1] parce que Pass_Len a atteint, Appelle Rec ([1,1] + [2]) ... etc Si la longueur est atteinte, signifie aucun mot de passe trouvé dans cette branche, alors rentrez aucun de Si PWD (s) == X, puis le mot de passe trouvé, renvoyez les pwd (s) et renvoie tout le chemin de la sauvegarde de l'arborescence. P>

def pwd(p):
    return ', '.join(map(str, p))

numbers=[1,2,3]
password_to_guess = [1,3]
x = pwd(password_to_guess)
pass_len = 3

def rec(s):
    if pwd(s)==x: #password found, return password
        return s
    if len(s)==pass_len: #length reached, return Nothing
        return None
    for n in numbers:
        ret = rec(s+[n]) #call myself with n appended
        if ret!=None: #password found, return immediately
            return ret

print(pwd(rec([])))

0 commentaires