it-swarm.dev

La crittografia multipla è una buona idea?

So che molti algoritmi di crittografia, sebbene sicuri, presentano delle vulnerabilità. Per ridurre i rischi, sarebbe la crittografia multipla come questa

Blowfish_CbC ( Rc2_OFB ( AES128_CBC (myfilecontent)))

essere una buona idea?

So che i tempi di esecuzione aumentano notevolmente, ma questo non è un problema per me. Qualche suggerimento o idea?

20

Personalmente, eviterei il più delle volte protocolli di crittografia. Aggiunge una notevole complessità di implementazione extra senza rendere i tuoi dati più sicuri nel mondo reale, a meno che il protocollo di crittografia che stai utilizzando non sia in definitiva rotto o diventi fattibile dal punto di vista computazionale in una data successiva.

Certo, non sarò d'accordo con gli altri che sostengono che così facendo avrai una superficie di attacco più ampia e aumenterai le tue vulnerabilità. Mentre la superficie di attacco aumenta tecnicamente (puoi attaccare il pesce palla; puoi attaccare AES), dal momento che devi attaccare con successo entrambi i livelli di sicurezza non sono diminuiti. (Supponendo che il tuo messaggio sia moltiplicato in modo nidificato (qualsiasi altra cosa non abbia senso) con chiavi/passphrase indipendenti come multiply_encrypted_file = Blowfish(AES(file)). Se un attaccante ottiene una sospensione di multiply_encrypted_file È non è in alcun modo più debole di ottenere encrypted_file = AES(file) anche se dovresti stare attento a esponendoti ad attacchi in chiaro che potrebbe indebolire la sicurezza se usi la stessa chiave/passphrase a tutti i livelli e avere un'intestazione/struttura indovinabile del file dopo il primo livello di decrittazione). Anche se trovano un difetto sfruttabile nella crittografia Blowfish, possono comunque solo invertire ciò e quindi trovare un file crittografato AES.

Tuttavia, utilizzo più livelli di crittografia su base quasi giornaliera quando esiste un motivo legittimo e fornisce una sicurezza aggiuntiva. Ad esempio, spesso devo collegarmi ai computer di lavoro da casa mia, ma per sicurezza i computer di lavoro si trovano su una rete Intranet privata, protetta da un firewall esterno al mondo esterno.

Per connettermi, per prima cosa creo un tunnel VPN su Internet pubblico a un server VPN pubblico che verifica la mia identità che funge da gateway per la rete Intranet. Quindi tutto il mio traffico di rete inviato su Internet tra casa mia e lavoro crittografato tramite protocollo IPsec da VPN al server VPN che lo decodifica e lo inoltra al computer locale come se fosse sull'intranet locale. Tuttavia, potrei quindi voler collegarmi a qualcosa al lavoro usando ssh o https. Questo fornisce un livello di crittografia per l'intranet locale al lavoro, quindi i miei colleghi non potevano dire di intercettare sulle mie connessioni di rete. Tuttavia, a qualcuno nel mio ISP che acquisisce i pacchetti i dati che vedono sono stati crittografati in modo multiplo: VPN_encryption(ssh_encryption(actual_data_to_be_transferred)). Ancora una volta, non sto usando il protocollo ssh (in cima alla VPN) per rendere i miei dati più sicuri contro il mio intercettazione dell'ISP; ma non rende in alcun modo più facile per il mio ISP intercettare).


EDIT: Alcuni continuano a sostenere che l'implementazione sarebbe molto più dura della crittografia standard, ma non necessariamente. Per dimostrare, per prima cosa implemento Blowfish/AES in python usando pycrypto :

from Crypto.Cipher import Blowfish, AES 
from Crypto import Random
from hashlib import sha256, sha512

