Algoritmo de fuerza bruta de Python

algorithm brute-force

Question

Necesito generar todas las combinaciones posibles de un conjunto de caracteres dado a un rango dado. Me gusta,

charset=list(map(str,"abcdefghijklmnopqrstuvwxyz"))
range=10

Y la salida debe ser,

[a,b,c,d..................,zzzzzzzzzy,zzzzzzzzzz]

Sé que puedo hacer esto usando bibliotecas ya en uso. Pero necesito saber cómo funcionan realmente. Si alguien me puede dar un código comentado de este tipo de algoritmo en Python o cualquier lenguaje de programación legible, estaría muy agradecido.

Answer 1

Solución simple utilizando los itertools y los módulos de cadena.

# modules to easily set characters and iterate over them
import itertools, string 

# character limit so you don''t run out of ram
maxChar = int(input(''Character limit for password: ''))  

# file to save output to, so you can look over the output without using so much ram
output_file = open(''insert filepath here'', ''a+'') 

# this is the part that actually iterates over the valid characters, and stops at the 
# character limit.
x = list(map(''''.join, itertools.permutations(string.ascii_lowercase, maxChar))) 

# writes the output of the above line to a file 
output_file.write(str(x)) 

# saves the output to the file and closes it to preserve ram
output_file.close() 

Pagué la salida a un archivo para guardar el ram, y usé la función de entrada para que pueda establecer el límite de caracteres en algo como "hiiworld". A continuación se muestra la misma secuencia de comandos, pero con un conjunto de caracteres más fluido utilizando letras, números, símbolos y espacios.

import itertools, string

maxChar = int(input(''Character limit for password: ''))
output_file = open(''insert filepath here'', ''a+'')

x = list(map(''''.join, itertools.permutations(string.printable, maxChar)))
x.write(str(x))
x.close()

Answer 2

Encontré otra forma muy fácil de crear diccionarios usando itertools.

generator=itertools.combinations_with_replacement(''abcd'', 4 )

Esto recorrerá todas las combinaciones de ''a'', ''b'', ''c'' y ''d'' y creará combinaciones con una longitud total de 1 a 4. es decir. a, b, c, d, aa, ab ........., dddc, dddd. El generador es un objeto de itertool y se puede recorrer normalmente de esta manera,

for password in generator:
        ''''.join(password)

Cada contraseña es de hecho de tipo tupla y puede trabajar en ellas como lo hace normalmente.

Answer 3

Prueba esto:

import os
import sys

Zeichen=["a","b","c","d","e","f","g","h"­,"i","j","k","l","m","n","o","p","q­","r","s","­;t","u","v","w","x","y","z"]
def start(): input("Enter to start")
def Gen(stellen): if stellen==1: for i in Zeichen: print(i) elif stellen==2: for i in Zeichen:    for r in Zeichen: print(i+r) elif stellen==3: for i in Zeichen: for r in Zeichen: for t in Zeichen:     print(i+r+t) elif stellen==4: for i in Zeichen: for r in Zeichen: for t in Zeichen: for u in Zeichen:    print(i+r+t+u) elif stellen==5: for i in Zeichen: for r in Zeichen: for t in Zeichen: for u in    Zeichen: for o in Zeichen: print(i+r+t+u+o) else: print("done")

#*********************
start()
Gen(1)
Gen(2)
Gen(3)
Gen(4)
Gen(5)

Answer 4

Si REALMENTE desea realizar una fuerza bruta, intente esto, pero le tomará una cantidad de tiempo ridícula:

your_list = ''abcdefghijklmnopqrstuvwxyz''
complete_list = []
for current in xrange(10):
    a = [i for i in your_list]
    for y in xrange(current):
        a = [x+i for i in your_list for x in a]
    complete_list = complete_list+a

En un ejemplo más pequeño, donde list = ''ab'' y solo subimos hasta 5, esto imprime lo siguiente:

[''a'', ''b'', ''aa'', ''ba'', ''ab'', ''bb'', ''aaa'', ''baa'', ''aba'', ''bba'', ''aab'', ''bab'', ''abb'', ''bbb'', ''aaaa'', ''baaa'', ''abaa'', ''bbaa'', ''aaba'', ''baba'', ''abba'', ''bbba'', ''aaab'', ''baab'', ''abab'', ''bbab'', ''aabb'', ''babb'', ''abbb'', ''bbbb'', ''aaaaa'', ''baaaa'', ''abaaa'', ''bbaaa'', ''aabaa'', ''babaa'', ''abbaa'', ''bbbaa'', ''aaaba'',''baaba'', ''ababa'', ''bbaba'', ''aabba'', ''babba'', ''abbba'', ''bbbba'', ''aaaab'', ''baaab'', ''abaab'', ''bbaab'', ''aabab'', ''babab'', ''abbab'', ''bbbab'', ''aaabb'', ''baabb'', ''ababb'', ''bbabb'', ''aabbb'', ''babbb'', ''abbbb'', ''bbbbb'']

Answer 5

Si realmente desea un algoritmo de fuerza bruta, no guarde ninguna lista grande en la memoria de su computadora, a menos que desee un algoritmo lento que se bloquee con un error de memoria.

Podrías intentar usar itertools.product como este:

from string import ascii_lowercase
from itertools import product

charset = ascii_lowercase  # abcdefghijklmnopqrstuvwxyz
maxrange = 10


def solve_password(password, maxrange):
    for i in range(maxrange+1):
        for attempt in product(charset, repeat=i):
            if ''''.join(attempt) == password:
                return ''''.join(attempt)


solved = solve_password(''solve'', maxrange)  # This worked for me in 2.51 sec

itertools.product(*iterables) devuelve los productos cartesianos de los iterables que ingresó.

[i for i in product(''bar'', (42,))] devuelve, por ejemplo, [(''b'', 42), (''a'', 42), (''r'', 42)]

El parámetro de repeat permite hacer exactamente lo que pidió:

[i for i in product(''abc'', repeat=2)]

Devoluciones

[(''a'', ''a''),
 (''a'', ''b''),
 (''a'', ''c''),
 (''b'', ''a''),
 (''b'', ''b''),
 (''b'', ''c''),
 (''c'', ''a''),
 (''c'', ''b''),
 (''c'', ''c'')]

Nota :

Querías un algoritmo de fuerza bruta, así que te lo di. Ahora, es un método muy largo cuando la contraseña comienza a ser más grande porque crece exponencialmente (tomó 62 segundos para encontrar la contraseña ''resuelta''). También puede usar un código de contraseña ya existente o generarlo con peajes como cupp ( github )

Answer 6

Una solución mediante recursión:

def brute(string, length, charset):
    if len(string) == length:
        return
    for char in charset:
        temp = string + char
        print(temp)
        brute(temp, length, charset)

Uso:

brute("", 4, "rce")

Answer 7

Use itertools.product , combinado con itertools.chain para juntar las diferentes longitudes:

from itertools import chain, product
def bruteforce(charset, maxlength):
    return (''''.join(candidate)
        for candidate in chain.from_iterable(product(charset, repeat=i)
        for i in range(1, maxlength + 1)))

Demostración:

>>> list(bruteforce(''abcde'', 2))
[''a'', ''b'', ''c'', ''d'', ''e'', ''aa'', ''ab'', ''ac'', ''ad'', ''ae'', ''ba'', ''bb'', ''bc'', ''bd'', ''be'', ''ca'', ''cb'', ''cc'', ''cd'', ''ce'', ''da'', ''db'', ''dc'', ''dd'', ''de'', ''ea'', ''eb'', ''ec'', ''ed'', ''ee'']

Esto producirá eficientemente palabras progresivamente más grandes con los conjuntos de entrada, hasta longitud máxima de longitud.

No intente generar una lista en memoria de 26 caracteres hasta una longitud de 10; en su lugar, iterar sobre los resultados producidos:

for attempt in bruteforce(string.ascii_lowercase, 10):
    # match it against your password, or whatever
    if matched:
        break

Answer 8

itertools es ideal para esto:

itertools.chain.from_iterable((''''.join(l)
                               for l in itertools.product(charset, repeat=i))
                              for i in range(1, maxlen + 1))

Answer 9

from random import choice

sl = 4  #start length
ml = 8 #max length 
ls = ''9876543210qwertyuiopasdfghjklzxcvbnm'' # list
g = 0
tries = 0

file = open("file.txt",''w'') #your file

for j in range(0,len(ls)**4):
    while sl <= ml:
        i = 0
        while i < sl:
            file.write(choice(ls))
            i += 1
        sl += 1
        file.write(''/n'')
        g += 1
    sl -= g
    g = 0
    print(tries)
    tries += 1


file.close()

Answer 10

import string, itertools

    #password = input("Enter password: ")

    password = "abc"

    characters = string.printable

    def iter_all_strings():
        length = 1
        while True:
            for s in itertools.product(characters, repeat=length):
                yield "".join(s)
            length +=1

    for s in iter_all_strings():
        print(s)
        if s == password:
            print(''Password is {}''.format(s))
            break