Zum Hauptinhalt springen

4. Cryptographic Dependencies (Kryptografische Abhängigkeiten)

4. Cryptographic Dependencies (Kryptografische Abhängigkeiten)​

HPKE-Varianten basieren auf den folgenden Primitiven:

Ein Schlüssel-Kapselungsmechanismus (KEM):

  • GenerateKeyPair(): Randomisierter Algorithmus zur Generierung eines Schlüsselpaars (skX, pkX).

  • DeriveKeyPair(ikm): Deterministischer Algorithmus zur Ableitung eines Schlüsselpaars (skX, pkX) aus der Byte-Zeichenkette ikm, wobei ikm mindestens Nsk Bytes Entropie haben SOLLTE (siehe Abschnitt 7.1.3 für Diskussion).

  • SerializePublicKey(pkX): Erzeugt eine Byte-Zeichenkette der Länge Npk, die den öffentlichen Schlüssel pkX kodiert.

  • DeserializePublicKey(pkXm): Analysiert eine Byte-Zeichenkette der Länge Npk, um einen öffentlichen Schlüssel wiederherzustellen. Diese Funktion kann bei Deserialisierungsfehlern von pkXm einen DeserializeError auslösen.

  • Encap(pkR): Randomisierter Algorithmus zur Generierung eines ephemeren symmetrischen Schlüssels fester Länge (das KEM gemeinsame Geheimnis) und einer Kapselung fester Länge dieses Schlüssels, die vom Inhaber des zu pkR gehörenden privaten Schlüssels entkappselt werden kann. Diese Funktion kann bei Kapselungsfehlern einen EncapError auslösen.

  • Decap(enc, skR): Deterministischer Algorithmus, der den privaten Schlüssel skR verwendet, um den ephemeren symmetrischen Schlüssel (das KEM gemeinsame Geheimnis) aus seiner gekapselten Darstellung enc wiederherzustellen. Diese Funktion kann bei Entkapselungsfehlern einen DecapError auslösen.

  • AuthEncap(pkR, skS) (optional): Wie Encap(), und die Ausgaben kodieren eine Zusicherung, dass das KEM gemeinsame Geheimnis vom Inhaber des privaten Schlüssels skS generiert wurde.

  • AuthDecap(enc, skR, pkS) (optional): Wie Decap(), und der Empfänger ist sicher, dass das KEM gemeinsame Geheimnis vom Inhaber des privaten Schlüssels skS generiert wurde.

  • Nsecret: Die Länge in Bytes eines von diesem KEM produzierten KEM gemeinsamen Geheimnisses.

  • Nenc: Die Länge in Bytes eines von diesem KEM produzierten gekapselten Schlüssels.

  • Npk: Die Länge in Bytes eines kodierten öffentlichen Schlüssels für diesen KEM.

  • Nsk: Die Länge in Bytes eines kodierten privaten Schlüssels für diesen KEM.

Eine Schlüsselableitungsfunktion (KDF):

  • Extract(salt, ikm): Extrahiert einen pseudozufälligen Schlüssel fester Länge Nh Bytes aus dem Eingabeschlüsselmaterial ikm und einer optionalen Byte-Zeichenkette salt.

  • Expand(prk, info, L): Erweitert einen pseudozufälligen Schlüssel prk unter Verwendung der optionalen Zeichenkette info in L Bytes Ausgabeschlüsselmaterial.

  • Nh: Die Ausgabegröße der Extract() Funktion in Bytes.

Ein AEAD-Verschlüsselungsalgorithmus [RFC5116]:

  • Seal(key, nonce, aad, pt): Verschlüsselt und authentifiziert Klartext pt mit zugehörigen Daten aad unter Verwendung des symmetrischen Schlüssels key und der Nonce nonce, was Geheimtext und Tag ct ergibt. Diese Funktion kann bei Fehlern einen MessageLimitReachedError auslösen.

  • Open(key, nonce, aad, ct): Entschlüsselt Geheimtext und Tag ct unter Verwendung zugehöriger Daten aad mit symmetrischem Schlüssel key und Nonce nonce, gibt Klartextnachricht pt zurück. Diese Funktion kann bei Fehlern einen OpenError oder MessageLimitReachedError auslösen.

  • Nk: Die Länge in Bytes eines Schlüssels für diesen Algorithmus.

  • Nn: Die Länge in Bytes einer Nonce für diesen Algorithmus.

  • Nt: Die Länge in Bytes des Authentifizierungs-Tags für diesen Algorithmus.

Über das Obige hinaus KANN ein KEM auch die folgenden Funktionen bereitstellen, deren Verhalten in Abschnitt 7.1.2 detailliert beschrieben wird:

  • SerializePrivateKey(skX): Erzeugt eine Byte-Zeichenkette der Länge Nsk, die den privaten Schlüssel skX kodiert.

  • DeserializePrivateKey(skXm): Analysiert eine Byte-Zeichenkette der Länge Nsk, um einen privaten Schlüssel wiederherzustellen. Diese Funktion kann bei Deserialisierungsfehlern von skXm einen DeserializeError auslösen.

Eine Kryptosuite (ciphersuite) ist ein Tripel (KEM, KDF, AEAD), das eine Auswahl eines Algorithmus für jede Primitive enthält.

Eine Menge von Algorithmusidentifikatoren für konkrete Instanziierungen dieser Primitiven wird in Abschnitt 7 bereitgestellt. Algorithmusidentifikatoren sind zwei Bytes lang.

Beachten Sie, dass GenerateKeyPair als DeriveKeyPair(random(Nsk)) implementiert werden kann.

Die Notation pk(skX) ist, abhängig von ihrer Verwendung und dem KEM und seiner Implementierung, entweder die Berechnung des öffentlichen Schlüssels unter Verwendung des privaten Schlüssels oder nur Syntax, die die Abfrage des öffentlichen Schlüssels ausdrückt, unter der Annahme, dass er zusammen mit dem privaten Schlüsselobjekt gespeichert ist.

Die folgenden zwei Funktionen sind definiert, um die Domänentrennung von KDF-Aufrufen sowie Kontextbindung zu erleichtern:

def LabeledExtract(salt, label, ikm):
  labeled_ikm = concat("HPKE-v1", suite_id, label, ikm)
  return Extract(salt, labeled_ikm)

def LabeledExpand(prk, label, info, L):
  labeled_info = concat(I2OSP(L, 2), "HPKE-v1", suite_id,
                        label, info)
  return Expand(prk, labeled_info, L)

Der Wert von suite_id hängt davon ab, wo der KDF verwendet wird; es wird implizit aus der Implementierung angenommen und nicht als Parameter übergeben. Wenn innerhalb eines KEM-Algorithmus verwendet, MUSS suite_id mit "KEM" beginnen und diesen KEM-Algorithmus identifizieren; wenn im Rest von HPKE verwendet, MUSS es mit "HPKE" beginnen und die gesamte verwendete Kryptosuite identifizieren. Siehe Abschnitte 4.1 und 5.1 für Details.

Letztes Update am