json_AT = descifrado #.decode("utf-8", "ignore") # Extraer los datos del mensaje clave, emisor = json.loads(json_AT) print("\t\tMensaje de", emisor, ": ", json_AT, "\n") return clave, emisor # 0 - Obtener la clave entre Alice y TTP Kbt = open("KBT.bin", "rb").read() # 3 - Recibir mensaje cifrado desde el TTP print("Abriendo conexión...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5551) socket.escuchar() print("Conexión establecida.\n") print("\tRecibiendo...") datos_AB = socket.recibir() mac_AB = socket.recibir() nonce_AB = socket.recibir() print("\tMensaje recibido.") Kab, emisor = descifrar3(Kbt, datos_AB, mac_AB, nonce_AB) # 4.1 - Generar un valor aleatorio Rb Rb = get_random_bytes(16) # 4.2 - Challenge-response
fileIn = open("key", "r") t_bt = fileIn.read() fileIn.close() # Consigo K_AB decipher_aes_b_t = AES.new(key_b_t, AES.MODE_ECB) json_a_b = unpad(decipher_aes_b_t.decrypt(bytearray.fromhex(t_bt)), BLOCK_SIZE_AES).decode("utf-8") print("Hijack, A->B (Clear): " + json_a_b) msg_a_b = json.loads(json_a_b) a_key_a_b, a_alice = msg_a_b a_key_a_b = bytearray.fromhex(a_key_a_b) ##################################################################### # PROCESO DE ATAQUE ##################################################################### print("Conecto a Bob") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 6666) socket.conectar() # Conectado # Paso 3 socket.enviar(bytearray.fromhex(t_bt)) print("M->B: " + t_bt) # Paso 4 datos = socket.recibir() decipher_aes_a_b = AES.new(a_key_a_b, AES.MODE_ECB) json_b_a = (unpad(decipher_aes_a_b.decrypt(datos), BLOCK_SIZE_AES).decode("utf-8")) print("B->M (Clear): " + json_b_a) msg_b_a = json.loads(json_b_a) b_random = bytearray.fromhex(msg_b_a) b_random = int(b_random.hex(), 16) - 1 b_random = hex(b_random)[2:] json_a_b = json.dumps(b_random)
from socket_class import SOCKET_SIMPLE_TCP from rsa_class import RSA_OBJECT from aes_class import AES_CIPHER from Crypto.Hash import SHA256 from Crypto.Random import get_random_bytes import base64 import json # Recibe la informacion del cliente ################################### # Crea el socket en 5555 print("Creando socket y escuchando...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socket.escuchar() # Recibe los datos y cierra el socket datos = socket.recibir() json_vendedor = datos.decode("utf-8", "ignore") socket.cerrar() # Decodifica los datos msg_cliente = json.loads(json_vendedor) json_banco_cifrado_hex, IV_banco_hex, digital_envelope_hex, PIMD_hex, OI_vendedor, firma_dual_hex, pub_usuario_hex = msg_cliente ##################################################### # A REALIZAR POR EL ALUMNO # # Comprobar que la informacion recibida por parte # del cliente es integra, considerando en este caso # la firma dual computada por dicho cliente ######################################################
# - Mensaje cifrado para el banco # - IV usado en el mensaje cifrado para el banco # - "digital envelope" (clave del mensaje cifrado para el banco, cifrado con kPubBanco) # - PIMD # - OI # - Firma dual # - Certificado del usuario msg_vendedor = [] msg_vendedor.append(json_banco_cifrado.hex()) msg_vendedor.append(IV_banco.hex()) msg_vendedor.append(digital_envelope.hex()) msg_vendedor.append(PIMD.hex()) msg_vendedor.append(OI_Str) msg_vendedor.append(firma_dual.hex()) msg_vendedor.append(RSA_Usuario.get_PublicKeyPEM().hex()) json_vendedor = json.dumps(msg_vendedor) # Abre una conexion al vendedor socketVendedor = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socketVendedor.conectar() # Envia los datos print("Cliente -> Vendedor: mensaje") socketVendedor.enviar(json_vendedor.encode("utf-8")) # Cierra el canal socketVendedor.cerrar() print("Cliente finalizado correctamente")
from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP from random import randint # Parametros key_b_t = b'FEDCBA9876543210' BLOCK_SIZE_AES = 16 # Crea el socket servidor y escucha print("Creando socket y escuchando...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5556) socket.escuchar() # A->B: EBT(KAB,ALICE) datos = socket.recibir() msg_b_t = bytearray.fromhex(datos.decode("UTF-8")) # B descifra los datos a través de la clave KBT, guarda la clave KAB y la identidad # de Alicia y crea un valor random denominado Rb uncipher_b_t = AES.new(key_b_t, AES.MODE_ECB) json_b_t = unpad(uncipher_b_t.decrypt(msg_b_t), BLOCK_SIZE_AES).decode("UTF-8", "ignore") print("A->B: " + json_b_t)
from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP # Parametros key_a_t = b'0123456789ABCDEF' key_b_t = b'FEDCBA9876543210' BLOCK_SIZE_AES = 16 # Crea el socket servidor y escucha print("Creando socket y escuchando...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socket.escuchar() # A->T: Alice, Bob, Ra datos = socket.recibir() json_a_t = datos.decode("utf-8", "ignore") print("A->T: " + json_a_t) msg_a_t = json.loads(json_a_t) # T: Guarda Alice, Bob, Ra t_alice, t_bob, t_random = msg_a_t t_random = bytearray.fromhex(t_random) ############################################################################ # COMPLETAR: CREAR K_AB, CREAR E_BT(K_AB, Alice), ENVIAR EL MENSAJE A ALICE ############################################################################
return random, receptor, clave, cifrado_mensaje, cifrado_mac, cifrado_nonce # 0 - Obtener la clave entre Alice y TTP Kat = open("KAT.bin", "rb").read() # 1.1 - Generar un valor aleatorio Ra Ra = get_random_bytes(16) # 1.2 - Enviar el mensaje cifrado a TTP mensaje = ["Alice", "Bob", Ra] datos_AT, mac_AT, nonce_AT = cifrar12(Kat, mensaje) print("Creando conexión con TTP...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5550) socket.conectar() print("Conexión establecida.\n") print("\tEnviando...") socket.enviar(datos_AT) socket.enviar(mac_AT) socket.enviar(nonce_AT) print("\tMensaje enviado.\n") # 2.3 - Esperar la respuesta de TTP print("\tRecibiendo...") datos_TA = socket.recibir() mac_TA = socket.recibir() nonce_TA = socket.recibir() print("\tMensaje recibido.")
msg_a_b = json.loads(json_b_t) a_k_ab, b_alice = msg_a_b t_k_ab = bytearray.fromhex(a_k_ab) key_a_t=t_k_ab ##################################################################### # COMPLETAR: CONTACTAR CON BOB, SEGUIR EL PROTOCOLO NEEDHAM-SCHROEDER ##################################################################### # Crea el socket servidor y escucha socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5556) socket.conectar() # A envia a B el mensaje recibido por parte del servidor dirigido a B # A->B: EBT(KAB,ALICE) socket.enviar(mensajecapturado) # B genera el valor aleatorio y se lo envía a A usando la clave AB (challengee-response) #B->A: EAB(RB) mensaje = socket.recibir() decipher_b_a = AES.new(t_k_ab, AES.MODE_ECB) json_b_a = unpad(decipher_b_a.decrypt(mensaje),BLOCK_SIZE_AES).decode("UTF-8") print("T->A: " + json_b_a)
from Crypto.Cipher import PKCS1_OAEP, DES, AES from Crypto.PublicKey import RSA from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP # Parametros key_a_t = b'0123456789ABCDEF' BLOCK_SIZE_AES = 16 # Abre una conexion a T socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socket.conectar() # A: Crear campos a_alice = "Alice" a_bob = "Bob" a_random = get_random_bytes(8) # A: msg_a_t = Alice, Bob, Ra msg_a_t = [] msg_a_t.append("Alice") msg_a_t.append("Bob") msg_a_t.append(a_random.hex()) json_a_t = json.dumps(msg_a_t) # A->T: msg_a_t
# Crear Clave KAT, guardar a fichero KAT = funciones_aes.crear_AESKey() FAT = open("KAT.bin", "wb") FAT.write(KAT) FAT.close() # Crear Clave KBT, guardar a fichero KBT = funciones_aes.crear_AESKey() FBT = open("KBT.bin", "wb") FBT.write(KBT) FBT.close() # Crear el socket de escucha de Bob (5551) print("Esperando a Bob...") socket_Bob = SOCKET_SIMPLE_TCP('127.0.0.1', 5551) socket_Bob.escuchar() # Crea la respuesta para B y A: K1 y K2 K1 = funciones_aes.crear_AESKey() K2 = funciones_aes.crear_AESKey() # Paso 1) B->T: KBT(Bob, Nb) en AES-GCM cifrado = socket_Bob.recibir() cifrado_mac = socket_Bob.recibir() cifrado_nonce = socket_Bob.recibir() _, t_nb = descifraPasos1y3("B", KBT, cifrado, cifrado_mac, cifrado_nonce) # Paso 2) T->B: KBT(K1, K2, Nb) en AES-GCM # A empezar a resolver!!!!!!!
msg_ET = json.loads(json_ET) # Extraigo el contenido, y lo devuelvo t_k1, t_k2, t_ne = msg_ET t_k1 = bytearray.fromhex(t_k1) t_k2 = bytearray.fromhex(t_k2) t_ne = bytearray.fromhex(t_ne) return t_k1, t_k2, t_ne # Lee clave KBT KBT = open("KBT.bin", "rb").read() # Crear el socket de conexion con T (5551) print("Creando conexion con T...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5551) socket.conectar() # Paso 1) B->T: KBT(Bob, Nb) en AES-GCM t_n_origen = get_random_bytes(16) cifrado, cifrado_mac, cifrado_nonce = cifraPaso1("B", "T", KBT, "Bob", t_n_origen) socket.enviar(cifrado) socket.enviar(cifrado_mac) socket.enviar(cifrado_nonce) # Paso 2) T->B: KBT(K1, K2, Nb) en AES-GCM cifrado = socket.recibir() cifrado_mac = socket.recibir() cifrado_nonce = socket.recibir() socket.cerrar()
from Crypto.Cipher import PKCS1_OAEP, DES, AES from Crypto.PublicKey import RSA from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP # Parametros key_a_t = b'0123456789ABCDEF' BLOCK_SIZE_AES = 16 # Abre una conexion a T socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socket.conectar() # A: Crear campos, Paso 1-1 a_alice = "Alice" a_bob = "Bob" a_random = get_random_bytes(8) # A: msg_a_t = Alice, Bob, Ra msg_a_t = ["Alice", "Bob", a_random.hex()] json_a_t = json.dumps(msg_a_t) # A->T: msg_a_t, Paso 1-2 print("A->T: " + json_a_t) socket.enviar(json_a_t.encode("utf-8"))
print(emisor + "->" + receptor + " (descifrado): " + json_ET) # Cifra los datos con AES GCM aes_engine = funciones_aes.iniciarAES_GCM(KET) t_cifrado, t_mac, t_nonce = funciones_aes.cifrarAES_GCM( aes_engine, json_ET.encode("utf-8")) return t_cifrado, t_mac, t_nonce # Lee clave KBT KBT = open("KBT.bin", "rb").read() # Crear el socket de conexion con T (5551) print("Creando conexion con T...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5551) socket.conectar() # Paso 1) B->T: KAT(Alice, Na) en AES-GCM t_n = get_random_bytes(16) cifrado, cifrado_mac, cifrado_nonce = cifraPaso1("B", "T", KBT, "Bob", t_n) socket.enviar(cifrado) socket.enviar(cifrado_mac) socket.enviar(cifrado_nonce) # Paso 2) T->B: KBT(K1, K2, Nb) en AES-GCM # A empezar a resolver!!!!!!! # Espero a Alice para el paso 5) # Paso 5) A->B: KAB(Nombre) en AES-CTR con HMAC
# 0 - Crear la clave entre Alice/Bob y TTP Kat = aes.crear_AESKey() fichero_Kat = open("KAT.bin", "wb") # La clave entre Alice y TTP fichero_Kat.write(Kat) # se escribe en un fichero fichero_Kat.close() # (simulando el intercambio) Kbt = aes.crear_AESKey() fichero_Kbt = open("KBT.bin", "wb") # La clave entre Bob y TTP fichero_Kbt.write(Kbt) # se escribe en un fichero fichero_Kbt.close() # (simulando el intercambio) # 1.2 - Escuchar conexiones print("Esperando conexión con Alice...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5550) socket.escuchar() print("Conexión establecida.\n") print("\tRecibiendo...") datos_AT = socket.recibir() mac_AT = socket.recibir() nonce_AT = socket.recibir() print("\tMensaje recibido.") emisor, receptor, random = descifrar12(Kat, datos_AT, mac_AT, nonce_AT) # 2.1 - Crear clave entre el emisor (Alice) y el receptor (Bob) Kab = aes.crear_AESKey() print("\tClave entre", emisor, "y", receptor, "creada.")
from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad,unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP # Parametros key_a_t = b'0123456789ABCDEF' key_b_t = b'FEDCBA9876543210' BLOCK_SIZE_AES = 16 # Crea el socket servidor y escucha print("Creando socket y escuchando...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socket.escuchar() # A->T: Alice, Bob, Ra datos = socket.recibir() json_a_t = datos.decode("utf-8" ,"ignore") print("A->T: " + json_a_t) msg_a_t = json.loads(json_a_t) # T: Stores Alice, Bob, Ra ; creates random K_AB t_alice, t_bob, t_random = msg_a_t t_random = bytearray.fromhex(t_random) key_a_b = get_random_bytes(16) # T: msg_t_a = Ra, Bob, K_AB, E_BT(K_AB, Alice)
FAT = open("KAT.bin", "wb") FAT.write(KAT) FAT.close() # Crear Clave KBT, guardar a fichero KBT = funciones_aes.crear_AESKey() FBT = open("KBT.bin", "wb") FBT.write(KBT) FBT.close() # Crear el socket de escucha de Bob (5551) print("Esperando a Bob...") socket_Bob = SOCKET_SIMPLE_TCP('127.0.0.1', 5551) socket_Bob.escuchar() # Crea la respuesta para B y A: K1 y K2 K1 = funciones_aes.crear_AESKey() K2 = funciones_aes.crear_AESKey() # Paso 1) B->T: KBT(Bob, Nb) en AES-GCM cifrado = socket_Bob.recibir() cifrado_mac = socket_Bob.recibir() cifrado_nonce = socket_Bob.recibir() _, t_nb = descifraPasos1y3("B", KBT, cifrado, cifrado_mac, cifrado_nonce) # Paso 2) T -> B : KBT(K1, K2, Nb) en AES-GCM # A empezar a resolver!!!!!!!
print(emisor + " -> " + receptor + " (descifrado): " + json_ET) # Cifra los datos con AES GCM motor_AES = funciones_aes.iniciarAES_GCM(KET) cifrado_T, mac_T, nonce_T = funciones_aes.cifrarAES_GCM(motor_AES, json_ET.encode("utf-8")) return cifrado_T, mac_T, nonce_T # Lee clave KBT KAT = open("KAT.bin", "rb").read() # Crear el socket de conexion con T (5550) print("Creando conexion con T...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5550) socket.conectar() # Paso 3) A->T: KAT(Alice, Na) en AES-GCM num = get_random_bytes(16) cifrado, cifrado_mac, cifrado_nonce = cifraPaso3("A", "T", KAT, "Alice", num) socket.enviar(cifrado) socket.enviar(cifrado_mac) socket.enviar(cifrado_nonce) # Paso 4 print("Comienza el paso 4 en A") cifrado_Ta1 = socket.recibir()
from Crypto.Cipher import PKCS1_OAEP, DES, AES from Crypto.PublicKey import RSA from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad,unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP # Parametros key_a_t = b'0123456789ABCDEF' BLOCK_SIZE_AES = 16 # Abre una conexion a T socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5555) socket.conectar() # A: Crear campos(Alice,bob,random a) a_alice = "Alice" a_bob = "Bob" a_random = get_random_bytes(8) # A: msg_a_t = Alice, Bob, Ra(Creo el mensaje) msg_a_t = [] msg_a_t.append("Alice") msg_a_t.append("Bob") msg_a_t.append(a_random.hex()) json_a_t = json.dumps(msg_a_t) # A->T: msg_a_t(Se lo mando a trent)
# Crear Clave KAT, guardar a fichero KAT = funciones_aes.crear_AESKey() FAT = open("KAT.bin", "wb") FAT.write(KAT) FAT.close() # Crear Clave KBT, guardar a fichero KBT = funciones_aes.crear_AESKey() FBT = open("KBT.bin", "wb") FBT.write(KBT) FBT.close() # Crear el socket de escucha de Bob (5551) print("Esperando a Bob...") socket_Bob = SOCKET_SIMPLE_TCP('127.0.0.1', 5551) socket_Bob.escuchar() # Crea la respuesta para B y A: K1 y K2 K1 = funciones_aes.crear_AESKey() K2 = funciones_aes.crear_AESKey() # Paso 1) B->T: KBT(Bob, Nb) en AES-GCM cifrado = socket_Bob.recibir() cifrado_mac = socket_Bob.recibir() cifrado_nonce = socket_Bob.recibir() _, t_nb = descifraPasos1y3("B", KBT, cifrado, cifrado_mac, cifrado_nonce) # Paso 2) T->B: KBT(K1, K2, Nb) en AES-GCM cifrado, cifrado_mac, cifrado_nonce = cifraPasos2y4("B", KBT, K1, K2, t_nb) socket_Bob.enviar(cifrado)
from Crypto.PublicKey import RSA from Crypto.Hash import SHA256, HMAC from Crypto.Signature import pss from Crypto.Util.Padding import pad,unpad from Crypto.Random import get_random_bytes import base64 import json from socket_class import SOCKET_SIMPLE_TCP key_a_t = b'0123456789ABCDEF' key_b_t = b'FEDCBA9876543210' BLOCK_SIZE_AES = 16 print("Creando socket y escuchando...") socket = SOCKET_SIMPLE_TCP('127.0.0.1', 5556) socket.escuchar() #Recibe datos datos = socket.recibir() datos_hex = datos.hex() print("A -> B: " + datos_hex) #Se descifra la clave K_AB decipher_aes_a_b = AES.new(key_b_t, AES.MODE_ECB) json_a_b = unpad(decipher_aes_a_b.decrypt(datos), BLOCK_SIZE_AES) print("A->B (Clear): " + json_a_b.hex()) K_AB = json_a_b #Se genera el valor Rb b_random = get_random_bytes(8)