2. Algoritmi di firma

2. Algoritmi di firma

La sezione 8.1 di [RFC9052] contiene una descrizione generica degli algoritmi di firma. Questo documento definisce gli identificatori dell'algoritmo di firma per due algoritmi di firma.

2.1. ECDSA

L'Elliptic Curve Digital Signature Algorithm (ECDSA) [DSS] definisce un algoritmo di firma utilizzando la crittografia a curva ellittica (ECC). Le implementazioni DOVREBBERO utilizzare una versione deterministica di ECDSA come quella definita in [RFC6979]. L'uso di un algoritmo di firma deterministico consente ai sistemi di evitare di affidarsi a generatori di numeri casuali per evitare di generare lo stesso valore di "k" (il valore casuale per messaggio). La generazione distorta del valore "k" può essere attaccata e le collisioni di questo valore portano a chiavi trapelate. Consente inoltre di eseguire test deterministici per l'algoritmo di firma. L'uso di ECDSA deterministico non diminuisce la necessità di avere una buona generazione di numeri casuali durante la creazione della chiave privata.

L'algoritmo di firma ECDSA è parametrizzato con una funzione hash (h). Nel caso in cui la lunghezza dell'output della funzione hash sia maggiore del gruppo della chiave, vengono utilizzati i byte più a sinistra dell'output hash.

Gli algoritmi definiti in questo documento si trovano nella Tabella 1.

          +=======+=======+=========+==================+
          | Name  | Value | Hash    | Description      |
          +=======+=======+=========+==================+
          | ES256 |   -7  | SHA-256 | ECDSA w/ SHA-256 |
          +-------+-------+---------+------------------+
          | ES384 |  -35  | SHA-384 | ECDSA w/ SHA-384 |
          +-------+-------+---------+------------------+
          | ES512 |  -36  | SHA-512 | ECDSA w/ SHA-512 |
          +-------+-------+---------+------------------+

                 Tabella 1: Valori dell'algoritmo ECDSA

Questo documento definisce ECDSA come funzionante solo con le curve P-256, P-384 e P-521. Questo documento richiede che le curve siano codificate utilizzando il tipo di chiave "EC2" (curva ellittica a due coordinate). Le implementazioni devono verificare che il tipo di chiave e la curva siano corretti durante la creazione e la verifica di una firma. Documenti futuri potrebbero definirlo per funzionare con altre curve e tipi di chiave in futuro.

Al fine di promuovere l'interoperabilità, si suggerisce di utilizzare SHA-256 solo con la curva P-256, SHA-384 solo con la curva P-384 e SHA-512 solo con la curva P-521. Ciò è in linea con la raccomandazione nella Sezione 4 di [RFC5480].

L'algoritmo di firma si traduce in una coppia di numeri interi (R, S). Questi numeri interi avranno la stessa lunghezza della lunghezza della chiave utilizzata per il processo di firma. La firma viene codificata convertendo i numeri interi in stringhe di byte della stessa lunghezza della dimensione della chiave. La lunghezza viene arrotondata al byte più vicino e viene riempita a sinistra con bit zero per ottenere la lunghezza corretta. I due numeri interi vengono quindi concatenati insieme per formare una stringa di byte che è la firma risultante.

Utilizzando la funzione definita in [RFC8017], la firma è:

Signature = I2OSP(R, n) | I2OSP(S, n)

dove n = ceiling(key_length / 8)

Quando si utilizza una chiave COSE per questo algoritmo, vengono effettuati i seguenti controlli:

• Il campo "kty" DEVE essere presente e DEVE essere "EC2".

• Se il campo "alg" è presente, DEVE corrispondere all'algoritmo di firma ECDSA utilizzato.

• Se il campo "key_ops" è presente, DEVE includere "sign" durante la creazione di una firma ECDSA.

• Se il campo "key_ops" è presente, DEVE includere "verify" durante la verifica di una firma ECDSA.

2.1.1. Considerazioni sulla sicurezza per ECDSA

La forza di sicurezza della firma non è superiore al minimo della forza di sicurezza associata alla lunghezza in bit della chiave e alla forza di sicurezza della funzione hash.

Nota: L'uso di una tecnica di firma deterministica è una buona idea anche quando esiste una buona generazione di numeri casuali. Ciò riduce sia la possibilità di avere lo stesso valore di "k" in due operazioni di firma sia consente valori di firma riproducibili, il che aiuta i test. Di recente ci sono stati attacchi che hanno coinvolto il guasto del dispositivo per estrarre la chiave. Ciò può essere affrontato combinando sia la casualità che il determinismo [CFRG-DET-SIGS].

