it-swarm-eu.dev

Ist Mehrfachverschlüsselung eine gute Idee?

Ich weiß, dass viele Verschlüsselungsalgorithmen zwar sicher sind, aber Schwachstellen aufweisen. Um Risiken zu reduzieren, würde eine Mehrfachverschlüsselung wie diese erfolgen

Blowfish_CbC ( Rc2_OFB ( AES128_CBC (myfilecontent)))

eine gute Idee sein?

Ich weiß, dass die Ausführungszeit ernsthaft zunimmt, aber das ist für mich kein Problem. Anregungen oder Ideen?

20

Persönlich würde ich die meiste Zeit mehrere Verschlüsselungsprotokolle vermeiden. Dies erhöht die Komplexität der Implementierung erheblich, ohne dass Ihre Daten in der realen Welt sicherer werden, es sei denn, das von Ihnen verwendete Verschlüsselungsprotokoll ist letztendlich fehlerhaft oder wird zu einem späteren Zeitpunkt rechnerisch durchführbar.

Zugegeben, ich werde anderen nicht zustimmen, die behaupten, dass Sie dadurch eine größere Angriffsfläche haben und Ihre Schwachstellen erhöhen. Während die Angriffsfläche technisch zunimmt (Sie können Blowfish angreifen; Sie können AES angreifen), hat Ihre Sicherheit nicht abgenommen, da Sie beide erfolgreich angreifen müssen. (Angenommen, Ihre Nachricht ist verschachtelt (alles andere macht keinen Sinn) mit unabhängigen Schlüsseln/Passphrasen wie multiply_encrypted_file = Blowfish(AES(file)) mehrfach verschlüsselt. Wenn ein Angreifer multiply_encrypted_file Erhält, ist dies der Fall in keiner Weise schwächer als encrypted_file = AES(file) zu erreichen, obwohl Sie sich davor hüten sollten, sich bekannten Klartextangriffen auszusetzen, die die Sicherheit schwächen könnten wenn Sie auf allen Ebenen denselben Schlüssel/dieselbe Passphrase verwendet haben und nach der ersten Entschlüsselungsstufe einen erratenen Header/eine erratene Struktur der Datei haben). Selbst wenn sie einen ausnutzbaren Fehler in der Blowfish-Verschlüsselung finden, können sie diesen nur umkehren und dann eine AES-verschlüsselte Datei finden.

Ich verwende jedoch fast täglich mehrere Verschlüsselungsebenen, wenn es einen legitimen Grund dafür gibt und dies zusätzliche Sicherheit bietet. Beispielsweise muss ich häufig von zu Hause aus eine Verbindung zu Arbeitscomputern herstellen. Aus Sicherheitsgründen befinden sich die Arbeitscomputer jedoch in einem privaten Intranet, das von der Außenwelt abgeschirmt ist.

Um eine Verbindung herzustellen, erstelle ich zunächst einen VPN-Tunnel über das öffentliche Internet zu einem öffentlich zugänglichen VPN-Server, der meine Identität überprüft und als Gateway zum Intranet fungiert. Dann wird mein gesamter Netzwerkverkehr, der über das Internet zwischen meinem Haus und meiner Arbeit gesendet wird, verschlüsselt mit dem IPSec-Protokoll per VPN an den VPN-Server gesendet, der ihn entschlüsselt und an den lokalen Computer weiterleitet, als wäre er im lokalen Intranet. Möglicherweise möchte ich dann jedoch mit ssh oder https eine Verbindung zu etwas bei der Arbeit herstellen. Dies bietet eine Verschlüsselungsebene für das lokale Intranet bei der Arbeit, sodass meine Mitarbeiter meine Netzwerkverbindungen nicht belauschen konnten. Für jemanden bei meinem ISP, der Pakete erfasst, wurden die angezeigten Daten jedoch mehrfach verschlüsselt: VPN_encryption(ssh_encryption(actual_data_to_be_transferred)). Auch hier verwende ich nicht das SSH-Protokoll (zusätzlich zu VPN), um meine Daten vor dem Abhören durch den Internetdienstanbieter sicherer zu machen. aber in keiner Weise erleichtert es meinem ISP das Abhören).


EDIT: Einige argumentieren immer wieder, dass die Implementierung viel schwieriger als die Standardverschlüsselung wäre, aber nicht unbedingt. Zur Demonstration implementiere ich zuerst Blowfish/AES in python using 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

welche in python wie verwendet werden):

>>> 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.

Jetzt können Sie mit minimalen Details Folgendes implementieren:

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))

Welches kann verwendet werden wie:

>>> 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.

Ich sehe nicht, dass die mehrfach verschlüsselte Implementierung eher eine Angriffsfläche hat und ohnehin schwächer ist als eine einfach implementierte. Für die Implementierung nach außen kann weiterhin ein Kennwort zum Entschlüsseln einer gespeicherten Datei eingegeben werden.

11
dr jimbob

Durch Hinzufügen weiterer Algorithmen können Sie zwei Dinge tun:

  1. Potenziell Erhöhen Sie die Stärke der Verschlüsselung.
  2. Erhöhen Sie die Angriffsfläche Ihrer Anwendung.

AES128-CBC ist stark. Wenn Sie es richtig implementieren und starke Zufallsschlüssel und eindeutige Zufalls-IVs verwenden, sind Sie sehr sicher. Die US-Regierung (NSA) zertifiziert AES für die Sicherung streng geheimer Dokumente. Ich bezweifle etwas, dass Ihre Sicherheitsanforderungen in der Nähe ihrer liegen, daher sollten Sie AES allein als mehr als stark genug betrachten. Wenn Sie wirklich paranoid sind, wechseln Sie zu 256-Bit-AES.

Verkettungsalgorithmen bieten nur dann nachweisbarere Sicherheit, wenn Sie jeweils unabhängige Schlüssel verwenden. Wenn Sie für alle Chiffren denselben Schlüssel verwenden, müssen Sie immer noch nur einen Schlüssel brutal erzwingen. Bei 128 Bit wurde jedoch vorausgesagt, dass wir die Ausrüstung möglicherweise nie dazu besitzen werden.

Das Verketten mehrerer Algorithmen ist in lächerlich hochsicheren Langzeitspeichersituationen mit hoher Paranoia wie TrueCrypt-Volumes, in denen die Bereitstellungsumgebung völlig unbekannt ist, sinnvoll. Wenn Sie jedoch wahrscheinlich keine militärischen Geheimnisse aufbewahren, die in ein feindliches Land verschifft werden, und zufällig ein professioneller Kryptograf sind, würde ich mich nur an AES halten.

16
Polynomial

Es ist äußerst selten, dass der Algorithmus selbst eine Sicherheitsanfälligkeit darstellt. Selbst schwache Algorithmen wie RC4 sind häufig der stärkste Teil des Systems, in dem sie verwendet werden. Sicherheitslücken verbergen sich normalerweise in wie Sie wenden Verschlüsselung (Auffüllen, IV-Zufälligkeit, Integritätsprüfungen ...) und in der Schlüsselverwaltung an. Diese scheinbar peripheren Aktivitäten sind ziemlich schwer richtig zu machen und haben sich wiederholt als die Hauptursache für Schwachstellen in jedem Verschlüsselungssystem erwiesen. Durch dreimaliges Verschlüsseln haben Sie die Möglichkeiten für solche bösen Schwächen verdreifacht.

Also tu es nicht.

13
Thomas Pornin