Criptografia em linguagem simples: analisamos criptografia simétrica e assimétrica usando o gráfico Star Wars como exemplo (Atualizado)

1. O que é criptografia;
2. Qual é a diferença entre criptografia simétrica e assimétrica;
3. Nesse caso, é mais eficiente usar simétrico e em que criptografia assimétrica;
4. O que é um hash de dados e por que é usado na criptografia;

Traçar

Esquema

• O inimigo interceptará o sinal, entenderá seu conteúdo sobre o planejamento do ataque e levará o objeto para mais perto das forças leais ao Império. Nesse caso, as perdas entre a resistência serão maiores;
• Um dos espiões será capturado e durante o interrogatório revelará o plano de operação, o que pode levar ao comprometimento das chaves de criptografia (falaremos sobre elas abaixo);
• Um espião com dados baixados pode ser interceptado por forças imperiais, que farão alterações no conteúdo, desinformando a resistência sobre as fraquezas da estação. Nesse caso, durante o ataque, a frota rebelde será enviada em uma direção falsa e gradualmente destruída;

1. O conteúdo deve ser criptografado e protegido com segurança contra alterações;
2. Em caso de perda de chaves de criptografia ou seu comprometimento, deve ser possível obter novas chaves de criptografia remotamente, com uma frequência que pode ser tocada pelo adversário.

Criptografia de informações

Descrição do princípio de criptografia

O método no qual a mensagem é criptografada e descriptografada usando uma única chave é chamada de criptografia simétrica .



O ponto fraco da criptografia simétrica é a chave de criptografia, ou melhor, sua entrega ao destinatário. Se a chave for comprometida durante a entrega, um terceiro poderá facilmente decodificar a mensagem. A força da criptografia simétrica é sua velocidade, o que possibilita a codificação de grandes quantidades de dados.

A criptografia assimétrica usa duas chaves conectadas uma à outra: pública e privada.



O mecanismo de ação é o seguinte:

1. o destinatário envia a chave ABRIR ao remetente;
2. o remetente codifica a mensagem usando a chave pública recebida. Ao mesmo tempo, a mensagem agora pode ser decodificada apenas com a chave privada;
3. após o recebimento da mensagem criptografada, o destinatário a decodifica com a chave CLOSED (que foi gerada em conjunto com o 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 

O que é um hash

Um hash de documento é simplesmente uma sequência de caracteres que é exclusiva para qualquer conjunto de dados. Com qualquer alteração de dados, o hash muda muito. Em outras palavras, um hash é um tipo de "impressão digital" para qualquer conjunto de dados.

O usuário Akela_wolf observou com razão que qualquer um pode gerar e enviar a chave pública. Fiz alguns ajustes no plano.

Será correto se, antes de enviar agentes, a matriz gerar vários pares de chaves e atribuir uma chave privada a cada agente. É melhor gerar apenas alguns pares para que cada agente tenha uma chave individual. Isso é necessário para personificar com precisão o proprietário da chave.
Então, se as chaves estiverem comprometidas, o centro criará uma nova chave SIMÉTRICA, a codificará para cada agente com chaves públicas e a enviará pelo canal aberto.

Esquema de solução geral

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

Posfácio