Esistono due attacchi di sostituzione che possono teoricamente essere montati contro l'algoritmo di firma ECDSA.

• Modifica della curva utilizzata per convalidare la firma: se si modifica la curva utilizzata per convalidare la firma, potenzialmente si potrebbero avere due messaggi con la stessa firma, ciascuno calcolato sotto una curva diversa. Gli unici requisiti sulla nuova curva sono che il suo ordine sia lo stesso della vecchia e che sia accettabile per il client. Un esempio sarebbe passare dall'utilizzo della curva secp256r1 (aka P-256) all'utilizzo di secp256k1. (Entrambe sono curve a 256 bit.) Al momento non abbiamo alcun modo per affrontare questa versione dell'attacco se non per limitare l'insieme complessivo di curve che possono essere utilizzate.

• Modifica della funzione hash utilizzata per convalidare la firma: se si hanno due diverse funzioni hash della stessa lunghezza o si può troncare una funzione hash, si potrebbero potenzialmente trovare collisioni tra le funzioni hash piuttosto che all'interno di una singola funzione hash. Ad esempio, troncare SHA-512 a 256 bit potrebbe entrare in collisione con un valore hash a 256 bit SHA-256. Poiché l'algoritmo hash fa parte dell'identificatore dell'algoritmo di firma, questo attacco viene mitigato includendo un identificatore dell'algoritmo di firma nel bucket dell'intestazione protetta.

2.2. Edwards-Curve Digital Signature Algorithm (EdDSA)

[RFC8032] descrive lo schema di firma a curva ellittica Edwards-curve Digital Signature Algorithm (EdDSA). In quel documento, l'algoritmo di firma viene istanziato utilizzando parametri per le curve edwards25519 e edwards448. Il documento descrive inoltre due varianti dell'algoritmo EdDSA: Pure EdDSA, in cui nessuna funzione hash viene applicata al contenuto prima della firma, e HashEdDSA, in cui una funzione hash viene applicata al contenuto prima della firma e il risultato di quella funzione hash viene firmato. Per EdDSA, il contenuto da firmare (il messaggio o il valore pre-hash) viene elaborato due volte all'interno dell'algoritmo di firma. Per l'uso con COSE, viene utilizzata solo la versione Pure EdDSA. Questo perché non si prevede che saranno necessari contenuti estremamente grandi e, in base alla disposizione della struttura del messaggio, l'intero messaggio dovrà essere tenuto in memoria per creare o verificare una firma. Pertanto, non sembra esserci la necessità di essere in grado di eseguire aggiornamenti di blocco dell'hash, seguiti dall'eliminazione del messaggio dalla memoria. Le applicazioni possono fornire le stesse funzionalità definendo il contenuto del messaggio come un valore hash e trasportando l'oggetto COSE (con il valore hash) e il contenuto come elementi separati.

L'algoritmo definito in questo documento si trova nella Tabella 2. È definito un singolo algoritmo di firma, che può essere utilizzato per più curve.

                  +=======+=======+=============+
                  | Name  | Value | Description |
                  +=======+=======+=============+
                  | EdDSA |   -8  | EdDSA       |
                  +-------+-------+-------------+

                   Tabella 2: Valore dell'algoritmo EdDSA

[RFC8032] descrive il metodo di codifica del valore della firma.

Quando si utilizza una chiave COSE per questo algoritmo, vengono effettuati i seguenti controlli:

• Il campo "kty" DEVE essere presente e DEVE essere "OKP" (Octet Key Pair).

• Il campo "crv" DEVE essere presente e DEVE essere una curva definita per questo algoritmo di firma.

• Se il campo "alg" è presente, DEVE corrispondere a "EdDSA".

• Se il campo "key_ops" è presente, DEVE includere "sign" durante la creazione di una firma EdDSA.

• Se il campo "key_ops" è presente, DEVE includere "verify" durante la verifica di una firma EdDSA.

2.2.1. Considerazioni sulla sicurezza per EdDSA

I valori pubblici vengono calcolati in modo diverso in EdDSA ed Elliptic Curve Diffie-Hellman (ECDH); per questo motivo, la chiave pubblica dell'uno non dovrebbe essere utilizzata con l'altro algoritmo.

Se viene eseguita la verifica della firma batch, è RICHIESTO un generatore di numeri casuali crittografici ben inizializzato (Sezione 8.2 di [RFC8032]). La firma e la verifica della firma non batch sono operazioni deterministiche e non necessitano di numeri casuali di alcun tipo.