def encrypt(plaintext, key, crypto_class):
    block_size = crypto_class.block_size
    iv = Random.new().read(block_size)
    cipher = crypto_class.new(key, crypto_class.MODE_CBC, iv)
    pad_len = block_size - (len(plaintext) % block_size)
    padding = ''.join([chr(pad_len)]*pad_len)
    encrypted_msg = iv + cipher.encrypt(plaintext + padding)
    return encrypted_msg

def decrypt(encrypted_msg, key, crypto_class):
    block_size = crypto_class.block_size
    iv = encrypted_msg[:block_size]
    cipher = crypto_class.new(key, crypto_class.MODE_CBC, iv)
    padded_msg = cipher.decrypt(encrypted_msg[block_size:])
    pad_len = ord(padded_msg[-1])
    msg = padded_msg[:len(padded_msg)-pad_len]
    return msg

che può essere usato in python come:

>>> plaintext = """CONFIDENTIAL INFO: Wall Street does insider trading.  Also, Israel has nuclear weapons."""
>>> passphrase = 'dinner artist mere trace metal thirty warp better'
>>> key1 = sha256(passphrase).digest()[0:16] # use 16-bytes=128bits for AES128 
>>> key2 = sha512(passphrase).digest()[0:56] # 56 bytes max for Blowfish.
# ideally independent keys but based on same passphrase for simplicity

>>> aes_encrypted_msg = encrypt(plaintext, key1, AES)           # '\r\xd0\x8e\x11\xbd\x9cN3\xd3\xa7a\xce\xd7\x15\xb4\xb2\[email protected]\nBv\x95\xe0\xdb\xd0\xd2\xf2K\x9b\xcd\x80\xc0xr\xb7\x8d/\x16=\xfadV\xf0\xe2\xc8"x,\xa6\xf8\xed\x8b\xee#\xe1\xd1\xd4U4*0\x07\x11\x08\xc5\xe3\x98\r5\x018\xa5\xf1\x84\xb4\x90\xbc\x12\x80E\xbd\xe9\tN\xe1M\x92\xbb=\x06\r\xfe(\xe8\x12\xc7\x86=\n\x0f\x00\xa1R\xe6\x9c\xca\xaa\x15\xc1(\xaa\xe6'
>>> print decrypt(aes_encrypted_msg, key1, AES)
CONFIDENTIAL INFO: Wall Street does insider trading.  Also, Israel has nuclear weapons.

>>> blowfish_encrypted_msg = encrypt(plaintext, key2, Blowfish) # "a\xd2\xe5mf\xac\x81f\xe9Q\xbd.\xd9SwA\x8a)\xcc\x84S\x08\x00\x84\xc6Y\xf5\xa1\x16\x88JaUoF\t4\xa2\xf2b\x89s\xaa\xa6\xb3\xda\xe2\xdd\xff\x0f\xc2\xe2\x1dW\xf6\x840\xe9\x08Eje\xfa\x14\xb77\x99\x00a\xe0\xcd\xaf\xbe\x83\x08\xc0'\x81\x8b\x85\xf0\xdaxT\x94!o\xd0\x07\x0f#\xae$,\x91Q"
>>> print decrypt(blowfish_encrypted_msg, key2, Blowfish)
CONFIDENTIAL INFO: Wall Street does insider trading.  Also, Israel has nuclear weapons.

Ora, con dettagli minimi è possibile implementare qualcosa di simile:

def double_encrypt_using_keys(plaintext, key1, key2):
    tmp_encrypted_msg = encrypt(plaintext, key1, AES)    
    encrypted_msg = encrypt(tmp_encrypted_msg, key2, Blowfish)
    return encrypted_msg

def double_decrypt_using_keys(encrypted_msg, key1, key2):
    tmp_encrypted_msg = decrypt(encrypted_msg, key2, Blowfish)
    plaintext = decrypt(tmp_encrypted_msg, key1, AES)    
    return plaintext

def passphrase_to_keys(passphrase):
    return sha256(passphrase).digest()[0:16], sha512(passphrase).digest()[0:56]

