Passa al contenuto principale

A.1.2. Generation of k (Generazione di k)

A.1.2. Generation of k (Generazione di k)​

In questo esempio, utilizziamo la funzione hash SHA-256 [FIPS-180-4]. Il messaggio di input è la codifica UTF-8 della stringa "sample" (6 ottetti, cioè, 48 bit).

Il messaggio di input hashato h1 = SHA-256(m) è:

h1
   AF 2B DB E1 AA 9B 6E C1 E2 AD E1 D6 94 F4 1F C7
   1A 83 1D 02 68 E9 89 15 62 11 3D 8A 62 AD D1 BF

(32 ottetti; ogni valore di ottetto è elencato in notazione esadecimale).

Convertiamo la chiave privata x in una sequenza di ottetti utilizzando la trasformazione int2octets:

int2octets(x)
   00 9A 4D 67 92 29 5A 7F 73 0F C3 F2 B4 9C BC 0F
   62 E8 62 27 2F

Nota: Sebbene il valore specifico di x si adatterebbe numericamente in 160 bit, cioè, 20 ottetti, codifichiamo ancora x in 21 ottetti, perché la lunghezza di codifica è guidata dalla lunghezza di q, che è 163 bit.

Tronchiamo e/o espandiamo anche il messaggio hashato utilizzando bits2octets:

bits2octets(h1)
   01 79 5E DF 0D 54 DB 76 0F 15 6D 0D AC 04 C0 32
   2B 3A 20 42 24

I passaggi da b a g (vedere Sezione 3.2) calcolano quindi i valori per le variabili K e V. Queste variabili sono sequenze di 256 bit (la lunghezza di output della funzione hash, arrotondata per eccesso a un multiplo di 8). Riproduciamo qui i valori successivi:

V dopo il passaggio b:
   01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
   01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01

K dopo il passaggio c:
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

K dopo il passaggio d:
   09 99 9A 9B FE F9 72 D3 34 69 11 88 3F AD 79 51
   D2 3F 2C 8B 47 F4 20 22 2D 11 71 EE EE AC 5A B8

V dopo il passaggio e:
   D5 F4 03 0F 75 5E E8 6A A1 0B BA 8C 09 DF 11 4F
   F6 B6 11 1C 23 85 00 D1 3C 73 43 A8 C0 1B EC F7

K dopo il passaggio f:
   0C F2 FE 96 D5 61 9C 9E F5 3C B7 41 7D 49 D3 7E
   A6 8A 4F FE D0 D7 E6 23 E3 86 89 28 99 11 BD 57

V dopo il passaggio g:
   78 34 57 C1 CF 31 48 A8 F2 A9 AE 73 ED 47 2F A9
   8E D9 CD 92 5D 8E 96 4C E0 76 4D EF 3F 84 2B 9A

Nel passaggio h, eseguiamo il ciclo finale. Poiché utilizziamo HMAC con SHA-256, che produce 256 bit di output, e abbiamo bisogno solo di 163 bit per T, una singola invocazione HMAC produce il seguente T:

T (primo tentativo)
   93 05 A4 6D E7 FF 8E B1 07 19 4D EB D3 FD 48 AA
   20 D5 E7 65 6C BE 0E A6 9D 2A 8D 4E 7C 67 31 4A

che, quando convertito in un intero con bits2int, produce un primo candidato per k:

k1 = 0x4982D236F3FFC758838CA6F5E9FEA455106AF3B2B

Poiché quel valore è maggiore di q-1, dobbiamo ripetere il ciclo. Questo comporta prima il calcolo di nuovi valori per K e V:

nuovo K
   75 CB 5C 05 B2 A7 8C 3D 81 DF 12 D7 4D 7B E0 A0
   E9 4A B1 98 15 78 1D 4D 8E 29 02 A7 9D 0A 66 99

nuovo V
   DC B9 CA 12 61 07 A9 C2 7C E7 7B A5 8E A8 71 C8
   C9 12 D8 35 EA DD C3 05 F2 44 5D 88 F6 6C 4C 43

poi un nuovo T:

T (secondo tentativo)
   C7 0C 78 60 8A 3B 5B E9 28 9B E9 0E F6 E8 1A 9E
   2C 15 16 D5 75 1D 2F 75 F5 00 33 E4 5F 73 BD EB

e un nuovo candidato per k:

k2 = 0x63863C30451DADF4944DF4877B740D4F160A8B6AB

Poiché k2 è anche maggiore di q-1, ripetiamo nuovamente il ciclo:

nuovo K (2)
   0A 5A 64 B9 9C 05 95 20 10 36 86 CB 6F 36 BC FC
   A7 88 EB 3B CF 69 BA 66 A5 BB 08 0B 05 93 BA 53

nuovo V (2)
   0B 3B 19 68 11 B1 9F 6C 6F 72 9C 43 F3 5B CF 0D
   FD 72 5F 17 CA 34 30 E8 72 14 53 E5 55 50 A1 8F

T (terzo tentativo)
   47 5E 80 E9 92 14 05 67 FC C3 A5 0D AB 90 FE 84
   BC D7 BB 03 63 8E 9C 46 56 A0 6F 37 F6 50 8A 7C

e otteniamo finalmente un valore accettabile per k:

k = 0x23AF4074C90A02B3FE61D286D5C87F425E6BDD81B
Ultimo aggiornamento il