[Enlace externo eliminado para invitados]
[Enlace externo eliminado para invitados]
Características:
+ Encripta cadenas de máximo 246 caracteres.
+ El resultado es una cadena aleatoria + binario.
+ Todo el código está comentado por si alguien quisiera ver en más detalle el algoritmo.
+ Está listo para su uso, correr el código con Python e interactuar con la consola.
Código:
import random
def encode(string, psw):
#Generamos la cadena aleatoria de 10 digitos
cadena_aleatoria = str(random.randint(0, 9))
while len(cadena_aleatoria) != 10:
cadena_aleatoria = cadena_aleatoria + str(random.randint(0, 9))
#Con la cadena aleatoria podemos formar nuestra cadena de inicio y con la cadena de inicio formar la lista de los 256 elementos alternada.
#Para ello usaremos la funcion lista256_generator.
lista256 = lista256_generator(cadena_aleatoria, psw)
#Ahora pasamos a binario la lista 256 alternada y el mensaje original:
binMSG = binLST = ""
i = 0
while i < len(string):
caracter_MSG_binario = bin(ord(string[i])).replace("b", "").zfill(8)
caracter_LST_binario = bin(lista256[i]).replace("b", "").zfill(8)
if len(caracter_MSG_binario) == 9:
caracter_MSG_binario = caracter_MSG_binario[1:9]
if len(caracter_LST_binario) == 9:
caracter_LST_binario = caracter_LST_binario[1:9]
binMSG = binMSG + caracter_MSG_binario
binLST = binLST + caracter_LST_binario
i += 1
#Ya tenemos nuestras cadenas en binario, ahora las comparamos para formar la cadena final.
cadena_final = comparar_cadenas(binMSG, binLST)
#El mensaje codificado a enviarse se compone de cadena aletoria + cadena final
return (cadena_aleatoria + cadena_final)
def decode(string, psw):
#Lo primero es obtener la cadena aleatoria que son los primeros 10 digitos.
cadena_aleatoria = string[:10]
#Con la cadena aleatoria ya podemos obtener la cadena de inicio y a su ves la lista de los 256 elementos alternada.
lista256 = lista256_generator(cadena_aleatoria, psw)
#La pasamos a binario:
binLST = ""
i = 0
while i < 256:
caracter_LST_binario = bin(lista256[i]).replace("b", "").zfill(8)
if len(caracter_LST_binario) == 9:
caracter_LST_binario = caracter_LST_binario[1:9]
binLST = binLST + caracter_LST_binario
i += 1
#Para obtener la cadena binMSG original comparamos la cadena que nos estan entregando (cadena_final) con el binLST que generamos anteriormente.
cadena_final = string[10:]
binMSG = comparar_cadenas(cadena_final, binLST)
#Ahora queda transformar la cadena binaria a texto plano.
if (len(binMSG) % 8) == 0:
repeticiones = (len(binMSG) // 8)
j = k = 0
valor_original = ""
while k <= (repeticiones - 1):
segmento_8 = binMSG[j:j + 8]
ascii_value = bin_to_ascii(segmento_8)
str_value = chr(ascii_value)
valor_original = valor_original + str(str_value)
j += 8
k += 1
else:
print("Invalid text to decode.")
return
return valor_original
def lista256_generator(cadena_aleatoria, psw):
#Generamos la cadena de inicio de 256 digitos
cadena_de_inicio = ""
while len(cadena_de_inicio) <= 256:
cadena_de_inicio = str(cadena_de_inicio) + str(psw) + str(cadena_aleatoria)
if len(cadena_de_inicio) > 256:
cadena_de_inicio = cadena_de_inicio[:256]
#Creamos la lista con 256 elementos numerados del 0 al 255 en orden
lista256 = list(range(0, 256))
#Intercambiamos sus primeros 256 elementos segun la formula: lista256[i] <> lista256[i + cadena_de_inicio[i]]
i = 0
while i < 256:
elemento_inicial = lista256[i]
if (i + int(cadena_de_inicio[i])) < 256:
elemento_a_intercambiar = lista256[i + int(cadena_de_inicio[i])]
lista256[i] = elemento_a_intercambiar
lista256[i + int(cadena_de_inicio[i])] = elemento_inicial
else:
elemento_a_intercambiar = lista256[i + int(cadena_de_inicio[i]) - 256]
lista256[i] = elemento_a_intercambiar
lista256[i + int(cadena_de_inicio[i]) - 256] = elemento_inicial
i += 1
return lista256
def comparar_cadenas(cadena1, cadena2):
i = 0
cadena_final = ""
while i <= (len(cadena1) - 1):
if cadena1[i] != cadena2[i]:
cadena_final += "1"
else:
cadena_final += "0"
i += 1
return cadena_final
def bin_to_ascii(bin_number):
bin_number_str = str(bin_number)
if len(bin_number_str) == 8:
i = 0
dec_number = 0
while i <= 7:
dec_number = dec_number + (int(bin_number_str[i]) * (2 ** (7 - i)))
i += 1
return dec_number
else:
return "Error decoding."
print("#############################################\n####### CipherSaber Encode/Decode #######\n####### Autor: azav3 #######\n####### Also known as: Szudisch, Azav #######\n####### Dedication: indetectables.net #######\n")
while True:
eleccion = input("\nCHOOSE YOUR MODE: \n+To encode write e\n+To decode write d\n>")
if eleccion == "e":
while True:
string = input("\nPlease enter your plain text (max length = 246 characters)\n>")
if len(string) <= 246 and len(string) > 0:
break
else:
print("The plain text must contain at least 1 character and a maximum lenght of 246 characters.")
while True:
psw = input("\nPlease enter a password (only numbers allowed) (max length = 246 characters)\n>")
if psw.isdigit() and len(psw) <= 246 and len(psw) > 0:
break
if not psw.isdigit() and len(psw) != 0:
print("The password must contain ONLY numbers.")
if len(psw) > 246 or len(psw) == 0:
print("Submitted password has " + str(len(psw)) + " characters. Max lenght = 246. Min lenght = 1.")
print("\nTexto encriptado: " + encode(string, psw))
elif eleccion == "d":
while True:
string = input("\nPlease enter your binary text (max length = 1978 characters)\n>")
if len(string) <= 1978 and len(string) >= 18 and string.isdigit() and ((len(string) - 10) % 8 == 0):
break
if not string.isdigit():
print("The text must be binary text, only using 1 and 0's.")
if len(string) > 1978 or len(string) < 18:
print("The plain text must contain at least 18 character and a maximum lenght of 1978 characters.")
if ((len(string) - 10) % 8 != 0):
print(str(len(string)) + " is not a valid amount of characters to this encryption.")
while True:
psw = input("\nPlease enter the password (only numbers allowed) (max length = 246 characters\n>")
if psw.isdigit() and len(psw) <= 246 and len(psw) > 0:
break
if not psw.isdigit():
print("The password must contain ONLY numbers.")
if len(psw) > 246 or len(psw) == 0:
print("Submitted password has " + str(len(psw)) + " characters. Max lenght = 246. Min lenght = 1.")
print("\nTexto plano: " + decode(string, psw))
else:
print("Please enter a valid mode.")
Nos vemos!