Zum Hauptinhalt springen

7. Verschlüsselungsschemata (Encryption Schemes)

Für die Zwecke dieses Dokuments besteht ein Verschlüsselungsschema (Encryption Scheme) aus einer Verschlüsselungsoperation und einer Entschlüsselungsoperation, wobei die Verschlüsselungsoperation unter Verwendung des öffentlichen RSA-Schlüssels des Empfängers einen Chiffretext aus einer Nachricht erzeugt und die Entschlüsselungsoperation unter Verwendung des entsprechenden privaten RSA-Schlüssels des Empfängers eine Nachricht aus einem Chiffretext wiederherstellt.

Verschlüsselungsschemata können auf eine Vielzahl von Anwendungsszenarien angewendet werden. Eine typische Anwendung ist das Schlüsselvereinbarungsprotokoll (Key Establishment Protocol), bei dem die Nachricht Schlüsselmaterial enthält, das vertraulich von einer Partei zu einer anderen übertragen werden muss. Beispielsweise verwendet PKCS #7 [RFC2315] solche Protokolle, um einen Inhaltsverschlüsselungsschlüssel von einem Absender zu einem Empfänger zu übertragen; die in diesem Dokument definierten Verschlüsselungsschemata eignen sich für die Verwendung als Schlüsselverschlüsselungsalgorithmen in diesem Kontext.

Dieses Dokument spezifiziert zwei Verschlüsselungsschemata: RSAES-OAEP und RSAES-PKCS1-v1_5. Neue Anwendungen MÜSSEN (REQUIRED) RSAES-OAEP unterstützen; RSAES-PKCS1-v1_5 ist nur für die Kompatibilität mit bestehenden Anwendungen enthalten.

Die hier präsentierten Verschlüsselungsschemata folgen einem allgemeinen Modell ähnlich dem in IEEE 1363 [IEEE1363] verwendeten, das Verschlüsselungs- und Entschlüsselungsprimitive mit einer Kodierungsmethode für die Verschlüsselung kombiniert. Die Verschlüsselungsoperation wendet eine Nachrichtenkodierungsoperation auf die Nachricht an, um eine kodierte Nachricht zu erzeugen, die dann in einen ganzzahligen Nachrichtenrepräsentanten umgewandelt wird. Das Verschlüsselungsprimitiv wird auf den Nachrichtenrepräsentanten angewendet, um den Chiffretext zu erzeugen. Umgekehrt wendet die Entschlüsselungsoperation das Entschlüsselungsprimitiv auf den Chiffretext an, um den Nachrichtenrepräsentanten wiederherzustellen, der dann in eine Oktettzeichenkette der kodierten Nachricht umgewandelt wird. Eine Nachrichtendekodierungsoperation wird auf die kodierte Nachricht angewendet, um die Nachricht wiederherzustellen und die Korrektheit der Entschlüsselung zu überprüfen.

Um Implementierungsschwächen im Zusammenhang mit der Art und Weise zu vermeiden, wie Fehler in der Dekodierungsoperation behandelt werden (siehe [BLEICHENBACHER] und [MANGER]), sind die Kodierungs- und Dekodierungsoperationen von RSAES-OAEP und RSAES-PKCS1-v1_5 in die Spezifikationen der jeweiligen Verschlüsselungsschemata eingebettet, anstatt in separaten Spezifikationen definiert zu werden. Beide Verschlüsselungsschemata sind mit den entsprechenden Schemata in PKCS #1 v2.1 kompatibel.

7.1. RSAES-OAEP​

RSAES-OAEP kombiniert die RSAEP- und RSADP-Primitive (Abschnitt 5.1) mit der EME-OAEP-Kodierungsmethode (in diesem Abschnitt eingebettet). Es basiert auf der von Bellare und Rogaway in [OAEP] erstmals eingeführten Methode der optimalen asymmetrischen Verschlüsselungspolsterung (Optimal Asymmetric Encryption Padding, OAEP). EME-OAEP ist eine Einweg-Variante von EME-OAEP in IEEE 1363 [IEEE1363].

Das Schema ist nicht deterministisch: Für einen gegebenen öffentlichen Schlüssel und eine gegebene Nachricht können viele mögliche Chiffretexte erzeugt werden.

