Passa al contenuto principale

4. Cryptographic Dependencies (Dipendenze crittografiche)

4. Cryptographic Dependencies (Dipendenze crittografiche)​

Le varianti HPKE si basano sulle seguenti primitive:

Un meccanismo di incapsulamento della chiave (KEM):

  • GenerateKeyPair(): Algoritmo randomizzato per generare una coppia di chiavi (skX, pkX).

  • DeriveKeyPair(ikm): Algoritmo deterministico per derivare una coppia di chiavi (skX, pkX) dalla stringa di byte ikm, dove ikm DOVREBBE avere almeno Nsk byte di entropia (vedere la sezione 7.1.3 per discussione).

  • SerializePublicKey(pkX): Produce una stringa di byte di lunghezza Npk che codifica la chiave pubblica pkX.

  • DeserializePublicKey(pkXm): Analizza una stringa di byte di lunghezza Npk per recuperare una chiave pubblica. Questa funzione può sollevare un errore DeserializeError in caso di fallimento della deserializzazione di pkXm.

  • Encap(pkR): Algoritmo randomizzato per generare una chiave simmetrica effimera di lunghezza fissa (il segreto condiviso KEM) e un incapsulamento di lunghezza fissa di quella chiave che può essere disincapsulato dal possessore della chiave privata corrispondente a pkR. Questa funzione può sollevare un EncapError in caso di fallimento dell'incapsulamento.

  • Decap(enc, skR): Algoritmo deterministico che utilizza la chiave privata skR per recuperare la chiave simmetrica effimera (il segreto condiviso KEM) dalla sua rappresentazione incapsulata enc. Questa funzione può sollevare un DecapError in caso di fallimento del disincapsulamento.

  • AuthEncap(pkR, skS) (opzionale): Come Encap(), e le uscite codificano una garanzia che il segreto condiviso KEM è stato generato dal possessore della chiave privata skS.

  • AuthDecap(enc, skR, pkS) (opzionale): Come Decap(), e il destinatario è assicurato che il segreto condiviso KEM è stato generato dal possessore della chiave privata skS.

  • Nsecret: La lunghezza in byte di un segreto condiviso KEM prodotto da questo KEM.

  • Nenc: La lunghezza in byte di una chiave incapsulata prodotta da questo KEM.

  • Npk: La lunghezza in byte di una chiave pubblica codificata per questo KEM.

  • Nsk: La lunghezza in byte di una chiave privata codificata per questo KEM.

Una funzione di derivazione della chiave (KDF):

  • Extract(salt, ikm): Estrae una chiave pseudocasuale di lunghezza fissa Nh byte dal materiale di chiave di input ikm e da una stringa di byte opzionale salt.

  • Expand(prk, info, L): Espande una chiave pseudocasuale prk utilizzando la stringa opzionale info in L byte di materiale di chiave di output.

  • Nh: La dimensione di output della funzione Extract() in byte.

Un algoritmo di crittografia AEAD [RFC5116]:

  • Seal(key, nonce, aad, pt): Crittografa e autentica il testo in chiaro pt con dati associati aad utilizzando la chiave simmetrica key e il nonce nonce, producendo testo cifrato e tag ct. Questa funzione può sollevare un MessageLimitReachedError in caso di fallimento.

  • Open(key, nonce, aad, ct): Decrittografa il testo cifrato e il tag ct utilizzando dati associati aad con la chiave simmetrica key e il nonce nonce, restituendo il messaggio in chiaro pt. Questa funzione può sollevare un OpenError o MessageLimitReachedError in caso di fallimento.

  • Nk: La lunghezza in byte di una chiave per questo algoritmo.

  • Nn: La lunghezza in byte di un nonce per questo algoritmo.

  • Nt: La lunghezza in byte del tag di autenticazione per questo algoritmo.

Oltre a quanto sopra, un KEM PUÒ anche esporre le seguenti funzioni, il cui comportamento è dettagliato nella sezione 7.1.2:

  • SerializePrivateKey(skX): Produce una stringa di byte di lunghezza Nsk che codifica la chiave privata skX.

  • DeserializePrivateKey(skXm): Analizza una stringa di byte di lunghezza Nsk per recuperare una chiave privata. Questa funzione può sollevare un errore DeserializeError in caso di fallimento della deserializzazione di skXm.

Una suite crittografica (ciphersuite) è una tripla (KEM, KDF, AEAD) contenente una scelta di algoritmo per ciascuna primitiva.

Un insieme di identificatori di algoritmi per istanziazioni concrete di queste primitive è fornito nella sezione 7. I valori degli identificatori di algoritmi sono lunghi due byte.

Si noti che GenerateKeyPair può essere implementato come DeriveKeyPair(random(Nsk)).

La notazione pk(skX), a seconda del suo utilizzo e del KEM e della sua implementazione, è o il calcolo della chiave pubblica utilizzando la chiave privata, o semplicemente una sintassi che esprime il recupero della chiave pubblica, assumendo che sia memorizzata insieme all'oggetto chiave privata.

Le seguenti due funzioni sono definite per facilitare la separazione di dominio delle chiamate KDF nonché il binding del contesto:

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)

Il valore di suite_id dipende da dove viene utilizzato il KDF; si presume implicito dall'implementazione e non viene passato come parametro. Se utilizzato all'interno di un algoritmo KEM, suite_id DEVE iniziare con "KEM" e identificare questo algoritmo KEM; se utilizzato nel resto di HPKE, DEVE iniziare con "HPKE" e identificare l'intera suite crittografica in uso. Vedere le sezioni 4.1 e 5.1 per i dettagli.

Ultimo aggiornamento il