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)