RSAES-OAEP wird für neue Anwendungen empfohlen. RSAES-OAEP kann als bevorzugte Alternative zu RSAES-PKCS1-v1_5 in jeder Anwendung verwendet werden.

Die Sicherheit dieses Schemas basiert auf der Schwierigkeit von zwei Funktionen: dem RSA-Problem und dem Zufallsorakelmodell der Maskengenerierungsfunktion (Mask Generation Function, MGF). Die Sicherheitseigenschaften dieser beiden Funktionen sind in einem Theorembeweis verkörpert, der zeigt, dass die Schwierigkeit, RSAES-OAEP gegen einen Angriff mit gewähltem Chiffretext (Chosen Ciphertext Attack) zu verwenden, im Wesentlichen genauso schwierig ist wie das Lösen des RSA-Problems, vorausgesetzt, dass das MGF sich wie ein Zufallsorakel (Random Oracle) verhält.

7.1.1. Verschlüsselungsoperation (Encryption Operation)​

RSAES-OAEP-ENCRYPT ((n, e), M, L)

Eingabe (Input):

  • (n, e): öffentlicher RSA-Schlüssel des Empfängers (k bezeichnet die Länge des Modulus in Oktetten)
  • M: zu verschlüsselnde Nachricht, eine Oktettzeichenkette der Länge höchstens k - 2hLen - 2, wobei hLen die Ausgabelänge der Hash-Funktion Hash in Oktetten ist
  • L: optionales Label, das mit der Verschlüsselungsoperation verknüpft ist; Standardwert ist die leere Zeichenkette

Ausgabe (Output):

  • C: Chiffretext, eine Oktettzeichenkette der Länge k

Fehler (Errors):

  • "message too long" (Nachricht zu lang)
  • "label too long" (Label zu lang)

Annahme (Assumption): Der öffentliche RSA-Schlüssel (n, e) ist gültig

Schritte (Steps):

  1. Längenprüfung: Wenn die Länge von L die Eingabegrenze für die Maskengenerierungsfunktion überschreitet (die 2^61 - 1 Oktette beträgt), Ausgabe "label too long" und Stopp.

  2. EME-OAEP-Kodierung:

    • Wenn die Länge von M größer als k - 2hLen - 2 Oktette ist, Ausgabe "message too long" und Stopp.
    • Sei lHash = Hash(L), eine Oktettzeichenkette der Länge hLen.
    • Erzeuge eine Polsterzeichenkette PS, bestehend aus k - mLen - 2hLen - 2 Null-Oktetten und einem einzelnen Oktett mit dem Wert 0x01.
    • Konkateniere lHash, PS, das einzelne Byte 0x01 und die Nachricht M, um den Datenblock DB zu bilden: DB = lHash || PS || 0x01 || M
    • Erzeuge eine zufällige Oktettzeichenkette seed der Länge hLen.
    • Sei dbMask = MGF(seed, k - hLen - 1).
    • Sei maskedDB = DB ⊕ dbMask.
    • Sei seedMask = MGF(maskedDB, hLen).
    • Sei maskedSeed = seed ⊕ seedMask.
    • Konkateniere ein einzelnes Oktett mit dem Wert 0x00, maskedSeed und maskedDB, um die kodierte Nachricht EM zu bilden: EM = 0x00 || maskedSeed || maskedDB

  3. RSA-Verschlüsselung:

    • Konvertiere die kodierte Nachricht EM in einen ganzzahligen Nachrichtenrepräsentanten m: m = OS2IP(EM)
    • Wende das RSAEP-Verschlüsselungsprimitiv an: c = RSAEP((n, e), m)
    • Konvertiere den Chiffretextrepräsentanten c in einen Chiffretext C der Länge k: C = I2OSP(c, k)

  4. Gebe den Chiffretext C aus.

7.1.2. Entschlüsselungsoperation (Decryption Operation)​

RSAES-OAEP-DECRYPT (K, C, L)

Eingabe (Input):

  • K: privater RSA-Schlüssel des Empfängers
  • C: zu entschlüsselnder Chiffretext, eine Oktettzeichenkette der Länge k, wobei k die Länge des RSA-Modulus n in Oktetten ist
  • L: optionales Label, dessen Wert mit dem Label während der Verschlüsselungsoperation verknüpft ist, die den Chiffretext erzeugt hat; Standardwert ist die leere Zeichenkette