def double_encrypt(plaintext, passphrase):        
    return double_encrypt_using_keys(plaintext, *passphrase_to_keys(passphrase))

def double_decrypt(encrypted_msg, passphrase):
    return double_decrypt_using_keys(encrypted_msg, *passphrase_to_keys(passphrase))

Che può essere usato come:

>>> double_encrypted_msg = double_encrypt(plaintext, passphrase) # '\xe9\xcd\x89\xed\xb1f\xd4\xbel\xcb\x8b2!\x98\xf0\xe7\xcd.\xefE\x1b\x92>\x82(\x8dG\xdaUS\x8f!\xe2rgkJ\xfb\xed\xb0\x10~n\xae\xe1\xce\x10\xf0\xa4K\x9f\xe6\xff\x8b\x7f\xdex]\x9a<\x9d\xc7\xa9\xb8\x9a\xbbx\xa4\xcekoA\xbc=)\xcc\xe6R\xd7\xb7\xd0[\xc3\xfc\xbfOU\x86\x18\xec5\xa9N\xed\xaa=\x9f\x06.\xbd\x0cMy\xcch\r\xf8\x8cR\xc0\xc5\xdeO\xef\xb0\xe01\x162\xaf\xf2\x1f\xd5\xb5"\x8a\xea\x96'
>>> print double_decrypt(double_encrypted_msg, passphrase)
CONFIDENTIAL INFO: Wall Street does insider trading.  Also, Israel has nuclear weapons.

Non vedo come l'implementazione con crittografia multipla abbia più di una superficie di attacco ed è comunque più debole di una implementata singolarmente. L'implementazione nel mondo esterno può comunque essere immessa una password per decrittografare un file memorizzato.

11
dr jimbob

Aggiungendo più algoritmi, fai due cose:

  1. Potenzialmente aumenta la forza della crittografia.
  2. Aumenta la superficie di attacco dell'applicazione.

AES128-CBC è forte. Se lo stai implementando correttamente e usando chiavi casuali forti e IV casuali unici, sei molto sicuro. Il governo degli Stati Uniti (NSA) certifica AES per l'uso nella protezione di documenti top-secret. Dubito in qualche modo che i tuoi requisiti di sicurezza siano vicini ai loro, quindi dovresti considerare AES più che abbastanza forte da solo. Se sei davvero paranoico, passa a AES a 256 bit.

Gli algoritmi di concatenamento forniscono una sicurezza più dimostrabile solo se si utilizzano chiavi indipendenti per ciascuno. L'uso della stessa chiave per tutte le cifre significa che devi solo forzare una chiave, anche se a 128 bit è stato previsto che non potremmo mai supporre che l'apparecchiatura funzioni per farlo.

Concatenare algoritmi multipli ha un senso in situazioni di archiviazione a lungo termine ridicolmente ad alta sicurezza ad alta paranoia come i volumi TrueCrypt, in cui l'ambiente di distribuzione è completamente sconosciuto. Tuttavia, a meno che tu non stia probabilmente conservando segreti militari che verranno spediti in un paese ostile, e ti capita di essere un crittografo professionista, mi limiterei a usare solo AES.

16
Polynomial

È estremamente raro che l'algoritmo stesso sia una vulnerabilità. Anche gli algoritmi deboli come RC4 sono spesso la parte più forte del sistema in cui vengono utilizzati. Le vulnerabilità di solito si nascondono in how si applica la crittografia (riempimento, casualità IV, controlli di integrità ...) e nella gestione delle chiavi. Queste attività apparentemente periferiche sono piuttosto difficili da svolgere nel modo giusto e hanno ripetutamente dimostrato di essere la prima fonte di debolezza in qualsiasi sistema di crittografia. Crittografando tre volte, hai triplicato le opportunità per tali cattive debolezze.

Quindi non farlo.

13
Thomas Pornin