Passa al contenuto principale

5.2 Encryption and Decryption (Cifratura e decifrazione)

5.2 Encryption and Decryption (Cifratura e decifrazione)​

HPKE consente di eseguire più operazioni di cifratura basate su una data transazione di configurazione. Poiché le operazioni di chiave pubblica coinvolte nella configurazione sono tipicamente più costose della cifratura o decifrazione simmetrica, questo permette alle applicazioni di ammortizzare il costo delle operazioni di chiave pubblica, riducendo il sovraccarico complessivo.

Tuttavia, per evitare il riutilizzo del nonce, questa cifratura deve essere con stato. Ciascuna delle procedure di configurazione sopra produce un oggetto di contesto specifico per ruolo che memorizza i parametri AEAD e di esportazione dei segreti. I parametri AEAD consistono in:

  • L'algoritmo AEAD in uso

  • Una chiave segreta

  • Un nonce di base base_nonce

  • Un numero di sequenza (inizialmente 0)

I parametri di esportazione dei segreti consistono in:

  • La suite crittografica HPKE in uso e

  • Un exporter_secret utilizzato per l'interfaccia di esportazione dei segreti (vedere la Sezione 5.3)

Tutti questi parametri tranne il numero di sequenza AEAD sono costanti. Il numero di sequenza fornisce l'unicità del nonce: Il nonce utilizzato per ogni operazione di cifratura o decifrazione è il risultato dello XOR di base_nonce con il numero di sequenza corrente, codificato come intero big-endian della stessa lunghezza di base_nonce. Le implementazioni POSSONO utilizzare un numero di sequenza più corto della lunghezza del nonce (riempiendo a sinistra con zeri), ma DEVONO sollevare un errore se il numero di sequenza trabocca. L'algoritmo AEAD produce un testo cifrato che è Nt byte più lungo del testo in chiaro. Nt = 16 per gli algoritmi AEAD definiti in questo documento.

La cifratura è unidirezionale dal mittente al destinatario. Il contesto del mittente può cifrare un testo in chiaro pt con dati associati aad come segue:

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

Il contesto del destinatario può decifrare un testo cifrato ct con dati associati aad come segue:

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

Ogni operazione di cifratura o decifrazione incrementa il numero di sequenza per il contesto in uso. I dettagli del nonce per messaggio e dell'incremento del numero di sequenza sono i seguenti:

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

Il contesto del mittente NON DEVE essere utilizzato per la decifrazione. Allo stesso modo, il contesto del destinatario NON DEVE essere utilizzato per la cifratura. I protocolli di livello superiore che riutilizzano lo scambio di chiavi HPKE per scopi più generali possono derivare materiale di chiavi separato secondo necessità utilizzando l'interfaccia di esportazione dei segreti; vedere le Sezioni 5.3 e 9.8 per ulteriori dettagli.

Spetta all'applicazione garantire che le cifrature e decifrature siano eseguite nella sequenza appropriata, in modo che i nonce di cifratura e decifrazione si allineino. Se ContextS.Seal() o ContextR.Open() causassero il traboccamento del campo seq, allora l'implementazione DEVE fallire con un errore. (Nello pseudocodice seguente, Context<ROLE>.IncrementSeq() fallisce con un errore quando seq trabocca, il che fa fallire di conseguenza ContextS.Seal() e ContextR.Open().) Si noti che le chiamate interne Seal() e Open() corrispondono all'algoritmo AEAD del contesto.

Ultimo aggiornamento il