# -*- coding: utf-8-*-binary_base =[1,2,4,8,16,32,64,128]def cypher(message): cypher_words =[]for letter inmessage: cypher_letter =format(ord(letter),'b') cypher_words.append(cypher_letter)return' '.join(cypher_words)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: word =str(word) sumatory =0for value, letter inenumerate(word[::-1]):ifint(letter)==1: sumatory += binary_base[value] decipher_letter =chr(sumatory) decipher_message.append(decipher_letter)return"".join(decipher_message)def run():whileTrue: command =str(input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': message =str(input('Escribe un mensaje: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =str(input('Escribe un mensaje: ')) decipher_message =decipher(message)print('')print(decipher_message) elif command =='s':exit()print('salir')else:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()
muy fancy tu codigo, felicidades!
Hola me podrías explicar como hiciste para no tener que crear el diccionario KEY y simplemente basta con agregar la lista:
binary_base =[1,2,4,8,16,32,64,128]
Código en python 3:
def code(texto): binario =' '.join(format(x,'b')for x inbytearray(texto,'UTF-8'))return binario
def decode(binario): mensaje = binario.split(' ') texto =''.join(chr(int(x,base=2))for x in mensaje)return texto
def run(): mensaje =''while(True): opcion =str(input('''
••••••••••••••••••••••••••••••••••••••••••••••
CRIPTOGRAFIA ••••••••••••••••••••••••••••••••••••••••••••••
Seleccione una opción:[C]odificar
[D]ecodificar
[S]alir
''').upper())if(opcion =='C'): encrypted =code(input('Mensaje a codificar:'))print(encrypted)elif(opcion =='D'): unencrypted =decode(input('Mensaje a decodificar: '))print(' ')print('El mensaje original es: ',unencrypted)else:breakif __name__ =='__main__':run()
Muy bien y funciona. Olvidaba lo que significaban las sentencias for en una misma línea. Aquí está el concepto por si algiuen también lo olivdó:
KEYS={'a':'01100001','á':'11100001','b':'01100010','c':'01100011','d':'01100100','e':'01100101','é':'11101001','f':'01100110','g':'01100111','h':'01101000','i':'01101001','í':'11101101','j':'01101010','k':'01101011','l':'01101100','m':'01101101','n':'01101110','ñ':'11110001','o':'01101111','ó':'11110011','p':'01110000','q':'01110001','r':'01110010','s':'01110011','t':'01110100','u':'01110101','ú':'11111010','ü':'11111100','v':'01110110','w':'01110111','x':'01111000','y':'01111001','z':'01111010','A':'01000001','Á':'11000001','B':'01000010','C':'01000011','D':'01000100','E':'01000101','É':'11001001','F':'01000110','G':'01000111','H':'01001000','I':'01001001','Í':'11001101','J':'01001010','K':'01001011','L':'01001100','M':'01001101','N':'01001110','Ñ':'11010001','O':'01001111','Ó':'11010011','P':'01010000','Q':'01010001','R':'01010010','S':'01010011','T':'01010100','U':'01010101','Ú':'11011010','Ü':'11011100','V':'01010110','W':'01010111','X':'01011000','Y':'01011001','Z':'01011010',}def cypher(message): words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +=KEYS[letter] cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word =''for i inrange(0,len(word),8): binary = word[i:i+8]for key, value inKEYS.items():if value == binary: decipher_word += key
decipher_message.append(decipher_word)return' '.join(decipher_message)def run():whileTrue: command =str(input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': message =str(input('Escribe tu mensaje: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =str(input('Escribe tu mensaje tu cifrado: ')) decypher_message =decipher(message)print(decypher_message) elif command =='s':print('salir')breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()```
excelente compañero
En este reto use el algoritmo construido en la clase de encriptación y desincriptación, el cambio que le hice fue cargar en el diccionario el equivalente binario como valor para cada caracter que es usado como llave (key) en este, la lógica es la misma para ambos procesos:
# -*- coding: utf-8-*-'''
Created on 5/11/2019@author:Jose'''
KEYS={'a':'11110000','b':'11001100','c':'10101010','d':'01110001','e':'11000101','f':'00011001','g':'00010110','h':'11111111','i':'00000000','j':'11111000','k':'11100000','l':'10000000','m':'01111111','n':'00111111','o':'11000000','p':'11111110','q':'00000001','r':'00001111','s':'00010001','t':'11101110','u':'10111111','v':'01000000','w':'00100000','x':'11011111','y':'11101111','z':'00010000','A':'00001000','B':'11110111','C':'11111011','D':'00000100','E':'11111101','F':'00000010','G':'11110001','H':'00001110','I':'11001000','J':'00110111','K':'11001110','L':'00111110','M':'00110001','N':'00111001','O':'11011101','P':'10100000','Q':'10101111','R':'10110000','S':'11101110','T':'01111110','U':'10000001','V':'11000011','W':'11100111','X':'00111100','Y':'00011000','Z':'00011111','0':'11100000','1':'10001111','2':'10001000','3':'10001100','4':'10001001','5':'01110000','6':'01111001','7':'01110111','8':'10110011','9':'10111101','.':'10110100',',':'01001011','?':'01001110','!':'01000100',}def cypher(message): words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +=KEYS[letter] cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word ='' letters =[word[i:i+8]for i inrange(0,len(word),8)]for letter inletters:for key, value inKEYS.items():if value == letter: decipher_word += key
decipher_message.append(decipher_word)return' '.join(decipher_message)def run():whileTrue: command =str(input('''---*---*---*---*---*---*---*---Programa que encripta y desencripta mensajes.¿Qué quieres hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))print('')if command =='c': message =str(input('Escribe tu mensaje: ')) cypher_message =cypher(message)print('')print('El mensaje cifrado es: {}'.format(cypher_message))print('') elif command =='d': message =str(input('Escribe tu mensaje cifrado: ')) decypher_message =decipher(message)print('')print('El mensaje descifrado es: {}'.format(decypher_message))print('') elif command =='s':print('salir')breakelse:print('')print('Opción de menú no encontrada!')print('')if __name__ =='__main__':print('')print('M E N S A J E S C I F R A D O S E N B I N A R I O')print('')run()
La imagen a continuación presenta las pruebas realizadas al programa:
: words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''.join(format(ord(x),'b')for x in word) cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word =''.join(chr(int(word[i*7:i*7+7],2))for i inrange(len(word)//7)) decipher_message.append(decipher_word)return' '.join(decipher_message)def run():whileTrue: command =str(raw_input('''---*---*---*---*---*---*---*---*---*---*---*---*---Bienvenido a criptografía con binarios de Platzi.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''.decode("UTF-8").encode(sys.stdin.encoding)))print('')if command =='c': message =str(raw_input('Escribe tu mensaje: ')) cypher_message =cypher(message)print('')print('El mensaje cifrado es: {}.'.format(cypher_message))print('') elif command =='d': message =str(raw_input('Para cifrar tu mensaje, procura que los binarios cifrados, no contengan acentos españoles (por ejemplo, tíldes). \nEscribe tu mensaje tu cifrado: '.decode("UTF-8").encode(sys.stdin.encoding))) decypher_message =decipher(message)print('')print('El mensaje descifrado es: {}.'.format(decypher_message).decode("UTF-8").encode(sys.stdin.encoding))print('') elif command =='s':print('')print('**********Se terminó el programa. Gracias por usarlo***********'.decode("UTF-8").encode(sys.stdin.encoding))breakelse:print('¡Comando no encontrado!'.decode("UTF-8").encode(sys.stdin.encoding))if __name__ =='__main__':print('')print('M E N S A J E S C I F R A D O S')print('')run()
Hago las pruebas y esto es lo que sucede:
Como ven al descifrar el binario, no se obtiene el Herrán correctamente.
SI alguien tiene una solución a ese problema, no duden en hacérmelo saber. Se los agradeceré eternamente.
Hola, si notaste que tu función encripta así:
['ú''?'' ''t'>>>[format(ord(x),'b')for x in a]['11111010','111111','100000','1110100']8667
y al desencriptar asumes que todos tus términos traen 7 caracteres;
puedes corregirlo agregando '0' por la izquierda hasta completar 8 caracteres a tus letras cifradas.
Hola Haider... Si voy a probarlo..... Gracias por tu aporte....
# -*- coding: utf-8-*-import binascii
def cypher(message): encoding='utf-8' errors='surrogatepass' bits =bin(int(binascii.hexlify(message.encode(encoding, errors)),16))[2:]return bits.zfill(8*((len(bits)+7)// 8))def decipher(message): encoding='utf-8' errors='surrogatepass' n =int(message,2)returnint2bytes(n).decode(encoding, errors)def int2bytes(i): hex_string ='%x'% i
n =len(hex_string)return binascii.unhexlify(hex_string.zfill(n +(n &1)))def run():whileTrue: command =str(raw_input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': message =str(raw_input('Escribe tu mensaje: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =str(raw_input('Escribe tu mensaje tu cifrado: ')) decypher_message =decipher(message)print(decypher_message) elif command =='s':returnFalseelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()
Acabo de terminar mi codigo pero lo hice diferente ya que empece de cero sin tomar el codigo anterior y cuando tenia que cifrar el mensaje utilice una funcion recursiva creo que eso quedo hermoso, pero tuve problemas con los caracteres como los de punto, coma, espacio, ya que siempre devolvian una cadena binaria menor a 7 y con la letra “ñ” “Ñ” este caracter esta en el codigo ascci extendido.
Favor sus criticas a mi código, gracias
Quiero seguir mejorando
# -*- coding: utf-8-*-def cifrar(codigo_ascii, binario): # inicia la funcion recursiva
if codigo_ascii ==0: # preguntamos si es igual a cero para terminar la función
returnstr(codigo_ascii %2)+ binario # devolvemos el valor una vez terminado
returncifrar((int(codigo_ascii /2)),str(codigo_ascii %2)+ binario) # el valor en cada vuelta recursiva
def decifrar(binario): n =7 # es el largo que tiene el binario por cada caracter
result =0 # donde voy sumando el resultado de la multiplicación y el elevado en base dos
for i inbinario: # ciclo para recorrer el binario
result = result +(int(i)*(2**n)) # aquí esta la magía para tener el resultado
n = n -1 # le voy restando 1 en cada pasada para que vaya elevando el número que corresponda
returnchr(result) # entrego el codigo asccí y lo resulvo con el comando chr
def run():whileTrue: op =str(input(''' >----Menu----<[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if op =='c': # opción encriptar
mensaje =str(input('Ingrese el mensaje a encriptar = ')) mensaje_encrip =str('') # inicializo cripte como string vacio
for i inmensaje: codigobinario =str('') # inicializo la varible como string vacia
cripte =str(cifrar(ord(i), codigobinario)) # concateno y voy a la función recursiva para encriptar
iflen(cripte)<8: # este es un problema cuando es un carater tipo punto o espacio
cripte ='0'+ cripte
mensaje_encrip +=' '+ cripte
print('este es el codigo cifrado = {}'.format(mensaje_encrip)) # muestro el resultado
elif op =='d': # opción desencriptar
mensaje =str(input('Ingrese el mensaje a desencriptar = ')) enigma =str() # aquí vamos guardando y concatenando el resultado de la función decifrar
chrbinario =str() # iniciamos limpia la variable
for j inmensaje: # recorremos el mensaje
if j ==' ': chrbinario =str() # limpicamos cada vez que aprace una nueva cadena de binarios
else: chrbinario += j # Vamos concatenando cada valor
iflen(chrbinario)==8: # es una cadena de binario
enigma +=decifrar(chrbinario) # vamos a la función con toda la cadena y concatenamos el resultado
chrbinario =str() # limpiamos nuestra variable
print('este es el codigo decifrado = {}'.format(enigma)) elif op =='s':break # salimos del ciclo whileelse:print('Debe ingresar una opción valida') # cada vez que ingresa un opción erronea
if __name__ =='__main__':print(' <--- CIFRADO BINARIO --->')run()
def cypher(text): wordList =list(text) newWord =[]for letter inwordList: x =format(ord(letter),'b')iflen(x)==6: x ='0'+ x
newWord.append(x)return''.join(newWord)def decipher(text): newWord =[]iflen(text)%7!=0:returnNonefor x inrange(7,len(text),7): newWord.append(chr(int(text[x-7:x],2)))return''.join(newWord)def run():whileTrue: command =input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
''')if command[0]=='c': text =input('Introduce el texto que quieres cifrar:\n') newText =cypher(text)print(newText) elif command[0]=='d': text =input('Introduce el texto que quieres decifrar:\n') newText =decipher(text)ifnewText:print(newText)else:print('Error en valor inicial') elif command[0]=='s':breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()```
ingresa el mensaje:message
cyphered message:0b11011010b11001010b11100110b11100110b11000010b11001110b1100101
Decyphered message:message
Costó, pero salió. Un conversor de texto a binario y de binario a texto (también convierte caracteres especiales, números, etc.).
# -*- coding: utf-8-*-def cypher(message): words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +='{0:012b}'.format(ord(letter))+' ' cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word ='' binarios = word.split(' ')for palabra inbinarios: numero =0for letra inpalabra: numero = numero*2+int(letra) decipher_word +=chr(numero) decipher_message.append(decipher_word)return' '.join(decipher_message)def run():whileTrue: command =str(raw_input('''---*---*---*---*---*---*---*---*---*---Bienvenido al conversor de texto a binario.¿Qué deseas hacer?[t]exto a binario
[b]inario a texto
[s]alir
'''))if command =='t': message =str(raw_input('Escribe tu mensaje: ')) cypher_message =cypher(message)print('')print('Tu mensaje en binario es:')print('')print(cypher_message)print('') elif command =='b': message =str(raw_input('Escribe el mensaje en binario: ')) decypher_message =decipher(message)print('')print('Tu texto es:')print('')print(decypher_message)print('') elif command =='s':breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('')print('C O N V E R S O R D E T E X T O A B I N A R I O')run()
import base64
def codificar(str):return base64.encodebytes(str.encode('utf-8'))def decodificar(bts):return base64.decodebytes(bts).decode('utf-8')def run(): message ='Hola, este mensaje se codificara usando el sistema binario.'print('mensaje original: {}'.format(message)) msg_cod =codificar(message)print('mensaje codificado: {}'.format(msg_cod)) msg_dec =decodificar(msg_cod)print('mensaje decodificado: {}'.format(msg_dec))if __name__ =='__main__':run()
AYUDA
Mi código para cifrar de mensaje a binario funciona perfectamente. Pero de binario a mensaje no, devuelve el mismo binario ¿En qué puedo estar fallando?
# -*- coding: utf-8-*-KEYS={'a':'01100001','b':'01100010','c':'01100011','d':'01100100','e':'01100101','f':'01100110','g':'01100111','h':'01101000','i':'01101001','j':'01101010','k':'01101011','l':'01101100','m':'01101101','n':'01101110','o':'01101111','p':'01110000','q':'01110001','r':'01110010','s':'01110011','t':'01110100','u':'01110101','v':'01110110','w':'01110111','x':'01111000','y':'01111001','z':'01111010','A':'01000001','B':'01000010','C':'01000011','D':'01000100','E':'01000101','F':'01000110','G':'01000111','H':'01001000','I':'01001001','J':'01001010','K':'01001011','L':'01001100','M':'01001101','N':'01001110','O':'01001111','P':'01010000','Q':'01010001','R':'01010010','S':'01010011','T':'01010100','U':'01010101','V':'01010110','W':'01010111','X':'01011000','Y':'01011001','Z':'01011010','0':'0','1':'1','2':'10','3':'11','4':'101','6':'110','7':'111','8':'1000','9':'1001','.':'00101110',',':'00101100','?':'00111111','!':'00100001',}def cypher(message): words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +=KEYS[letter] cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word =''for letter inword:for key, value inKEYS.items():if value == letter: decipher_word += key
decipher_message.append(decipher_word)return' '.join(decipher_message)def run():print('Bienvenido al encriptador binario')print('')print('Por favor elije lo que deseas hacer')whileTrue: command =str(input('''---*---*---*---*---*---*---*---[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': message =input(str('Por favor escribe el mensaje que deseas cifrar a binario: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =input(str('Por favor escribe el mensaje en binario que deseas convertir: ')) decipher_message =decipher(message)print('El mensaje cifrado es {}'.format(decipher_message)) elif command =='s':print('salir')else:print('¡Comando no encontrado!')if __name__ =='__main__':run()
Nicolás, en la función decipher, el código
for letter inword:for key, value inKEYS.items():if value == letter: decipher_word += key
Extrae un carácter de la palabra cifrada y lo compara con cada uno de los valores del diccionario. Em el diccionario 0 y 1 tienen el mismo valor.
'0':'0','1':'1',
Por lo que repite lo mimo que ingresaste para descifrar.
En python hay una función que convierte a binario (bin()), pero prefiero ejercitar la programación y decidí crear la función desde 0
# -*- coding: utf-8-*-KEYS={'a':'w','b':'E','c':'x','d':'1','e':'a','f':'t','g':'0','h':'C','i':'b','j':'!','k':'z','l':'8','m':'M','n':'I','o':'d','p':'.','q':'U','r':'Y','s':'i','t':'3','u':',','v':'J','w':'N','x':'f','y':'m','z':'W','A':'G','B':'S','C':'j','D':'n','E':'s','F':'Q','G':'o','H':'e','I':'u','J':'g','K':'2','L':'9','M':'A','N':'5','O':'4','P':'?','Q':'c','R':'r','S':'O','T':'P','U':'h','V':'6','W':'q','X':'H','Y':'R','Z':'l','0':'k','1':'7','2':'X','3':'L','4':'p','5':'v','6':'T','7':'V','8':'y','9':'K','.':'Z',',':'D','?':'F','!':'B',}def cypher(message):'''
Función que cifra un mensaje. @Parametro str:message -->Mensaje a encriptar
@Return str -->Mensaje encriptado
'''
words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +=KEYS[letter] cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message):'''
Función que decifra un mensaje. @Parametro str:message -->Mensaje a desencriptar
@Return str -->Mensaje desencriptado
'''
words = message.split(' ') decipher_message =[]for word inwords: decipher_word =''for letter inword:for key, value inKEYS.items():if value == letter: decipher_word += key
decipher_message.append(decipher_word)return' '.join(decipher_message)def toBin(num):'''
Funcion que convierte un numero en binario
@parametro int:num ->Numero a convertir a binario de 7 posiciones
@return str ->String con el numero convertido a binario
'''
bin_numInv =[] bin_num =[] #Se convierte a binario
while num >1: bin_numInv.append(num %2)if(num // 2 == 1): bin_numInv.append(num // 2) num //= 2 #Si el binario es menor de 7 espacios, se rellena con 0if(len(bin_numInv)<7): con =7-len(bin_numInv)for i inrange(con): bin_num.append('0') #Se ordena el binario
for j inreversed(bin_numInv): bin_num.append(str(j))return''.join(bin_num)def toBinario(message):'''
Funcion que convierte un mensaje a binario. @parametro str:message->String a convertir a binario
@return str ->String del mensaje convertido a binario
'''
words = message.split(' ') toNum_message =[]for word inwords: toNum_word =[] toNum_letter =''for letter inword: toNum_letter =toBin(ord(letter)) toNum_word.append(toNum_letter) toNum_message.append(''.join(toNum_word))return' '.join(toNum_message)def run():whileTrue: command =str(input('''---*---*---*---*---*---*---*---Bienvenido a criptografia.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[b]inario mensaje
b[i]nario mensaje
[s]alir
'''))if command =='c': message =str(input('Escribe tu mensaje: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =str(input('Escribe tu mensaje tu cifrado: ')) decypher_message =decipher(message)print(decypher_message) elif command =='b': message =str(input('Escribe tu mensaje: ')) binario_message =toBinario(cypher(message))print(binario_message) elif command =='s':print('salir')breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()
para convertir en binario el código de cifrado ya realizado se debe buscar el alfabeto binario y remplazarlo por nuestro diccionario, esto hace el cifrado, de la palabra, el de descifrado se complica un poco porque se debe separar en bits cada letra, se debe hacer un import de la librería textwrap.
# -*- coding: utf-8-*-import sys, textwrap
KEYS={'a':'01110111','b':'01000101','c':'01111000','d':'00110001','e':'01100001','f':'01110100','g':'00110000','h':'01000011','i':'01100010','j':'00100001','k':'01111010','l':'00111000','m':'01001101','n':'01001001','o':'01100100','p':'00101110','q':'01010101','r':'01011001','s':'01101001','t':'00110011','u':'00101100','v':'01001010','w':'01001110','x':'01100110','y':'01101101','z':'01010111','A':'01000111','B':'01010011','C':'01101010','D':'01101110','E':'01110011','F':'01010001','G':'01101111','H':'01100101','I':'01110101','J':'01100111','K':'00110010','L':'00111001','M':'01000001','N':'00110101','O':'00110100','P':'00111111','Q':'01100011','R':'01110010','S':'01001111','T':'01010000','U':'01101000','V':'00110110','W':'01110001','X':'01001000','Y':'01010010','Z':'01101100','0':'01101011','1':'00110111','2':'01011000','3':'01001100','4':'01110000','5':'01110110','6':'01010100','7':'01010110','8':'01111001','9':'01001011','.':'01011010',',':'01000100','?':'01000110','!':'01000010',}def cypher(message): words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +=KEYS[letter] cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: word = textwrap.wrap(word,8) decipher_word =''for letter inword:for key, value inKEYS.iteritems():if value == letter: decipher_word += key
decipher_message.append(decipher_word)return' '.join(decipher_message)def run():whileTrue: command =str(raw_input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': message =str(raw_input('Escribe tu mensaje: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =str(raw_input('Escribe tu mensaje tu cifrado: ')) decypher_message =decipher(message)print(decypher_message) elif command =='s':print('saliendo') sys.exit()else:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()
Tenía razón Diegoesteban13, se necesitaba separar de a ocho bits.
KEYS={'a':'01100001','b':'01100010','c':'01100011','d':'01100100','e':'01100101','f':'01100110','g':'01100111','h':'01101000','i':'01101001','j':'01101010','k':'01101011','l':'01101100','m':'01101101','n':'01101110','o':'01101111','p':'01110000','q':'01110001','r':'01110010','s':'01110011','t':'01110100','u':'01110101','v':'01110110','w':'01110111','x':'01111000','y':'01111001','z':'01111010','A':'01000001','B':'01000010','C':'01000011','D':'01000100','E':'01000101','F':'01000110','G':'01000111','H':'01001000','I':'01001001','J':'01001010','K':'01001011','L':'01001100','M':'01001101','N':'01001110','O':'01001111','P':'01010000','Q':'01010001','R':'01010010','S':'01010011','T':'01010100','U':'01010101','V':'01010110','W':'01010111','X':'01011000','Y':'01011001','Z':'01011010','0':'00000000','1':'00000001','2':'00000010','3':'00000011','4':'00000100','5':'00000101','6':'00000110','7':'00000111','8':'00001000','9':'00001001','.':'00001010',',':'00001011','?':'00001100','!':'00001101',}def cypher(message): #esta es la función para encriptar
words = message.split(' ') #cada vez que encuentra un espacio
cypher_message =[] #genera una palabra.for word inwords: #recorre cada palabra
cypher_word ='' #lista vacia
for letter inword: #recorre cada letra.cypher_word+=KEYS[letter] #rellena con el valor.cypher_message.append(cypher_word) #va guardando las palabras encriptadas.return' '.join(cypher_message) #forma el mensaje encriptado.#ahora lo hacemos al revés, tenemos el valor de la llave
#y debemos obtener la llave o letra.defdecipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word ='' separated_word =separate_chars(word)for letter inseparated_word:for key, value inKEYS.items():if value == letter: decipher_word += key
decipher_message.append(decipher_word) #forma el mensaje
return' '.join(decipher_message)def separate_chars(word): chars =[] ch ='' count =0for char inword: count +=1 ch += char
if(count %8==0): chars.append(ch) ch =''return chars
def run():whileTrue: command =str(input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': message =str(input('Escribe mensaje a encriptar: ')) #Guarda el mensaje en una variable.cypher_message=cypher(message) #llamamos a la función y le entrega como
#parametro el mensaje.La guarda en una variable.print(cypher_message) elif command =='d': message =str(input('Escribe tu mensaje encriptado: ')) decypher_message =decipher(message)print(decypher_message) elif command =='s':print('salir')else:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()```
La implementación es igual que el ejercicio de criptografía con dos diferencias:
Hay que cambiar el value del diccionario por su equivalencia en binario
A la hora de pasar de binario a texto normal, tenemos que tener en cuenta que cada 8 números en binario tenemos una equivalencia en texto, por lo tanto tenemos que, antes de hacer la equivalencia, dividir de 8 en 8. La librería textwrap tiene una función que nos permite hacer esto, llamada wrap.
import textwrap
KEYS={'a':'01100001','b':'01100010','c':'01100011','d':'01100100','e':'01100101','f':'01100110','g':'01100111','h':'01101000','i':'01101001','j':'01101010','k':'01101011','l':'01101100','m':'01101101','n':'01101110','o':'01101111','p':'01110000','q':'01110001','r':'01110010','s':'01110011','t':'01110100','u':'01110101','v':'01110110','w':'01110111','x':'01111000','y':'01111001','z':'01111010','A':'01000001','B':'01000010','C':'01000011','D':'01000100','E':'01000101','F':'01000110','G':'01000111','H':'01001000','I':'01001001','J':'01001010','K':'01001011','L':'01001100','M':'01001101','N':'01001110','O':'01001111','P':'01010000','Q':'01010001','R':'01010010','S':'01010011','T':'01010100','U':'01010101','V':'01010110','W':'01010111','X':'01011000','Y':'01011001','Z':'01011010','0':'00110000','1':'00110001','2':'00110010','3':'00110011','4':'00110100','5':'00110101','6':'00110110','7':'00110111','8':'00111000','9':'00111001','.':'00101110',',':'00101100','?':'00111111','!':'00100001',}def text_to_binary(message): words = message.split(' ') binary_message =[]for word inwords: binary_word =''for letter inword: binary_word +=KEYS[letter] binary_message.append(binary_word)return' '.join(binary_message)# En este caso tenemos primero que desgranar el binary text en una lista separando por grupos de 8 letras, que corresponderá a un value
def binary_to_text(message): words = message.split(' ') text_message =[]for word inwords: word = textwrap.wrap(word,8) text_word =''for letter inword:for key, value inKEYS.items():if value == letter: text_word += key
text_message.append(text_word)return' '.join(text_message)def run():whileTrue: command =str(input('''---*---*---*---*---*---*---*---Bienvenido a al traductor.¿Qué deseas hacer?[t]exto a binario
[b]inario a texto
[s]alir
'''))if command =='t': message =str(input('Escribe tu texto: ')) result =text_to_binary(message)print(result) elif command =='b': message =str(input('Escribe tu texto en binario: ')) result =binary_to_text(message)print(result) elif command =='s':print('salir')breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('T R A D U C T O R D E T E X T O A B I N A R I O')run()
# -*- coding: utf-8-*-#criptografía binaria
CODIGO={'a':'01100001','b':'01100010','c':'01100011','d':'01100100','e':'01100101','f':'01100110','g':'01100111','h':'01101000','i':'01101001','j':'01101010','k':'01101011','l':'01101100','m':'01101101','n':'01101110','o':'01101111','p':'01110000','q':'01110001','r':'01110010','s':'01110011','t':'01110100','u':'01110101','v':'01110110','w':'01110111','x':'01111000','y':'01111001','z':'01111010','A':'01000001','B':'01000010','C':'01000011','D':'01000100','E':'01000101','F':'01000110','G':'01000111','H':'01001000','I':'01001001','J':'01001010','K':'01001011','L':'01001100','M':'01001101','N':'01001110','O':'01001111','P':'01010000','Q':'01010001','R':'01010010','S':'01010011','T':'01010100','U':'01010101','V':'01010110','W':'01010111','X':'01011000','Y':'01011001','Z':'01011010','0':'00000000','1':'00000001','2':'00000010','3':'00000011','4':'00000100','5':'00000101','6':'00000110','7':'00000111','8':'00001000','9':'00001001','.':'00101110',',':'00101100','?':'00111111','!':'00100001',}def cifrado(mensaje): palabras = mensaje.split(' ') mensaje_cifrado =[]for palabra inpalabras: palabra_cifrada =''for letra inpalabra: palabra_cifrada +=CODIGO[letra] mensaje_cifrado.append(palabra_cifrada)return' '.join(mensaje_cifrado)def decifrado(mensaje): palabras = mensaje.split(' ') mensaje_decifrado =[]for palabra inpalabras: palabra_decifrada ='' cod_decimal ='' digito =''for n_decimal inrange(len(palabra)): #se maneja range, ya que si uso palbra solo no me deja usarla para sacar el numero binario correspondiante al indice
digito = palabra[n_decimal] cod_decimal += palabra[n_decimal]iflen(cod_decimal)==8:for key,value inCODIGO.items():if value == cod_decimal: palabra_decifrada += key
cod_decimal ='' mensaje_decifrado.append(palabra_decifrada)return' '.join(mensaje_decifrado)def run():whileTrue: opcion =str(input('''---*---*---*---*---*---*---*---Bienvenido a criptografía.¿Qué deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if opcion =='c': mensaje =str(input('Escribe tu mensaje: ')) mensaje_cifrado =cifrado(mensaje)print(mensaje_cifrado) elif opcion =='d': mensaje =str(input('Escribe tu mensaje cifrado: ')) decipher_message =decifrado(mensaje)print(decipher_message) elif opcion =='s':breakelse:print('Opción no valida')if __name__ =='__main__':print('E N C R I P T A C I O N')run()
# -*- coding: utf-8-*-BASE={'a':'01100001','á':'11100001','b':'01100010','c':'01100011','d':'01100100','e':'01100101','é':'11101001','f':'01100110','g':'01100111','h':'01101000','i':'01101001','í':'11101101','j':'01101010','k':'01101011','l':'01101100','m':'01101101','n':'01101110','ñ':'11110001','o':'01101111','ó':'11110011','p':'01110000','q':'01110001','r':'01110010','s':'01110011','t':'01110100','u':'01110101','ú':'11111010','ü':'11111100','v':'01110110','w':'01110111','x':'01111000','y':'01111001','z':'01111010','A':'01000001','Á':'11000001','B':'01000010','C':'01000011','D':'01000100','E':'01000101','É':'11001001','F':'01000110','G':'01000111','H':'01001000','I':'01001001','Í':'11001101','J':'01001010','K':'01001011','L':'01001100','M':'01001101','N':'01001110','Ñ':'11010001','O':'01001111','Ó':'11010011','P':'01010000','Q':'01010001','R':'01010010','S':'01010011','T':'01010100','U':'01010101','Ú':'11011010','Ü':'11011100','V':'01010110','W':'01010111','X':'01011000','Y':'01011001','Z':'01011010'}def cypher(message): words = message.split(' ') cypher_message =[]for word inwords: cypher_word =''for letter inword: cypher_word +=BASE[letter] cypher_message.append(cypher_word)return' '.join(cypher_message)def decipher(message): words = message.split(' ') decipher_message =[]for word inwords: decipher_word =''for i inrange(0,len(word),8): binary = word[i:i+8]for key, value inBASE.items():if value == binary: decipher_word += key
decipher_message.append(decipher_word)return' '.join(decipher_message)def run():whileTrue: command =str(raw_input('''---*---*---*---*---*---*---*---Bienvenido a criptografía de binarios.¿Qué deseas hacer?[c]ifrar mensaje a binarios
[d]ecifrar binarios a mensaje
[s]alir
---*---*---*---*---*---*---*---'''))if command =='c': message =str(raw_input('Escribe tu mensaje: ')) cypher_message =cypher(message)print(cypher_message) elif command =='d': message =str(raw_input('Escribe tu mensaje tu cifrado: ')) decypher_message =decipher(message)print('El binario desifrado es: {}'.format(decypher_message)) elif command =='s':breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':print('M E N S A J E S C I F R A D O S')run()
Luego de un par de horas , lo logré!, funciona para cualquier caracter, por ejemplo:( Hola, cómo sumo 1+1=2 en Python 3.7? en binario es 010010000110111101101100011000010010110000100000011000111111001101101101011011110010000001110011011101010110110101101111001000000011000100101011001100010011110100110010001000000110010101101110001000000101000001111001011101000110100001101111011011100010000000110011001011100011011100111111 ), además tiene la opción de entregar el mensaje cifrado separado (útil para probarlo en esta página
# # -*- coding: utf-8-*-def cifrar(cf_0, op):if op =='y':return' '.join([x.replace('0b','0'*(10-len(x)))for x in[bin(ord(x))for x inlist(cf_0)]])else:return''.join([x.replace('0b','0'*(10-len(x)))for x in[bin(ord(x))for x inlist(cf_0)]])def descifrar(df_0):return''.join([chr(int(df_0.replace(' ','')[x:x+8],2))for x inrange(0,len(df_0.replace(' ','')),8)])def run():print('M E N S A J E S C I F R A D O S')whileTrue: command =str(input('''---*---*---*---*---Bienvenido,Que deseas hacer?[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
'''))if command =='c': mensaje =input('Escribe tu mensaje: ') op =input('\n Lo quiere con espacios?, (y,n): ')print('El mensaje cifrado es:\n',cifrar(mensaje, op)) elif command =='d': mensaje =input('Escribe tu mensaje tu cifrado: ')print('El mensaje descifrado es:\n',descifrar(mensaje)) elif command =='s':print('Adios!')breakelse:print('¡Comando no encontrado!')if __name__ =='__main__':run()
Hola compañeros, les dejo mi aporte.
def convert_to_binary(character):return'{0:08b}'.format(ord(character))def convert_from_binary(letter_in_ascii): integer =int(letter_in_ascii,2)returnchr(integer)def cypher(message): cypher_message =""for letter inmessage: cypher_message +=str(convert_to_binary(letter))return cypher_message
def decipher(message): cypher_message =""for idx inrange(0,len(message),8): cypher_message +=str(convert_from_binary(message[idx:idx+8]))return cypher_message
def run():whileTrue: command =str(input("""---*---*---*---***---Whatdo you want to do?[c]overt a message to binary
[d]ecipher a message from binary
[o]ut
"""))if command =="c": message =str(input("Write your message:")) cypher_message =cypher(message)print("Your cypher message is:{}".format(cypher_message)) elif command =="d": message =str(input("Write your cyphered message:")) decipher_message =decipher(message)print(decipher_message) elif command =="o":breakelse:print("Command not found")if __name__ =="__main__":run()
