Kryptographie in einfacher Sprache: Wir analysieren die symmetrische und asymmetrische Verschlüsselung am Beispiel des Star Wars-Diagramms (aktualisiert).

1. Was ist Verschlüsselung?
2. Was ist der Unterschied zwischen symmetrischer und asymmetrischer Verschlüsselung?
3. In diesem Fall ist es effizienter, symmetrische und asymmetrische Verschlüsselung zu verwenden.
4. Was ist ein Daten-Hash und warum wird er bei der Verschlüsselung verwendet?

Handlung

Schema

• Der Feind wird das Signal abfangen, seinen Inhalt über die Planung des Angriffs verstehen und das Objekt näher an die dem Imperium loyalen Kräfte führen. In diesem Fall sind die Verluste unter dem Widerstand höher;
• Einer der Spione wird gefasst und enthüllt während des Verhörs den Operationsplan, der zum Kompromiss bei den Verschlüsselungsschlüsseln führen kann (wir werden weiter unten darauf eingehen).
• Ein Spion mit heruntergeladenen Daten kann von imperialen Kräften abgefangen werden, die Änderungen am Inhalt vornehmen und den Widerstand über die Schwächen der Station falsch informieren. In diesem Fall wird die Rebellenflotte während des Angriffs in eine falsche Richtung geschickt und nach und nach zerstört.

1. Der Inhalt muss sicher verschlüsselt und vor Änderungen geschützt sein.
2. Im Falle des Verlusts von Verschlüsselungsschlüsseln oder ihrer Gefährdung sollte es möglich sein, neue Verschlüsselungsschlüssel mit einer Frequenz aus der Ferne zu erhalten, auf die der Gegner zugreifen kann.

Informationsverschlüsselung

Beschreibung des Verschlüsselungsprinzips

Die Methode, mit der die Nachricht mit einem einzigen Schlüssel verschlüsselt und entschlüsselt wird, wird als symmetrische Verschlüsselung bezeichnet .



Der Schwachpunkt der symmetrischen Verschlüsselung ist der Verschlüsselungsschlüssel bzw. dessen Übermittlung an den Adressaten. Wenn der Schlüssel während der Zustellung kompromittiert wird, kann ein Dritter die Nachricht leicht entschlüsseln. Die Stärke der symmetrischen Verschlüsselung liegt in ihrer Geschwindigkeit, die es ermöglicht, große Datenmengen zu codieren.

Bei der asymmetrischen Verschlüsselung werden zwei miteinander verbundene Schlüssel verwendet: öffentlich und privat.



Der Wirkungsmechanismus ist wie folgt:

1. Der Adressat sendet den OPEN-Schlüssel an den Absender.
2. Der Absender codiert die Nachricht mit dem empfangenen öffentlichen Schlüssel. Gleichzeitig kann die Nachricht nur noch mit dem privaten Schlüssel dekodiert werden.
3. Nach Erhalt der verschlüsselten Nachricht dekodiert der Empfänger sie mit dem CLOSED-Schlüssel (der zusammen mit der Öffentlichkeit generiert wurde).

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 Die Message was encrypted into: ed10e4c65358bb9e351c801c3b3200b21fa86a24021c317bb5c9d8b3f76bdf9f3a7d26781a22402f0e4f41ca831b6d2da9e1e6878c34c79ddc7959af3ae9fc2ba0cfff1c0180a7e0f637f1aa5b24507d552d5dfe7625e7b81d817b5882b2b19bb95f3988a03c78f850098dfc8e6089863deaa39b887eaea4c1d4ba006edaec90205d54b27ed4ac70ed75cdd01732e1176bf04218beb8ae742ff708a201a9d1cb57dd5f2e70dc3239208d23705f7a3aae3e315c4df6d73c871b66c4995cce5f19738f731cd58755d21ed92612c44197f875cddf3f7aa1d60e435ce1492679b9d60c4b8538f52408f321711ac1d2daa6dbbc33dc655abca10e2f5fd3ff27823995b9dcdb62c0bafc1963ab539ccb466f1c140479df34b0005f578f72fcdd76b17391332037b801f74f733a08 DECRIPTION Success! Encrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026 Decrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026  120   120  / 120   10     30-5 (2)    4.0 

Was ist ein Hash?

Ein Dokument-Hash ist einfach eine Zeichenfolge, die für jeden Datensatz eindeutig ist. Bei jeder Datenänderung ändert sich der Hash sehr stark. Mit anderen Worten, ein Hash ist eine Art „Fingerabdruck“ für jeden Datensatz.

Der Benutzer Akela_wolf bemerkte zu Recht, dass jeder den öffentlichen Schlüssel generieren und senden kann. Ich habe einige Anpassungen am Plan vorgenommen.

Es ist richtig, wenn die Zentrale vor dem Senden von Agenten mehrere Schlüsselpaare generiert und jedem Agenten einen privaten Schlüssel zuweist. Es ist besser, nur wenige Paare zu generieren, damit jeder Agent einen eigenen Schlüssel hat. Dies ist erforderlich, um den Besitzer des Schlüssels genau zu personifizieren.
Wenn die Schlüssel kompromittiert werden, erstellt das Center einen neuen SYMMETRIC-Schlüssel, codiert ihn mit öffentlichen Schlüsseln an jeden Agenten und sendet ihn über den offenen Kanal.

Allgemeines Lösungsschema

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

Nachwort