Criptografía en lenguaje simple: analizamos el cifrado simétrico y asimétrico utilizando la trama de Star Wars como ejemplo (actualizado)

1. ¿Qué es el cifrado?
2. ¿Cuál es la diferencia entre cifrado simétrico y asimétrico?
3. En cuyo caso, es más eficiente usar el cifrado simétrico y en el cual el cifrado asimétrico;
4. ¿Qué es un hash de datos y por qué se usa en el cifrado?

Parcela

Esquema

• El enemigo interceptará la señal, comprenderá su contenido sobre la planificación del ataque y acercará el objeto a las fuerzas leales al Imperio. En este caso, las pérdidas entre la resistencia serán mayores;
• Uno de los espías será atrapado y durante el interrogatorio revelará el plan de operación, lo que puede comprometer las claves de cifrado (hablaremos de ellas a continuación);
• Un espía con datos descargados puede ser interceptado por las fuerzas imperiales, que harán cambios en el contenido, informando mal la resistencia sobre las debilidades de la estación. En este caso, durante el ataque, la flota rebelde será enviada en una dirección falsa y destruida gradualmente;

1. El contenido debe estar encriptado de forma segura y protegido de cambios;
2. En caso de pérdida de claves de cifrado o su compromiso, debería ser posible obtener nuevas claves de cifrado de forma remota a una frecuencia que el adversario pueda aprovechar.

Cifrado de información

Descripción del principio de encriptación

El método en el que el mensaje se encripta y desencripta usando una sola clave se denomina encriptación simétrica .



El punto débil del cifrado simétrico es la clave de cifrado, o más bien, su entrega al destinatario. Si la clave se ve comprometida durante la entrega, un tercero puede decodificar fácilmente el mensaje. La fuerza del cifrado simétrico es su velocidad, que permite codificar grandes cantidades de datos.

El cifrado asimétrico utiliza dos claves conectadas entre sí: pública y privada.



El mecanismo de acción es el siguiente:

1. el destinatario envía la clave ABIERTA al remitente;
2. el remitente codifica el mensaje usando la clave pública recibida. Al mismo tiempo, el mensaje ahora puede decodificarse solo con la clave privada;
3. Al recibir el mensaje cifrado, el destinatario lo decodifica con la clave CERRADA (que se generó en conjunto con el público).

from Crypto.Cipher import AES #   from Crypto.Hash import SHA256 #        SHA. from Crypto.Hash import MD5 #            32  from Crypto import Random def transform_password(password_str): """Transform the password string into 32 bit MD5 hash :param password_str: <str> password in plain text; :return: <str> Transformed password fixed length """ h = MD5.new() h.update(key.encode()) return h.hexdigest() def symmetric_encrypt(message, key, verbose = True): """Encripts the message using symmetric AES algorythm. :param message: <str> Message for encryption; :param key: <object> symmetric key; :return: <object> Message encrypted with key """ key_MD5 = transform_password(key) #      32  message_hash = SHA256.new(message.encode()) message_with_hash = message.encode() + message_hash.hexdigest().encode() #     .      iv = Random.new().read(AES.block_size) cipher = AES.new(key_MD5, AES.MODE_CFB, iv) #     . AES.MODE_CFB -   ,      iv. https://www.dlitz.net/software/pycrypto/api/current/Crypto.Cipher.blockalgo-module.html#MODE_CFB encrypted_message = iv + cipher.encrypt(message_with_hash) #       .  ,       ,       . if verbose: print(f'Message was encrypted into: {encrypted_message.hex()}') return encrypted_message def symmetric_decrypt(encr_message, key): """Decripts the message using private_key and check it's hash :param encrypted_message: <object> Encrypted message :param key: <object> symmetric key; :return: <object> Message decripted with key """ key_MD5 = transform_password(key) #   ,      bsize = AES.block_size dsize = SHA256.digest_size*2 iv = Random.new().read(bsize) cipher = AES.new(key_MD5, AES.MODE_CFB, iv) decrypted_message_with_hesh = cipher.decrypt(encr_message)[bsize:] #     ,      decrypted_message = decrypted_message_with_hesh[:-dsize] #   ,      digest = SHA256.new(decrypted_message).hexdigest() #    .     ,     . if digest==decrypted_message_with_hesh[-dsize:].decode(): #      ,      ,   print(f"Success!\nEncrypted hash is {decrypted_message_with_hesh[-dsize:].decode()}\nDecrypted hash is {digest}") return decrypted_message.decode() else: print(f"Encryption was not correct: the hash of decripted message doesn't match with encrypted hash\nEncrypted hash is {decrypted_message_with_hesh[-dsize:]}\nDecrypted hash is {digest}") 

 message = """  120   120  / 120   10     30-5 (2)    4.0 """ key = 'Traveling through hyperspace ain't like dusting crops, farm boy.' encr_message = symmetric_encrypt(message, key, verbose = True) print('\n') print('DECRIPTION') decr_message = symmetric_decrypt(encr_message, key) print(decr_message) 

 Message was encrypted into: ed10e4c65358bb9e351c801c3b3200b21fa86a24021c317bb5c9d8b3f76bdf9f3a7d26781a22402f0e4f41ca831b6d2da9e1e6878c34c79ddc7959af3ae9fc2ba0cfff1c0180a7e0f637f1aa5b24507d552d5dfe7625e7b81d817b5882b2b19bb95f3988a03c78f850098dfc8e6089863deaa39b887eaea4c1d4ba006edaec90205d54b27ed4ac70ed75cdd01732e1176bf04218beb8ae742ff708a201a9d1cb57dd5f2e70dc3239208d23705f7a3aae3e315c4df6d73c871b66c4995cce5f19738f731cd58755d21ed92612c44197f875cddf3f7aa1d60e435ce1492679b9d60c4b8538f52408f321711ac1d2daa6dbbc33dc655abca10e2f5fd3ff27823995b9dcdb62c0bafc1963ab539ccb466f1c140479df34b0005f578f72fcdd76b17391332037b801f74f733a08 DECRIPTION Success! Encrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026 Decrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026  120   120  / 120   10     30-5 (2)    4.0 

