SHA-3

Da BitcoinWiki.
Questa è la versione approvata di questa pagina, oltre ad essere la più recente.
SHA-3 algorithm Keccak

SHA-3 (Secure Hash Algorithm Versione 3), chiamato anche Keccak, è unidirezionale funzione per la generazione di stampe digitali della lunghezza selezionata (lo standard accetta 224, 256, 384 o 512 bit) da dati di input di qualsiasi dimensione, sviluppato da un gruppo di autori guidato da Yoan Dimen nel 2008 e adottato nel 2015 come nuovo standard FIPS. L'algoritmo funziona per mezzo della funzione di miscelazione con compressione alla dimensione selezionata “spugna crittografica“.

L'algoritmo originale di Keccak ha molti parametri configurabili (dimensione del blocco dati, dimensione dello Stato dell'Algoritmo, Numero di giri nella funzione f, ecc.) per fornire un rapporto ottimale di stabilità e prestazioni crittografiche per l'applicazione sulla piattaforma selezionata.

La versione dell'algoritmo di SHA-3 presenta diverse differenze rispetto all'algoritmo originale di keccak:

  • modalità lente c=768 e c = 1024 sono eliminati
  • algoritmo semplificato di riempimento
  • introdotto " funzioni con un risultato esteso "(XOF, Extendable Output Functions) SHAKE128 and SHAKE256, per cui il messaggio hash era necessario per completare il "suffisso" di 2 o 4 bit, a seconda del tipo di funzione.

Algoritmo di Keccak[modifica]

L'algoritmo di Keccak è il lavoro di Guido Bertoni, Joan Daemen (che ha anche co-progettato il cifrario Rijndael con Vincent Rijmen), Michael Peeters e Gilles Van Assche. Si basa su precedenti hash funzione progetta PANAMA e RadioGatún. PANAMA è stato progettato da Daemen e Craig Clapp nel 1998. RadioGatun, un successore di PANAMA, è stato progettato da demone, Peters e Van Assche, ed è stato presentato al prossimo Hash Workshop nel 2006.

Nel 2006 il NIST ha iniziato organizzare il competizione per funzioni hash NIST hash function competition per creare un nuovo standard hash, SHA-3. poiché non è stato dimostrato alcun attacco significativo allo SHA-2. A causa degli attacchi di successo su MD5, SHA-0 e SHA-1, NIST ha percepito la necessità di un hash crittografico alternativo e dissimile, che è diventato SHA-3.

Dopo un periodo di setup, le ammissioni dovevano essere presentate entro la fine del 2008. Keccak è stato accettato come uno dei 51 candidati.

Gli autori di Keccak hanno elaborato un semplice schema (se si capisce), la cosiddetta funzione spugna. All'interno di questa" spugna " c'è uno stato (1600 bit di dimensione per SHA-3), al quale viene applicata una e la stessa funzione su ogni round, che implementa una permutazione pseudo-casuale. In altre parole, è essenzialmente un cifrario a blocchi senza chiave con una dimensione di blocco di 1600 bit. E se riempiamo lo stato con zeri, eseguiamo 10 Round (10 volte applichiamo la loro funzione f) in una direzione, e poi la stessa quantità nella direzione opposta(con la funzione, inverso f), allora otteniamo di nuovo zeri.

Per cache una stringa, è necessario prima romperla in pezzi di una certa dimensione e su ogni round di esso non si dovrebbe mescolare a tutti 1600 bit stato, ma solo al suo inizio di dimensione r. qui perire inserirò il concorrente più immagine, ora ha senso. Ad ogni round, il pezzo successivo della stringa viene mescolato solo ad una parte dello Stato, mentre la permutazione pseudo-casuale f gestisce l'intero stato, smeating così la stringa per stato e rendendola dipendente dall'intera stringa.

Questa è la cosiddetta fase di ‘assorbimento’. E ora e 'chiaro perche' si chiama cosi'. Per ottenere l'hash reale, continuiamo ad applicare la funzione di permutazione f allo stato, e ad ogni fase copiare solo un pezzo di dimensione r da esso fino a ottenere l'hash della lunghezza richiesta. Questa cosiddetta spugna ‘spremitura’.

SHA-3 ASIC[modifica]

