4.3 — Hashberäkningsfas
Fram till nu har allt arbete varit en del av förbehandlingsfasen. Från och med nu kommer vi att titta på hashberäkningsfas. In this phase, we will be using data from the preprocessing phase to beräkna ytterligare 48 ord, totalling the number of words to 64. This then gives us 4 klossar totalt. Eftersom att beräkna ytterligare 48 ord skulle vara för långt, kommer jag att demonstrera beräkningen genom att beräkna 17:e ordet (𝑊(16) ). Detta beräknas med hjälp av följande ekvation:
Var för det 17:e ordet (bara t-värdet ändras för varje ord):
We start by finding the word 15 places back (𝑊 (1)). We then make två kopior av detta. Först tar vi den första kopian och right rotate by 7 places (𝑅𝑂𝑇𝑅⁷(𝑥)). Detta innebär att varje siffra flyttas till höger en plats 7 gånger och när siffrorna faller från slutet, flyttas de till fronten:
𝑾(𝟏) = 01110011011011010110111101110101
Med det andra exemplaret, vi högerrotera med 18 ( 𝑅𝑂𝑇𝑅¹⁸(𝑥)):
Till sist tar vi originalet och högerväxling med 3 (𝑆𝐻𝑅³(𝑥)). This means when a number falls off the end it is replaced by zeros vid börjar av ordet:
Vi tar sedan dessa 3 ord och tillämpar:
Var:
Smakämnen bitvis exklusiv-ELLER-operation (XOR ⨁) takes två binära siffror och returnerar 0 om båda siffrorna är 0 eller 1 och returnerar 1 annars. Eftersom vi har 3 ord använder vi först XOR-operationen på 𝑅𝑂𝑇𝑅⁷(𝑥) och 𝑅𝑂𝑇𝑅¹⁸(𝑥) och tar sedan detta resultat och använder XOR-operationen med 𝑆𝐻𝑥³).
Därför drar jag slutsatsen att:
Konvertera detta resultat till hexadecimal form har vi:
Vi tar nu tillbaka ordet 2 platser (𝑊(14) ) och gör 2 kopior. Vi tar sedan den första kopian och högerroterar 17 platser (𝑅𝑂𝑇𝑅¹⁷(𝑥)):
𝑾(𝟏𝟒) = 00000000000000000000000000000000
Nu tar vi den andra kopian och roterar höger 2 platser ( 𝑅𝑂𝑇𝑅¹⁹(𝑥)):
Slutligen tar vi det ursprungliga och högra skiftet med 10 (𝑆𝐻𝑅¹⁰(𝑥)):
Vi tar sedan dessa 3 ord och tillämpar:
Var:
Därför drar jag slutsatsen att:
Eftersom hela ordet endast består av nollor är det hexadecimala värdet 0. Vi hänvisar då till vår nästa ords formel, finding the word 16 places back (𝑊 (0)) and the word 7 places back (𝑊 (9)).
𝑊(0) = 01110000011011110111001001110100 0
𝑊(9) = 00000000000000000000000000000000
Vi kan nu beräkna 𝑊 (16). För detta använder vi binär addition (+) som följer reglerna som visas nedan:
Den första kolumnen ignoreras för att behålla 32-bitarsformatet. Nu har vi vårt 17:e ord (𝑊(16)):
𝑾𝟏𝟔 = 𝟎𝟎𝟏𝟎𝟏𝟏𝟏𝟏𝟏𝟏𝟎𝟎𝟎𝟏𝟎𝟏𝟏𝟎𝟎𝟏𝟏𝟏𝟏𝟎𝟎𝟏𝟎𝟏𝟏𝟏𝟏𝟏
Slutligen konverterar vi detta från binär till hexadecimal form:
Denna process upprepas sedan tills vi är kvar 64 ord. När vi beräknar de återstående orden har vi orden som visas nedan:
To compute the final hash, we must run 64 iterations of the equation below:
Använd våra 64 ord (𝑊 ) från tabellen ovan och de initiala hashvärdena (𝒂 𝒕𝒐 𝒉), där:
(¬) är INTE drift det returnerar 0 om siffran är 1 och 1 om siffran är 0. Vi använder också (∧) som är AND operation, detta returnerar 1 om båda siffrorna är 1 och 0 annars.
Exempel: Computing 𝑡(0)
För att beräkna 𝑡(0) måste vi beräkna våra nya 𝒂 𝒕𝒐 𝒉 hashvärden. Börjar med a, där:
Finna 𝑻𝟏:
𝑒 = 510𝑒527 = 01010001000011100101001001111111
𝑓 = 9𝑏05688𝑐 = 10011011000001010110100010001100
𝑔 = 1𝑓83𝑑9𝑎𝑏 = 00011111100000111101100110101011
h = 5𝑏𝑒0𝑐𝑑19 = 01011011111000001100110100011001
Med hänvisning till den slutliga iterationsformeln kan vi nu beräkna T(1):
Ger:
𝑻𝟏 = 01100011111001110101111111011100
Finna 𝑻𝟐:
𝑎 = 6𝑎09𝑒667 = 01101010000010011110011001100111
𝑏 = 𝑏𝑏67𝑎𝑒85 = 10111011011001111010111010000101
𝑐 = 3𝑐6𝑒𝑓372 = 00111100011011101111001101110010
We can now calculate 𝑇(2) :
Ger:
𝑻𝟐 = 00001000100100001001101011100101
Nu kan vi beräkna 𝒂 från 𝑇(1) och 𝑇(2):
Ger:
𝒂 = 01101100011101111111101011000001
Converting to hexadecimal, we have:
𝑎 = 6c77fac1
Med hänvisning tillbaka till iterationsalgoritmen kan vi nu också beräkna 𝑒:
𝑑 = 𝑎54𝑓𝑓53𝑎 = 10100101010011111111010100111010
𝑇(1) = 01100011111001110101111111011100
Ger:
𝑒 = 00001001001101110101010100010110
Omvandling till hexadecimal har vi:
𝑒 = 09375516
Med hänvisning till iterationsalgoritmen finner vi också:
𝑏 = 𝑎 = 6𝑎09𝑒667
𝑐 = 𝑏 = 𝑏𝑏67𝑎𝑒85
𝑑 = 𝑐 = 3𝑐6𝑒𝑓372
𝑓 = 𝑒 = 510𝑒527𝑓
𝑔 = 𝑓 = 9𝑏05688𝑐
h = 𝑔 = 1𝑓83𝑑9𝑎𝑏
Leaving us with the final values for the first iteration 𝑡(0):
Vi utför sedan ytterligare 63 iterationer av algoritmen, med våra 𝒂-𝒉-värden från föregående iteration, uppdaterar varje omgång. Detta lämnar oss med den 64:e iterationen 𝑡(63):
Using these values, we compute the ith intermediate hash value 𝐻(i) given by the following:
Var a-h are the values from our final iteration (𝑡(63)) and 𝐻(0)(0) to 𝐻(7)(0) are the initial hash values.
Giving us:
......
Slutligen kan vi konvertera de mellanliggande hash-värdena till hexadecimal form, vilket ger oss våra delar för det slutliga meddelandesammandraget:
Om vi sätter ihop dessa värden i följande layout har vi nu vårt sista meddelandesammandrag (𝑀):
𝑴=3ccf243960d58d970b38dfbfa68be5c554c7462c960ab480933eb16b0d789597
Som noterades i början av kapitlet kan vi se att från vårt första meddelande "portsmouth" finns det ingen likhet till meddelandesammandraget. Den långa processen med SHA-256 är nödvändig för att bibehålla säkerheten för Bitcoin, vilket säkerställer att det inte finns något möjligt sätt att vända processen. Om en metod för vändning var möjlig skulle angripare ha möjlighet att ändra transaktioner på blockkedjan efter eget val.
Och det avslutar hashprocessen. Om du undrade hur jag kunde få alla dessa resultat (jag är rädd att jag inte beräknade varje iteration själv) eller ville prova själv, skulle jag rekommendera att kolla in detta Google Sheets-dokument av hashprocessen av David Rabahy.
Om du gillade den här serien eller hade några brännande frågor, tveka inte släpp en kommentar nedan.