Ausgabe (Output):

  • M: Nachricht, eine Oktettzeichenkette der Länge höchstens k - 2hLen - 2

Fehler (Error):

  • "decryption error" (Entschlüsselungsfehler)

Schritte (Steps):

  1. Längenprüfung: Wenn die Länge von L die Eingabegrenze überschreitet, Ausgabe "decryption error" und Stopp. Wenn die Länge des Chiffretexts C nicht k Oktette beträgt (oder wenn k < 2hLen + 2), Ausgabe "decryption error" und Stopp.

  2. RSA-Entschlüsselung:

    • Konvertiere den Chiffretext C in einen ganzzahligen Chiffretextrepräsentanten c: c = OS2IP(C)
    • Wende das RSADP-Entschlüsselungsprimitiv an: m = RSADP(K, c). Wenn RSADP "ciphertext representative out of range" ausgibt, Ausgabe "decryption error" und Stopp.
    • Konvertiere den Nachrichtenrepräsentanten m in eine kodierte Nachricht EM der Länge k: EM = I2OSP(m, k)

  3. EME-OAEP-Dekodierung:

    • Sei lHash = Hash(L).
    • Trenne EM in ein einzelnes Oktett Y, eine Oktettzeichenkette maskedSeed der Länge hLen und eine Oktettzeichenkette maskedDB der Länge k - hLen - 1: EM = Y || maskedSeed || maskedDB
    • Sei seedMask = MGF(maskedDB, hLen).
    • Sei seed = maskedSeed ⊕ seedMask.
    • Sei dbMask = MGF(seed, k - hLen - 1).
    • Sei DB = maskedDB ⊕ dbMask.
    • Trenne DB in eine Oktettzeichenkette lHash' der Länge hLen, eine (möglicherweise leere) Polsterzeichenkette PS bestehend aus Oktetten mit dem Wert 0x00, ein einzelnes Oktett mit dem Wert 0x01 und eine Nachricht M: DB = lHash' || PS || 0x01 || M. Wenn es kein Oktett mit dem Wert 0x01 gibt, um PS und M zu trennen, wenn lHash nicht gleich lHash' ist oder wenn Y nicht null ist, Ausgabe "decryption error" und Stopp.

  4. Gebe die Nachricht M aus.

Hinweis: Die Implementierung muss sorgfältig durchgeführt werden, um zu vermeiden, dass die Implementierung versehentlich nützliche Informationen an einen Gegner liefert. Insbesondere dürfen Fehlermeldungen nicht offenbaren, ob ein Oktett in EM oder andere Oktette in DB nicht der erwarteten Form entsprechen.

7.2. RSAES-PKCS1-v1_5​

RSAES-PKCS1-v1_5 kombiniert die RSAEP- und RSADP-Primitive (Abschnitt 5.1) mit der EME-PKCS1-v1_5-Kodierungsmethode. Es ist nur für die Kompatibilität mit bestehenden Anwendungen enthalten; für neue Anwendungen wird die Verwendung von RSAES-OAEP empfohlen.

Die Sicherheit von RSAES-PKCS1-v1_5 hängt von der Schwierigkeit des RSA-Problems ab. Es gibt bekannte potenzielle Schwachstellen (siehe [BLEICHENBACHER]), daher sollten neue Anwendungen RSAES-OAEP verwenden.

7.2.1. Verschlüsselungsoperation (Encryption Operation)​

RSAES-PKCS1-V1_5-ENCRYPT ((n, e), M)

Eingaben, Ausgaben und Schritte sind ähnlich wie bei RSAES-OAEP, verwenden jedoch die EME-PKCS1-v1_5-Kodierung

7.2.2. Entschlüsselungsoperation (Decryption Operation)​

RSAES-PKCS1-V1_5-DECRYPT (K, C)

Eingaben, Ausgaben und Schritte sind ähnlich wie bei RSAES-OAEP, verwenden jedoch die EME-PKCS1-v1_5-Dekodierung

Wichtiger Sicherheitshinweis: Entschlüsselungsfehlermeldungen dürfen nicht zwischen verschiedenen Fehlertypen unterscheiden, um den Bleichenbacher-Angriff mit gewähltem Chiffretext zu verhindern.

Letztes Update am