SHA-3 funziona bene su ASICs e minatori vedono questo come un vantaggio strategico. Il team di Keccak afferma che la sua portata per una data area di circuito è un ordine di grandezza superiore a SHA-2 o a uno dei finalisti SHA-3. E se ti importa oltre la velocità normale, nota che consuma anche molta meno energia per bit. In questo senso, Keccak è un primitivo crittografico verde. Per quanto ne sanno, gli ASICs per lo SHA-3 non sono ancora ampiamente disponibili.La sicurezza è la massima preoccupazione e un maggiore hashrate di rete significa un obiettivo molto più difficile per i malfattori. Hash che sono ad alta intensità di memoria, o usano altri mezzi per diminuire il vantaggio di hardware specializzato, fanno per le reti che sono più facili da rovesciare. Quindi, non aveva senso scegliere deliberatamente un hashish inefficiente. SHA-3 offre più sicurezza, per meno potenza; una combinazione vincente.

Non è inoltre chiaro se gli ASIC contribuiscano o meno alla centralizzazione della rete. Il dibattito su questo punto su Bitcoin si è affievolito anni fa, e diversi hash utilizzati da altre cryptocurrencies hanno avuto ASICS sviluppato senza che lo stesso problema fosse sollevato; Scrypt e X11. Il punto di vista è che la funzione di distribuzione token ha più a che fare con questo che altro. Per risolvere questo problema abbiamo implementato un algoritmo speciale per calcolare la ricompensa di ogni blocco.

Infine, SHA-3 sembra avere la migliore resistenza agli attacchi basati sul calcolo quantistico. Questo è ancora un argomento di grande contesa, ma recenti ricerche dovrebbero alleviare queste preoccupazioni. Un team dell'Università di Waterloo ha studiato come SHA-2 e SHA-3 sono stati in grado di resistere ad un attacco preimage usando l'algoritmo di ricerca quantistica di Grover. SHA-3 ha fatto molto bene.

La funzione di Keccak consiste nel seguente:

Keccak[r,c](M) {
Inizializzazione e imbottitura
 Per(int x=0; x<5; x++)
   Per(int y=0; y<5; y++)
     S[x,y] = 0;
 P = M || 0x01 || 0x00 || … || 0x00;
 P = P xor (0x00 || … || 0x00 || 0x80);
 //Fase di assorbimento
 blocco forall Pi in P
 per(int x=0; x<5; x++)
   per(int y=0; y<5; y++)
     S[x,y] = S[x,y] xor Pi[x+5*y];
   S = Keccak-f[r+c](S);
 //Fase di spremitura
 Z = stringa vuota;
fare
{
 per(int x=0; x<5; x++)
   per(int y=0; y<5; y++)
     se((x+5y)<r/w)  
       Z = Z || S[x,y];
   S = Keccak-f[r+c](S)
}  mentre l'output è richiesto
 restituire Z;
}
  • Il passo di assorbimento calcola il valore di hash.
  • E nella fase di spremitura l'uscita dei risultati fino al raggiungimento della lunghezza di taglio richiesta


C'è funzione assorbente:

Keccak-f[b](A) 
{
 forall i in 0…nr-1
   A = Round[b](A, RC[i])
 restituire A
}

Qui b è il valore della funzione selezionata (il valore predefinito è 1600).

  • E la funzione rotonda () è una permutazione pseudo-casuale applicata su ogni giro. Il numero di giri "' nr '" è calcolato in base ai valori di r E c.

Le operazioni eseguite su ciascun round rappresentano la seguente funzione:

Rotondo[b](A,RC)
{
 θ passo
 per(int x=0; x<5; x++)
   C[x] = A[x,0] xor A[x,1] xor A[x,2] xor A[x,3] xor A[x,4];
 per(int x=0; x<5; x++)
   D[x] = C[x-1] xor rot(C[x+1],1);
 per(int x=0; x<5; x++)
   A[x,y] = A[x,y] xor D[x];
 ρ e π passo
 per(int x=0; x<5; x++)
   per(int y=0; y<5; y++)
     B[y,2*x+3*y] = rot(A[x,y], r[x,y]);
 χ passo
 per(int x=0; x<5; x++)
   per(int y=0; y<5; y++)
     A[x,y] = B[x,y] xor ((no B[x+1,y]) e B[x+2,y]);
 ι passo
 A[0,0] = A[0,0] xor RC
restituire A
}

Ci sono 4 passaggi su ciascuno dei quali un certo numero di azioni logiche sono eseguite sui dati in entrata.

Qui, la funzione rot (X,n) indica lo spostamento ciclico dell'elemento x per le posizioni n.

Il array R [] è un insieme predefinito di valori che specifica quanti byte spostare su ciascun round:

SHA-3 Keccak) array RC

le costanti rotonde Un array RC è un insieme di costanti predefinite:

SHA-3 Keccak) array r

le compensazioni di rotazione


VEDERE ANCHE[modifica]