Aller au contenu principal

5.2 Encryption and Decryption (Chiffrement et déchiffrement)

5.2 Encryption and Decryption (Chiffrement et déchiffrement)​

HPKE permet d'effectuer plusieurs opérations de chiffrement sur la base d'une transaction de configuration donnée. Étant donné que les opérations de clé publique impliquées dans la configuration sont généralement plus coûteuses que le chiffrement ou le déchiffrement symétrique, cela permet aux applications d'amortir le coût des opérations de clé publique, réduisant ainsi la surcharge globale.

Cependant, pour éviter la réutilisation de nonce, ce chiffrement doit être avec état. Chacune des procédures de configuration ci-dessus produit un objet de contexte spécifique au rôle qui stocke les paramètres AEAD et d'exportation de secrets. Les paramètres AEAD consistent en:

  • L'algorithme AEAD utilisé

  • Une clé secrète

  • Un nonce de base base_nonce

  • Un numéro de séquence (initialement 0)

Les paramètres d'exportation de secrets consistent en:

  • La suite cryptographique HPKE utilisée et

  • Un exporter_secret utilisé pour l'interface d'exportation de secrets (voir la Section 5.3)

Tous ces paramètres sauf le numéro de séquence AEAD sont constants. Le numéro de séquence fournit l'unicité du nonce: Le nonce utilisé pour chaque opération de chiffrement ou de déchiffrement est le résultat du XOR de base_nonce avec le numéro de séquence actuel, encodé comme un entier big-endian de la même longueur que base_nonce. Les implémentations PEUVENT utiliser un numéro de séquence plus court que la longueur du nonce (en complétant à gauche avec des zéros), mais DOIVENT lever une erreur si le numéro de séquence déborde. L'algorithme AEAD produit un texte chiffré qui est Nt octets plus long que le texte en clair. Nt = 16 pour les algorithmes AEAD définis dans ce document.

Le chiffrement est unidirectionnel de l'émetteur vers le destinataire. Le contexte de l'émetteur peut chiffrer un texte en clair pt avec des données associées aad comme suit:

def ContextS.Seal(aad, pt):
  ct = Seal(self.key, self.ComputeNonce(self.seq), aad, pt)
  self.IncrementSeq()
  return ct

Le contexte du destinataire peut déchiffrer un texte chiffré ct avec des données associées aad comme suit:

def ContextR.Open(aad, ct):
  pt = Open(self.key, self.ComputeNonce(self.seq), aad, ct)
  if pt == OpenError:
    raise OpenError
  self.IncrementSeq()
  return pt

Chaque opération de chiffrement ou de déchiffrement incrémente le numéro de séquence pour le contexte en cours d'utilisation. Les détails du nonce par message et de l'incrémentation du numéro de séquence sont les suivants:

def Context<ROLE>.ComputeNonce(seq):
  seq_bytes = I2OSP(seq, Nn)
  return xor(self.base_nonce, seq_bytes)

def Context<ROLE>.IncrementSeq():
  if self.seq >= (1 << (8*Nn)) - 1:
    raise MessageLimitReachedError
  self.seq += 1

Le contexte de l'émetteur NE DOIT PAS être utilisé pour le déchiffrement. De même, le contexte du destinataire NE DOIT PAS être utilisé pour le chiffrement. Les protocoles de niveau supérieur réutilisant l'échange de clés HPKE à des fins plus générales peuvent dériver du matériel de clé séparé selon les besoins en utilisant l'interface d'exportation de secrets; voir les Sections 5.3 et 9.8 pour plus de détails.

Il appartient à l'application de s'assurer que les chiffrements et déchiffrements sont effectués dans la séquence appropriée, de sorte que les nonces de chiffrement et de déchiffrement s'alignent. Si ContextS.Seal() ou ContextR.Open() causerait le débordement du champ seq, alors l'implémentation DOIT échouer avec une erreur. (Dans le pseudocode ci-dessous, Context<ROLE>.IncrementSeq() échoue avec une erreur lorsque seq déborde, ce qui fait échouer ContextS.Seal() et ContextR.Open() en conséquence.) Notez que les appels internes Seal() et Open() correspondent à l'algorithme AEAD du contexte.

Dernière mise à jour le