Cryptographie en langage simple: nous analysons le cryptage symétrique et asymétrique en utilisant l'exemple de l'intrigue Star Wars (Mise à jour)

1. Qu'est-ce que le chiffrement;
2. Quelle est la différence entre un chiffrement symétrique et asymétrique;
3. Dans ce cas, il est plus efficace d'utiliser symétrique et dans quel chiffrement asymétrique;
4. Qu'est-ce qu'un hachage de données et pourquoi est-il utilisé dans le chiffrement?

Terrain

Schéma

• L'ennemi va intercepter le signal, comprendre son contenu sur la planification de l'attaque et rapprocher l'objet des forces fidèles à l'Empire. Dans ce cas, les pertes parmi la résistance seront plus importantes;
• L'un des espions sera capturé et révélera au cours de l'interrogatoire le plan d'opération, ce qui peut conduire à la compromission des clés de chiffrement (nous en parlerons plus loin);
• Un espion avec des données téléchargées peut être intercepté par les forces impériales, qui apporteront des modifications au contenu, mal informant la résistance sur les faiblesses de la station. Dans ce cas, lors de l'attaque, la flotte rebelle sera envoyée dans une fausse direction et progressivement détruite;

1. Le contenu doit être crypté en toute sécurité et protégé contre les modifications;
2. En cas de perte de clés de chiffrement ou de leur compromission, il devrait être possible d'obtenir de nouvelles clés de chiffrement à distance à une fréquence pouvant être exploitée par l'adversaire.

Cryptage des informations

Description du principe de cryptage

La méthode dans laquelle le message est chiffré et déchiffré à l'aide d'une seule clé est appelée chiffrement symétrique .



Le point faible du cryptage symétrique est la clé de cryptage, ou plutôt sa remise au destinataire. Si la clé est compromise lors de la remise, un tiers peut facilement décoder le message. La force du chiffrement symétrique est sa vitesse, qui permet de coder de grandes quantités de données.

Le chiffrement asymétrique utilise deux clés connectées l'une à l'autre: publique et privée.



Le mécanisme d'action est le suivant:

1. le destinataire envoie la clé OUVERTE à l'expéditeur;
2. l'expéditeur code le message à l'aide de la clé publique reçue. Dans le même temps, le message ne peut désormais être décodé qu'avec la clé privée;
3. à la réception du message crypté, le destinataire le décode avec la clé CLOSED (qui a été générée en tandem avec le public).

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 Le 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'est-ce qu'un hachage

Un hachage de document est simplement une chaîne de caractères unique à tout ensemble de données. Avec tout changement de données, le hachage change beaucoup. En d'autres termes, un hachage est une sorte «d'empreinte digitale» pour tout ensemble de données.

L'utilisateur Akela_wolf a fait remarquer à juste titre que n'importe qui peut générer et envoyer la clé publique. J'ai apporté quelques ajustements au plan.

Il sera correct que, avant d'envoyer des agents, le siège social génère plusieurs paires de clés et attribue une clé privée à chaque agent. Il vaut mieux ne générer que quelques paires pour que chaque agent ait une clé individuelle. Cela est nécessaire pour personnifier avec précision le propriétaire de la clé.
Ensuite, si les clés sont compromises, le centre créera une nouvelle clé SYMMETRIC, la codera pour chaque agent avec des clés publiques et l'enverra sur le canal ouvert.

Schéma de solution général

 #          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}") 

Postface