¿Qué es un hash?

Un hash de documento es simplemente una cadena de caracteres que es exclusiva de cualquier conjunto de datos. Con cualquier cambio de datos, el hash cambia mucho. En otras palabras, un hash es una especie de "huella digital" para cualquier conjunto de datos.

El usuario Akela_wolf comentó correctamente que cualquiera puede generar y enviar la clave pública. Hice algunos ajustes al plan.

Será correcto si, antes de enviar agentes, la sede generará varios pares de claves y asignará una clave privada a cada agente. Es mejor generar solo unos pocos pares para que cada agente tenga una clave individual. Esto es necesario para personificar con precisión al propietario de la clave.
Luego, si las claves se ven comprometidas, el centro creará una nueva clave SIMÉTRICA, la codificará a cada agente con claves públicas y la enviará por el canal abierto.

Esquema de solución general

 #          RSA. #        SHA256 from Crypto.PublicKey import RSA #      def generate_keys(bits = 2048): """Generates the pair of private and public keys. :param bits: <int> Key length, or size (in bits) of the RSA modulus (default 2048) :return: <object> private_key, <object> public_key """ private_key = RSA.generate(bits) public_key = private_key.publickey() return private_key, public_key private_key, public_key = generate_keys(bits = 2048) 

 print(private_key.exportKey(format='PEM').decode()) print('\n') print('#'*65) print('\n') print(public_key.exportKey(format='PEM').decode()) 

 from Crypto.PublicKey import RSA #        RSA. from Crypto.Hash import SHA256 #        SHA256.    #       from Crypto.Cipher import PKCS1_OAEP #   def encrypt_message(message, public_key, verbose = True): """Encripts the message using public_key. :param message: <str> Message for encryption :param public_key: <object> public_key :param verbose: <bool> Print description; :return: <object> Message encrypted with public_key """ message_hash = SHA256.new(message.encode()) #   . cipher = PKCS1_OAEP.new(public_key) message_with_hash = message.encode() + message_hash.hexdigest().encode() #      ,          encrypted_message = cipher.encrypt(message_with_hash) if verbose: print(f'Message: {message} was encrypted to\n{encrypted_message.hex()}') return encrypted_message def decrypt_message(encrypted_message, private_key): """Decripts the message using private_key and check it's hash :param encrypted_message: <object> Encrypted message :param private_key: <object> private_key :return: <object> Message decripted with private_key """ dsize = SHA256.digest_size*2 cipher = PKCS1_OAEP.new(private_key) decrypted_message_with_hesh = cipher.decrypt(encrypted_message) #   (  ) decrypted_message = decrypted_message_with_hesh[:-dsize] #      digest = SHA256.new(decrypted_message).hexdigest() #     if digest==decrypted_message_with_hesh[-dsize:].decode(): #      ,      ,   print(f"Success!\nEncrypted hash is {decrypted_message_with_hesh[-dsize:].decode()}\nDecrypted hash is {digest}") return decrypted_message.decode() else: print(f"Encryption was not correct: the hash of decripted message doesn't match with encrypted hash\nEncrypted hash is {decrypted_message_with_hesh[-dsize:]}\nDecrypted hash is {digest}") 

Epílogo