Aller au contenu principal

4. Cryptographic Dependencies

4. Cryptographic Dependencies​

Les variantes HPKE reposent sur les primitives suivantes:

Un mécanisme d'encapsulation de clé (KEM):

  • GenerateKeyPair(): Algorithme aléatoire pour générer une paire de clés (skX, pkX).

  • DeriveKeyPair(ikm): Algorithme déterministe pour dériver une paire de clés (skX, pkX) à partir de la chaîne d'octets ikm, où ikm DEVRAIT avoir au moins Nsk octets d'entropie (voir la section 7.1.3 pour discussion).

  • SerializePublicKey(pkX): Produire une chaîne d'octets de longueur Npk codant la clé publique pkX.

  • DeserializePublicKey(pkXm): Analyser une chaîne d'octets de longueur Npk pour récupérer une clé publique. Cette fonction peut lever une erreur DeserializeError en cas d'échec de désérialisation de pkXm.

  • Encap(pkR): Algorithme aléatoire pour générer une clé symétrique éphémère de longueur fixe (le secret partagé KEM) et une encapsulation de longueur fixe de cette clé qui peut être désencapsulée par le détenteur de la clé privée correspondant à pkR. Cette fonction peut lever une EncapError en cas d'échec d'encapsulation.

  • Decap(enc, skR): Algorithme déterministe utilisant la clé privée skR pour récupérer la clé symétrique éphémère (le secret partagé KEM) à partir de sa représentation encapsulée enc. Cette fonction peut lever une DecapError en cas d'échec de désencapsulation.

  • AuthEncap(pkR, skS) (optionnel): Identique à Encap(), et les sorties encodent une assurance que le secret partagé KEM a été généré par le détenteur de la clé privée skS.

  • AuthDecap(enc, skR, pkS) (optionnel): Identique à Decap(), et le destinataire est assuré que le secret partagé KEM a été généré par le détenteur de la clé privée skS.

  • Nsecret: La longueur en octets d'un secret partagé KEM produit par ce KEM.

  • Nenc: La longueur en octets d'une clé encapsulée produite par ce KEM.

  • Npk: La longueur en octets d'une clé publique encodée pour ce KEM.

  • Nsk: La longueur en octets d'une clé privée encodée pour ce KEM.

Une fonction de dérivation de clé (KDF):

  • Extract(salt, ikm): Extraire une clé pseudo-aléatoire de longueur fixe Nh octets à partir du matériel de clé d'entrée ikm et d'une chaîne d'octets optionnelle salt.

  • Expand(prk, info, L): Étendre une clé pseudo-aléatoire prk en utilisant la chaîne optionnelle info en L octets de matériel de clé de sortie.

  • Nh: La taille de sortie de la fonction Extract() en octets.

Un algorithme de chiffrement AEAD [RFC5116]:

  • Seal(key, nonce, aad, pt): Chiffrer et authentifier le texte en clair pt avec des données associées aad en utilisant la clé symétrique key et le nonce nonce, produisant le texte chiffré et l'étiquette ct. Cette fonction peut lever une MessageLimitReachedError en cas d'échec.

  • Open(key, nonce, aad, ct): Déchiffrer le texte chiffré et l'étiquette ct en utilisant des données associées aad avec la clé symétrique key et le nonce nonce, renvoyant le message en clair pt. Cette fonction peut lever une OpenError ou MessageLimitReachedError en cas d'échec.

  • Nk: La longueur en octets d'une clé pour cet algorithme.

  • Nn: La longueur en octets d'un nonce pour cet algorithme.

  • Nt: La longueur en octets de l'étiquette d'authentification pour cet algorithme.

Au-delà de ce qui précède, un KEM PEUT également exposer les fonctions suivantes, dont le comportement est détaillé dans la section 7.1.2:

  • SerializePrivateKey(skX): Produire une chaîne d'octets de longueur Nsk codant la clé privée skX.

  • DeserializePrivateKey(skXm): Analyser une chaîne d'octets de longueur Nsk pour récupérer une clé privée. Cette fonction peut lever une erreur DeserializeError en cas d'échec de désérialisation de skXm.

Une suite cryptographique (ciphersuite) est un triplet (KEM, KDF, AEAD) contenant un choix d'algorithme pour chaque primitive.

Un ensemble d'identifiants d'algorithmes pour les instanciations concrètes de ces primitives est fourni dans la section 7. Les valeurs des identifiants d'algorithmes ont une longueur de deux octets.

Notez que GenerateKeyPair peut être implémenté comme DeriveKeyPair(random(Nsk)).

La notation pk(skX), selon son utilisation et le KEM et son implémentation, est soit le calcul de la clé publique utilisant la clé privée, soit simplement une syntaxe exprimant la récupération de la clé publique, en supposant qu'elle est stockée avec l'objet clé privée.

Les deux fonctions suivantes sont définies pour faciliter la séparation de domaine des appels KDF ainsi que la liaison de contexte:

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)

La valeur de suite_id dépend de l'endroit où le KDF est utilisé; elle est supposée implicite de l'implémentation et n'est pas passée comme paramètre. Si utilisé à l'intérieur d'un algorithme KEM, suite_id DOIT commencer par "KEM" et identifier cet algorithme KEM; si utilisé dans le reste de HPKE, il DOIT commencer par "HPKE" et identifier l'ensemble de la suite cryptographique en cours d'utilisation. Voir les sections 4.1 et 5.1 pour plus de détails.

Dernière mise à jour le