Hvad er SHA-2-algoritmen?

Hvis du har læst vores anden artikel, har du sikkert en ret god ide om, hvorfor vi bruger SHA-2, og hvad det gør i overordnet forstand. Menhvad sker der egentlig, når vi zoomer ind?Hvordan kan vi tage en sætning som 'hashing er kompliceret', sætte den igennem en online SHA-256 lommeregner , og ender med en hash som denne:

d6320decc80c83e4c17915ee5de8587bb8118258759b2453fce812d47d3df56a

Hvordan giver et simpelt bogstav 'A' os noget lige så komplekst?

559aead08264d5795d3909718cdd05abd49572e84fe55590eef31a88a08fdffd

Hvordan kan hele uafhængighedserklæringen resultere i noget, der ligner et enkelt bogstav, men også med så vidt forskellige værdier?

639505bee7bdae68f224b0d5bcb1c324d0e33011d2302839b7bedfab4515a1bb

Hvad foregår der egentlig inde i SHA-2-algoritmen?

Hvordan virker SHA-2-algoritmen?

Vi vil undersøgehvordan SHA-2-algoritmen fungerer gennem et eksempel, gennem hvert trin, der tager vores budskab, 'hashing er kompliceret', og på en eller anden måde giver os det indviklede output af:

d6320decc80c83e4c17915ee5de8587bb8118258759b2453fce812d47d3df56a

Vi vil demonstrere SHA-256, fordi det er den mest brugte iteration. SHA-224, SHA-384, SHA-512, SHA-512/224 og SHA-512/256 fungerer alle på samme måde, bortset fra atde to førstnævnte algoritmer har en blokstørrelse på 512 bit, mens de fire sidstnævnte har en blokstørrelse på 1024 bit.Bemærk, at SHA-384, SHA-512, SHA-512/224 og SHA-512/256 også inkluderer 80 runder i stedet for de 64, vi vil beskrive.

De bruger også nogle lidt forskellige inputnumre på forskellige punkter i algoritmen. SHA-512/224 og SHA-512/256 er trunkerede versioner af SHA-512, hvilket betyder, at den endelige hash kun er de 224 eller 256 bits længst til venstre.Du kan henvise til FIPS 180-4 for detaljerne.

Konvertering til binær

Når vi indtaster 'hashing er kompliceret' i en SHA-256 hash-funktion, er det første, der sker, at dataene konverteres til binære. For at forenkle forklaringen er dette i det væsentlige fordimennesker og maskiner taler, forstår og arbejder på separate sprog. Selvom det er nemt for os at tænke i ord, gør computere det hele i nuller og etaller. Hver gang vi bruger dem, konverterer de vores bogstaver og ord til det binære sprog, som de forstår, så de kan køre beregninger. Alt dette foregår dog generelt uden at vi bemærker det, hvilket giver os en smidig brugeroplevelse.

Vi konverterer bogstaver, tal og symboler til binære ved hjælp af American Standard Code for Information Interchange (ASCII) , som i bund og grund blot er et system, som et udvalg af smarte mennesker blev enige om til oversættelse mellem de to sprog.

Hvis vi vender os til en ASCII tabel , kan vi se, at det første bogstav i vores sætning, et lille bogstav 'h', er skrevet som '01101000' i binær. Ifølge samme tabel er et lille bogstav 'a' '01100001', mens et 's' er '01110011' og et 'h' er '01101000'. Bogstavet 'i' er '01101001', mens 'n' er '01101110', og 'g' er '01100111'. Den binære kode for et mellemrum er angivet i tabellen øverst i anden kolonne som ASCII-tegnet 'SP', i samme række som decimaltallet 32. Det er '00100000'.

I stedet for at gennemgå hvert enkelt bogstav i vores eksempelsætning, vil vi bare indtaste det i en ASCII til binær konverter . Indtastning giver os:

01101000 01100001 01110011 01101000 01101001 01101110 01100111 00100000 01101001 01110011 001010 10101010101010101010 1101 01110000 01101100 01101001 01100011 01100001 01110100 0110010

Ovenstående giver ingen mening for os som mennesker, men for maskiner, hedder det, er 'hashing kompliceret'.

SHA-2 og polstring

Når vi har omskrevet vores sætning i binær, er næste trin at tilføje polstring, som i bund og grund er en masse ekstra data, som vi tilføjer til vores input for at gøre det til en fast længde. Det er også med til at forebygge længde forlængelsesangreb . De forskellige versioner af SHA-2 har følgende blokstørrelser:

• SHA-224 – 512 bit
• SHA-256 – 512 bit
• SHA-384 – 1024 bit
• SHA-512 – 1024 bit
• SHA-512/224 – 1024 bit
• SHA-512/256 – 1024 bit

Disse blokstørrelser er mængden af ​​data, som SHA-2-algoritmen behandler på én gang. Vi har vist, at hash-funktioner er i stand til at behandle input, så længe uafhængighedserklæringen (SHA-256 faktisk kan tage input, der er størrelsesordener større , ved op til 2^64-1, hvilket er så stort et tal, at du ikke rigtig behøver at bekymre dig om algoritmens øvre grænser). Den behandler dog ikke disse oplysninger på én gang.

I stedet for, i tilfælde af SHA-256, behandler den informationen i 512-bit datablokke. I vores eksempel er tingene relativt ligetil, fordivores input 'hashing er kompliceret' er mindre end 512 bit data–det er 176 bit. Du kan beregne det ved at tælle hvert binært ciffer eller ved at tælle hvert bogstav plus de to mellemrum og derefter gange med 8, fordi hvert tegn er en byte langt.

Vi har dog ofte brug for at hash input, der er langt større end 512 bit i længden. I disse tilfælde er beskeden simpelthen opdelt i blokke. Hvis vi havde brug for at hash en 10.000-bit besked, skulle den simpelthen opdeles på tværs af flere 512-bit blokke.

I vores eksempel har vi kun 176 bit data, men skal fylde en 512-bit blok. Det betyder atvi bliver nødt til at tilføje 336 bits polstringat fuldføre det. SHA-2 bruger følgende polstringsskema:

• En 'en' tilføjesefter de binære meddelelsesdata, der hash.
• Derefter tilføjes nuller, indtil længden af ​​inputdata plus den yderligere fra det foregående trin lægger op til 448 bit. I vores eksempel har vi en inputlængde på 176 bit, plus den fra det forrige trin, hvilket bringer os op på 177 bit. Derfor skal vi bruge 448 minus 177 nuller. Hvis vi regner, er vi nødt til dettilføje 271 nuller.
• Det sidste 64 bit af sidste blok (512 bit minus de 448 bit, som vi allerede har udfyldt i de foregående trin) er afsat til at vise længden af ​​meddelelsen i binær . Da vi kun har at gøre med én blok af data, skal slutningen af ​​den inkludere denne 64-bit beskedlængde. Vores beskedlængde i bit er 176, hvilket er 10110000 i binær . Dette vil gå i slutningen af ​​blokken, og de foregående tal fyldes op med flere nuller (i tilfælde, hvor vi har en meget større input, vil disse nuller blive erstattet af den længere meddelelseslængde skrevet i binært).

Hvis vi sætter det hele sammen, ender vi med følgende polstrede 512-bit blok for beskeden 'hashing er kompliceret':

01101000 01100001 01110011 01101000 01101001 01101110 01100111 00100000 01101001 01110011 001010 10101010101010101010 1101 01110000 01101100 01101001 01100011 01100001 01110100 0110010 1 0000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000 00000000 00000000 00000000 00000000 00000000 00000000 00000000000000000000000000 0 000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 10110000

Hvis du tæller enere og nuller ud, vil du se, at der er 512 bits data i ovenstående blok. De første 176 bit er inputmeddelelsen i binær, 'hashing er kompliceret'. Den efterfølges af 1'eren, som vi har markeret med fed og understreget for at gøre det lettere at se. Så har vi de 271 nuller, efterfulgt af 64-bit beskedlængden, som også er fed og understreget. Denne beskedlængde indledes med nuller, som vi nævnte tidligere.

I SHA-384, SHA-512, SHA-512/224 og SHA-512/256 er udfyldningsskemaet stort set det samme, bortset fra at blokkene hver skal udfyldes med 1024 bit data ogden sidste blok har følgende forskelle:

• I det andet trin tilføjes nuller, indtil en længde på 896 bit er nået, i stedet for 448 bit.
• I det sidste trin afsættes 128 bit af blokken til at tilføje meddelelseslængden.

Hvis vi kørte gennem vores eksempel med SHA-384, SHA-512, SHA-512/224 eller SHA-512/256, ville den polstrede blok se meget ens ud, bortset fra at den ville have yderligere 448 nuller fra andet trin , og yderligere 64 nuller fra det sidste trin.

Input større end 448 bits (til SHA-224 og SHA-256) og 896 bits (til SHA-384, SHA-512, SHA-512/224 og SHA-512/256)

Vi har ofte brug for at hash beskedinput, der er større end blokstørrelserne på enten 512 bit eller 1024 bit, hvilket betyder, at vi skal opdele dataene på tværs af flere blokke. Afskæringspunktet for opdeling af blokke er faktisk enten 447 bit eller 895 bit, fordi mindst en bit af udfyldning plus 64-bit eller 128-bit meddelelseslængden skal inkluderes.

Det betyder athvis du har præcis 448 bits (eller 896 bits) data, som du skal hash, skal de opdeles på to blokke. Den første blok vil inkludere alle data plus 64 (eller 128) bits udfyldning (den ene efterfulgt af 63 eller 127 nuller). Den anden blok vil have yderligere 448 (eller 896) nuller, med 64-bit (eller 128-bit) meddelelseslængden mærket på i slutningen på samme måde, som vi viste i det foregående afsnit.

449 bits (eller 897 bits) data ville også optage to datablokke og ville i stedet have et plus 62 (eller 126) nuller af udfyldning før beskedlængden.

På den anden side,447 bits (eller 895 bits) data ville lige nå at passe ind i en enkelt blok. Det ville inkludere de 447 (eller 895) bits, derefter udfyldning af en enkelt en , efterfulgt af meddelelseslængden på enten 64 eller 128 bit.

Systemet fungerer på samme måde for større datainput. Dataene er opdelt på tværs af så mange blokke, som det kræver, for at alle data kan inkluderes, plus mindst ét ​​ciffer af udfyldning og med 64-bit beskedlængden tilføjet i slutningen af ​​den sidste blok. I tilfælde af 5.000 bits inputdata og 512-bit blokstørrelserne af SHA-224 eller SHA-256, vil inputtet blive opdelt på 10 blokke. De første ni ville kun inkludere inputdata, mens den tiende ville inkludere de sidste 392 bits inputdata, en en , 55 nuller og derefter 64-bit beskedlængden til sidst. Dette udgør i alt 5.120 bit data, hvilket er 10 ganget med 512.

I tilfælde af SHA-384, SHA-512, SHA-512/224 eller SHA-512/256 vil de samme 5.000 bits data blive opdelt på seks 1024-bit blokke. De første fire ville kun inkludere inputdata. Den femte blok vil omfatte de sidste 904 bit data, en en og derefter 119 nuller som polstring. De 5.000 bit data passer ikke helt inden for fem blokke, fordi de sidste 904 bit data overstiger cutoff for den sidste blok, som er 896 bit. Den sjette blok vil inkludere 896 nuller og derefter 128-bit beskedlængden til sidst.

Den vigtigste SHA-2-algoritme

Nedenfor har vi en grafisk repræsentation af SHA-2-algoritmen:

SHA-2-algoritmen

Medmindre du har beskæftiget dig med lignende algoritmer før, giver det sandsynligvis ikke ret meget mening. Bare rolig, for vi kommer til at bruge meget tid på at forklare det i detaljer.

Den første ting, der er værd at bemærke, er, at diagrammet viser Runde 0, runde T og runde 63. Runde 0 er den første runde, mens runde T i bund og grund er en pladsholder, der repræsenterer enhver runde imellem, fordi det ville være uhåndterligt at tegne snesevis af runder. Runde 63 er den sidste runde, som giver os i alt 64 runder, hvis vi starter fra 0.Bemærk, at SHA-384, SHA-512, SHA-512/224 og SHA-512/256 involverer 80 runder i stedet for 64, så den proces, vi er ved at beskrive, er noget anderledes i disse versioner af SHA-2-algoritmen.

Hver af disse runder har sine egne input og beregninger, hvor output fra nogle beregninger bliver input til efterfølgende. Som du sikkert begynder at finde ud af, er SHA-2-algoritmen kompliceret og involverer en hel masse trin og beregninger.

Meddelelsesindgangen M

Vi vil holde tingene enkle i dette eksempel ved kun at bruge vores enkelte 512-bit input blok i stedet for en længere og mere kompliceret input, der kræver en række blokke. Hvis vi skulle beskrive processen for længere datainput, ville vi være nødt til fuldstændigt at gentage meget af den lange, indviklede proces, vi er ved at lægge ud, med hver enkelt af de forskellige blokke af inputdata.

Hvis du ser øverst til venstre i diagrammet ovenfor, vil du seBesked input (M). Dette er den 512-bit polstrede blok af vores besked 'hashing er kompliceret':

01101000 01100001 01110011 01101000 01101001 01101110 01100111 00100000 01101001 01110011 001010 10101010101010101010 1101 01110000 01101100 01101001 01100011 01100001 01110100 01100101 01100100 10000000 00000000 000000000 0000000000000000000 0 0000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00 0 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 10110000

Vores beskedinput er først opdelt i seksten 32-bit ord mærket W₀er W._femten:

• I₀– 01101000 01100001 01110011 01101000
• I₁– 0110100 01101110 01100111 00100000
• I_to– 01101001 01110011 00100000 01100011
• I₃– 01101111 01101101 01110000 01101100
• I₄– 01101001 01100011 01100001 01110100
• I₅– 01100101 01100100 10000000 00000000
• I₆– 00000000 00000000 00000000 00000000
• I₇– 00000000 00000000 00000000 00000000
• I₈– 00000000 00000000 00000000 00000000
• I₉– 00000000 00000000 00000000 00000000
• I₁₀– 00000000 00000000 00000000 00000000
• I_elleve– 00000000 00000000 00000000 00000000
• I₁₂– 00000000 00000000 00000000 00000000
• I₁₃– 00000000 00000000 00000000 00000000
• I₁₄– 00000000 00000000 00000000 00000000
• I_femten– 00000000 00000000 00000000 10110000

Konvertering til hexadecimal

Før vi går videre, vil vi konvertere ovenstående binære cifre til et andet nummereringssystem kaldet hexadecimal. Hvis du har været meget opmærksom, har du måske bemærket, at vores hash indeholder en masse bogstaver:

d6320decc80c83e4c17915ee5de8587bb8118258759b2453fce812d47d3df56a

Dette skyldes, at hashes generelt er skrevet i hexadecimal, hvilket simpelthen er en anderledes måde at tælle på, meget på samme måde som binært og decimalsystemet, vi alle er vant til, er forskellige.

Binært er et base-2-system, hvilket grundlæggende betyder, at du har to muligheder, et 1 og et 0, før du skal begynde at repræsentere information med et større antal cifre.

Vores almindelige decimalsystem er base-10, hvilket betyder, at vi har 10 muligheder, 0, 1, 2, 3, 4, 5, 6, 7, 8 og 9, før vi løber tør og skal begynde at kombinere tal for at repræsentere større mængder af data, såsom når vi kombinerer et 1 og et 0 for at lave 10.

Hexadecimal er et base-16 system, hvilket betyder, at vi har 16 muligheder:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f

Når vi bruger base-16, er værdien af ​​10 ikke den samme behagelige værdi, som vi er vokset op med. I stedet er en 10 i base-16 virkelig tallet 16, som vi er vant til i decimal. I base-10 er vores velkendte decimaltal 10 repræsenteret med en-en, 11 erb, 12 erc,13 erd, 14 erogog 15 erf.

At gå for meget i dybden på hexadecimal vil distrahere fra hovedemnet, men du kan finde nogle flere oplysninger her .

Alt du behøver at vide er, at vi skifter vores input fra binær til hexadecimal, og vi vil gøre det ved at indtaste vores binære værdier i en simpel online konverter (hvis du selv prøver dette og kopierer de binære tal fra oven, skal du fjerne mellemrummene). Det burde give dig:

• I₀– 68617368
• I₁– 346E6720
• I_to– 69732063
• I₃- 6F6D706C
• I₄– 69636174
• I₅– 65648000
• I₆– 00000000
• I₇– 00000000
• I₈– 00000000
• I₉– 00000000
• I₁₀– 00000000
• I_elleve– 00000000
• I₁₂– 00000000
• I₁₃– 00000000
• I₁₄– 00000000
• I_femten– 000000B0

Meddelelsesplan: Find de andre W-værdier

SHA-2-algoritmen

Hvis du gransker diagrammet nøje, vil du bemærke, at en af ​​indgangene til runde 63 er W₆₃. Vi har kun W₀er W._femtenindtil videre, så det betyder, at vi har brug for yderligere 48 værdier, før vi har alle vores W-input. I SHA-384-, SHA-512-, SHA-512/224- og SHA-512/256-versionerne af algoritmen skal vi have 80 værdier i alt, så vi skal udlede en ekstra 64.

Disse input beregnes i boksen markeretbesked tidsplani diagrammet. I begge tilfælde udleder vi dem ved hjælp af følgende formel:

I_t= s₁(I_t-2) + W_t-7+ s₀(I_t-15) + W_t-16

Forvirret? Skyld ikke skylden på os, skyd skylden på kryptograferne, der har designet det. Lad os starte med at prøve at forklare et par af værdierne i ligningen ovenfor.

ter i bund og grund en stand-in for hvilken runde vi er i gang med.Hvis vi er i første runde, som ingeniørerne velvilligt kalder runde 0,ter 0. Altsåhvis du ser W₀, betyder det værdien for W i runde 0. Vi bruger denne notation, fordi vi vil bruge et stort antal forskellige værdier for W på forskellige stadier af algoritmen. Mange af de andre variabler bruger også skiftende værdier gennem algoritmens stadier.

Den næste værdi, du sandsynligvis er i tvivl om, er:

s₁(x)

Symbolet er kendt som ensigma, og ved siden af ​​tallet 1 står det for følgende funktion:

s₁(x) = ROTR¹⁷(x) ⊕ R.O.T.R.¹⁹(x) ⊕ SHR¹⁰(x)

Før vi fuldt ud kan forstå, hvordan meddelelsesplanen fungerer, skal vi forklare denne funktion.

Skiftedrift

ROTR fra den foregående ligning signalerer, at vi skal udføre encirkulært højreskiftpå den værdi, der følger efter den, x. Det forskydes i overensstemmelse med antallet af bit vist i hævet skrift. Lad os tage det første segment:

R.O.T.R.¹⁷(x)

Ovenstående siger egentlig bare for at flytte værdienx 17 bitstilhøjre. For at give dig et eksempel på, hvordan dette fungerer, hvis værdien for x er 1000 1001, og vi ønsker at udføre et cirkulært højreskift på kun1 bit, ville vi i det væsentlige bare tage værdien i kolonnen længst til højre:

1000 1001

Og flyt den til venstre:

1100 0100

For at demonstrere konceptet igen, denne gang med et cirkulært skift til højre for 3 bit, tager vi det samme tal:

1000 1001

Denne gang tager vi hvert af de tre cifre længst til højre og flytter dem til venstre:

0011 0001

Denne type operation er involveret i både den første del af ligningen, såvel som den midterste, med skift af17og19bits hhv.

Den sidste del af ligningen siger:

SHR¹⁰(x)

SHR fortæller os at udføre en lignende, men dog lidt anderledes operation, kendt som enlogisk venstreskift. I dette tilfælde flytter vi værdien x til venstre med antallet af bits i hævet skrift,10, og udfyld derefter højre side med nuller. Lad os tage det samme tal som før for at demonstrere, hvordan dette virker:

1000 1001

Vi udfører et skift på 10 bit til venstre i 10 trin, hvor det sidste ciffer er fed af ingen anden grund end for at hjælpe dig med at holde styr på dets fremskridt:

0001 0010

0010 0100

01001000

10010000

0010 0000

0100.000

1000 0000

0000 0000

0000 0000

0000 0000

I løbet af de første syv træk så vi dataene langsomt bevæge sig over til venstre og blive erstattet med nuller til højre. Ved det ottende træk var alle de originale data fuldstændig væk og var blevet erstattet af nuller.

Bemærk forskellen mellem dettelogisk venstreskiftoperation og det tidligere omtaltecirkulært højreskift. Ikke alene sker bevægelsen i forskellige retninger, men det cirkulære højreskift genbruger dataene til den anden side, mens det logiske venstreskift kasserer det og fylder det rum, der åbner sig op med nuller

At diskutere disse forskydninger i for detaljeret vil bringe os ud på en tangent, men du kan finde ud af mere om, hvordan de fungerer her ressource .

XOR operationer

Den sidste del af vores operation, vi skal forklare, er⊕ symbol, som forbinder hver af disse komponenter. ⊕ står for XOR operation, som er en logisk operation, der grundlæggende betyderdens output er sandt, hvis enten input er sandt, men er falsk, hvis begge input eller ingen af ​​input er sande.

Det er svært at forklare dette uden at dykke ned i en fuld forelæsning om boolsk algebra og logiske operationer. Dette link giver dig lidt af en gennemgang, men du behøver ikke rigtig at forstå det i dybden for at få et ordentligt overblik over, hvordan resten af ​​algoritmen fungerer. Alt du skal vide er, at vi grundlæggende vil lægge nogle tal sammen, men bruge noget mærkeligt matematik, som du sandsynligvis ikke har lært i skolen.

Løsning af den første del af vores ligning

Nu hvor vi har dækket nogle af detaljerne i operationerne, lad os tage et nyt kig på ligningen, vi blev stødt på:

I_t= s₁(I_t-2) + W_t-7+ s₀(I_t-15) + W_t-16

Hvor:

s₁(x) = ROTR¹⁷(x) ⊕ R.O.T.R.¹⁹(x) ⊕ SHR¹⁰(x)

Og:

s₀(x) = ROTR⁷(x) ⊕ R.O.T.R.¹⁸(x) ⊕ SHR³(x)

Lad os nu prøve at finde ud af værdien for W₁₆, fordi det er det første tal, vi skal finde ud af ved hjælp af denne ligning. Lad os tilføje vores værdi:

I₁₆= s₁(I_16-2) + W_16-7+ s₀(I_16-15) + W_16-16

Derfor:

I₁₆= s₁(I₁₄) + W₉+ s₀(I₁) + W₀

Vi kender alle W-værdierne i højre side af ligningen, fordi de er de W-ord, vi fandt ud af ved at opdele vores polstrede meddelelsesblok. Værdierne i både binær og hexadecimal er:

• I₀–68617368eller01101000 01100001 01110011 01101000
• I₁–346E6720eller0110100 01101110 01100111 00100000
• I₉–00000000eller00000000 00000000 00000000 00000000
• I₁₄–00000000eller00000000 00000000 00000000 00000000

Før vi tilslutter alle tallene, lad os finde ud af, hvad værdien er fors₁(I₁₄), ved hjælp af ligningen, vi diskuterede ovenfor:

s₁(I₁₄) = ROTR¹⁷(I₁₄) ⊕ R.O.T.R.¹⁹(I₁₄) ⊕ SHR¹⁰(I₁₄)

Med W₁₄værdier i hexadecimal, ser ligningen sådan ud:

s₁(00000000) = ROTR¹⁷(00000000) ⊕ R.O.T.R.¹⁹(00000000) ⊕ SHR¹⁰(00000000)

Det første trin er at udføre de skift, som vi beskrev tidligere for hvert afsnit af ligningen. Vi skifter til den binære værdi for W₁₄snarere end den hexadecimale, fordi det gør det nemmere at se de skift, vi skal udføre. Bemærk, at de binære og hexadecimale versioner simpelthen er forskellige repræsentationer af den samme værdi, så det giver ingen problemer at skifte dem, når det er praktisk:

R.O.T.R.¹⁷(00000000 00000000 00000000 00000000)

Resultatet af ovenstående operation vil være ekstremt forudsigeligt, fordi det hele er nuller, men vi vil køre igennem det alligevel, bare for at give dig en idé om, hvad der foregår. Gå til følgende online værktøj og indtast den binære værdi for W₁₄, de 32 nuller, i indtastningsfeltet markeretVærdi. Sørg for at fjerne mellemrummene. Gå ind32iStørrelse, fordi inputværdien er 32 bit lang. Type17iFlyttefelt, for at sikre, at det flytter værdien 17 mellemrum. Sørg for, at retningen er indstillet tilHøjre. VælgCirkulært skiftboksen og klik derefterUdfør bitskift. Dette udfører det cirkulære højreskift.

Ikke overraskende vil dette give dig en værdi af:

00000000 00000000 00000000 00000000

Det ser ud til, at der ikke er sket noget, men nullerne blev flyttet rundt. Vi kan bare ikke fortælle, og det virker meningsløst, for de er alle nuller.

Nu er det tid til at udføre den midterste del af operationen:

R.O.T.R.¹⁹(00000000 00000000 00000000 00000000)

I dette tilfælde er alt det samme, undtagenFlytteværdi er nu19. Dette giver os et output på:

00000000 00000000 00000000 00000000

Nu til den sidste del:

SHR¹⁰(00000000 00000000 00000000 00000000)

Husk, at SHR repræsenterer enlogisk venstreskift, så denne gang skal vi justere indstillingerne. DetVærdiogStørrelseforblive det samme, men vi skal sikre os, at:

Flytteer indstillet til10

Retninger indstillet tilVenstre

Logisk skifter valgt.

Igen får vi det samme output af:

00000000 00000000 00000000 00000000

Selvom dette kan have virket som en meningsløs bestræbelse, var det kun fordi vores startnummer var nuller. Når du udfører disse handlinger med andre numre, vil ændringer faktisk forekomme.

Binære og hexadecimale strenge på nul er de samme, så vi skifter disse værdier tilbage til hexadecimale, når vi går videre til næste del af vores beregning, så det passer bedre på siden:

s₁(I₁₄) = 00000000 ⊕ 00000000 ⊕ 00000000

Vi kan løse denne ligning i denne online lommeregner ved at indtaste:

00000000ind ifelt A.

VælgerGRATISfra rullemenuen under den.

00000000ind ifelt B.

VælgerGRATISfra rullemenuen under den.

00000000ind ifelt C.

Hvis du har gjort det rigtigt, burde det vise sigA XOR B XOR Ci boksen markeretLogisk udtryk. Det vil give dig svaret i feltet markeretDriftsresultat. I dette tilfælde er det:

0eller00000000eller00000000 00000000 00000000 00000000.

Det er et kedeligt svar, men det tager os et skridt tættere på at løse vores ligning, for nu ved vi det:

s₁(I₁₄) = 00000000

Hvis du scroller tilbage, vil du se, at vi bare mangler at finde en komponent mere, og så kan vi løse ligningen. Vi skal finde værdien for σ₀(I₁), som bruger følgende ligning:

s₀(x) = ROTR⁷(x) ⊕ R.O.T.R.¹⁸(x) ⊕ SHR³(x)

Som vi sagde ovenfor, ved vi, at W₁er:

346E6720

Derfor:

s₀(346E6720) = ROTR⁷(346E6720) ⊕ R.O.T.R.¹⁸(346E6720) ⊕ SHR³(346E6720)

Denne ligning er næsten nøjagtig den samme som den, vi lige har løst. For korthedens skyld går vi ikke ind på det, men hvis du selv vil prøve, skal du blot følge hvert af de trin, vi fulgte ovenfor, men ændreFlyttehver gang til7,18og3, henholdsvis.

s₀(346E6720) =4068DCCE ⊕ 99C80D1B ⊕ A3733901

Når du har løst det, vil du opdage, at svaret er:

s₀(346E6720) =7AD3E8D4

Modulær tilføjelse

Nu hvor vi kender værdierne for begges₁(I₁₄)ogs₀(I₁), er vi endelig klar til at finde ud af værdien for W₁₆:

I₁₆= s₁(I₁₄) + W₉+ s₀(I₁) + W₀

I₁₆= 00000000 + 00000000 + 7AD3E8D4 + 68617368

Ovenstående ligning ser forholdsvis ligetil ud. Det eneste, vi skal bemærke, er, at plustegnene i det repræsenterer modulær addition snarere end normal addition.

For at demonstrere konceptet med et 8-cifret decimaltal, hvis vi brugte modulær addition til at tilføje 1 til 99.999.999, er svaret ikke 100.000.000, som du ville forvente. I stedet ruller den blot tilbage til starten på samme måde, som 1 følger 12 på et ur. Svaret er 0 eller 00.000.000. Tjek ud denne primer hvis du har brug for en kort introduktion til modulær aritmetik.

I det væsentlige giver modulær addition dig mulighed for at tilføje tal, uden at dit svar nogensinde bliver længere. Tag følgende som et andet decimaleksempel:

76.487.639 + 98.094.034

Ved normal tilføjelse ville svaret være:

76.487.639 + 98.094.034 =174.581.673

Med modulær tilføjelse kan vi simpelthen smide1, og vores svar er:

76.487.639 + 98.094.034 =74.581.673

Vi kan lave de samme beregninger med de hexadecimale tal i vores ligning:

I₁₆= 00000000 + 00000000 + 7AD3E8D4 + 68617368

Vi løser det ved hjælp af dette online lommeregner . I vores eksempel behøver vi ikke bekymre os om at tilføje nuller, fordi de ikke ændrer værdien, og vi kan blot tilføje7AD3E8D4og68617368. Hvis du skal bruge det samme værktøj til at tilføje flere tal i fremtiden, kan du blot udføre operationen flere gange og tilføje det næste tal til resultatet fra den forrige ligning.

Vi kan løse vores ligning ved at skrive7AD3E8D4ind i online-beregnerens første boks og68617368ind i den anden. Dette giver os et resultat af:

I₁₆= e3355c3c

Husk, at dette formodes at være modulær addition, så hvis resultatet havde overskredet otte cifre, ville vi være nødt til at fjerne det længst til venstre. Vores resultat er kun 8 cifre langt, så vi behøver ikke bekymre os i dette tilfælde.

Det har været en lang og indviklet proces, men vi har endelig svaret til W₁₆. det ere3355c3c. Det samme sæt beregninger skal udføres for alle W-værdierne fra W₁₇er W.₆₃.

Vi har demonstreret, hvordan disse beregninger fungerer, så det er tid til at gå videre til de andre aspekter af SHA-2-algoritmen.

Initialiseringsvariablerne

Nu hvor vi har diskuteret, hvor alle W-input kommer fra, lad os vende tilbage til vores diagram:

SHA-2-algoritmen

Øverst vil du bemærke, at der står H_i-1. Dette repræsenterer arbejdsvariablerne, der fungerer som input i hver runde. Der er otte af disse variabler, og de opdateres i slutningen af ​​hver runde. Til at begynde med initialiseringsvariablerne, H₍₀₎er:

• H_(0)a= 6a09e667
• H_(0)b= bb67ae85
• H_(0)c= 3c6ef372
• H_(0)d= a54ff53a
• H_{(0) og}= 510e527f
• H_(0)f= 9b05688c
• H_(0)g= 1f83d9ab
• H_(0)t= 5be0cd19

Ovenstående tal er afledt af kvadratrødderne af de første otte primtal, men hvor de kommer fra er ligegyldigt for vores formål. Alt du skal vide er, at vi skal begynde med de specifikke tal, der er anført ovenfor.

I efterfølgende runder vil disse værdier være anderledes. For både overskuelighed og for at repræsentere deres skiftende værdier viser diagrammet disse input soma, b, c, d, e, f, g og h i stedet forH_(0)a, H_(0)bosv. eller H_(1)a, H_(1)b, etc..

Konstanten, K

I hver runde tager vi arbejdsvariablerne og kombinerer dem med den runde passende W-værdi, som vi beskrev i det foregående afsnit. Hvis du ser til højre side af runderne i diagrammet, vil du se et andet input,K. Der er 64 separate 32-bit værdier for K, en for hver af de 64 runder. De er afledt af terningrødderne af de første 64 primtal. I hexadecimal er disse otte-tegnskonstanter for hver runde som følger, læst fra venstre mod højre, før de går ned til næste række:

Bemærk, at værdierne for K er 64 bit lange i SHA-384, SHA-512, SHA-512/224 og SHA-512/256. Der er også 80 af disse værdier i stedet for 64. Du kan tjekke disse ud i FIPS 180-4 hvis det er nødvendigt.

Maj operationen

Endelig har vi alle vores input. Nu er det tid til at finde ud af, hvordan hver runde af SHA-2 bruger dem. Følgende diagram giver en god oversigt over, hvordan SHA-2 bruger alle disse input:

SHA-2-beregningerne involveret i en enkelt runde.

Hvis du ser mod toppen, har vi arbejdsvariablerne,H_(i)a, H_(i)b, H_(i)c, H_(i)d, H_(i)e, H_(hvis, H_{(i) g}, og H_(i)h. Disse er de samme som arbejdsvariablernea, b, c, d, e, f, g og hi diagrammet for hele SHA-2-algoritmen. I første runde vil de være de respektive initialiseringsvariabler, som vi listede i det foregående afsnit. Hvis du ser på H_(i)a, H_(i)b, H_(i)c, øverst til venstre vil du se, at alle tre input har pile, der peger på en boks,Maj. Dette står for følgende ligning:

Maj (a,b,c) = (a OG b) ⊕ (a OG c) ⊕ (b OG c)

For at gøre ligningen nemmere at læse, har vi taget H ud_(jeg)fra hver variabel og bare efterladt dem som-en,b, ogc. Så længe du husker, at værdierne af-en,bogcskift med hver runde, dette skulle gøre det nemmere at følge.

Vi har allerede beskæftiget os med ⊕ symbol, menOGi denne sammenhæng er nyt for os. Dette er en anden operation i boolsk algebra. Det refererer til logisk konjunktion, hvilket grundlæggende betyder, at output kun er sandt, hvis begge input er sande. Du kan lær mere her , men vi vil springe videre og blot bruge en online lommeregner for at udføre denne operation.

Lad os først smide initialiseringsvariablerne ind, som vi anførte iInitialiseringsvariablerneafsnit:

Maj (6a09e667, bb67ae85, 3c6ef372) = (6a09e667 OG bb67ae85) ⊕ (6a09e667 OG 3c6ef372) ⊕ (bb67ae85 OG 3c6ef372)

Den regnemaskine vi bruger er ret begrænset, så vi bliver nødt til at udføre beregningen i flere trin.

Gå ind6a09e667i inputEN.

VælgOGfra rullelisten nedenfor.

Gå indbb67ae85i inputB.

Dette giver dig et resultat af:

2A01A605

Næste:

Gå ind6a09e667i inputEN.

VælgOGfra rullelisten nedenfor.

Gå ind3c6ef372i inputB.

Dette giver dig et resultat af:

2808E262

Derefter:

Gå indbb67ae85i inputEN.

VælgOGfra rullelisten nedenfor.

Gå ind3c6ef372i inputB.

Dette giver dig et resultat af:

3866A200

Lad os sætte alle disse svar ind i ligningen:

Maj (6a09e667, bb67ae85, 3c6ef372) = 2A01A605 2808E262 3866A200

Nu skal vi bare ændre inputs i vores online-beregner endnu en gang:

Gå ind2A01A605i inputEN.

VælgGRATISfra rullelisten nedenfor.

Gå ind2808E262i inputB.

VælgGRATISfra rullelisten nedenfor.

Gå ind3866A200i inputC.

Dette giver os:

Maj(a,b,c)=3A6FE667

Den ∑₀operation

Nu hvor vi har svaret påMaj(a,b,c)lad os gå tilbage til diagrammet og se, hvad der er det næste:

SHA-2-beregningerne involveret i en enkelt runde.

Du vil se, at pilen fraH_(i)apeger også på∑ symbol. Dette indikerer, at vi skal tage H_(i)ainput og sæt det gennem følgende beregning:

∑₀(a) = ROTR^to(en) ⊕ R.O.T.R.¹³(en) ⊕ R.O.T.R.²²(en)

Endnu en gang har vi udeladt H_(jeg)for klarhed. Vi har allerede beskæftiget os med dissecirkulære højreskift, samtXOR operationer. Denne gang skal vi udføre de cirkulære højreskift med henholdsvis 2, 13 og 22 bit. Lad os vende tilbage til vores lommeregner , med vores værdi for-en,6a09e667.

For det første afsnit af denne beregning skal du indtaste:

6a09e667ind iVærdiSikrehexadecimalvælges fra rullemenuen til højre.

32 indStørrelse.

2 indFlytte.

Sørge for atHøjreer valgt tilRetning.

Klik påCirkulært skiftboks.

Klik påUdfør bitskiftknap.

Dette vil give dig et resultat af:

DA827999

Hvis du vil have mere indsigt i, hvordan dette resultat blev opnået, viser lommeregneren de trin, der er involveret i at udarbejde operationen. Du kan også henvise tilbage tilSkiftedriftafsnit for yderligere detaljer.

For de resterende to værdier skal vi finde ud af, vi behøver kun at ændre værdien iFlytteog klik derefter påUdfør bitskiftknappen igen.

Ændrer det til13giver os et svar på:

333B504F

Ændrer det til22giver os et svar på:

27999DA8

Vi har nu alle de værdier, vi skal bruge for at afslutte ligningen:

∑₀(6a09e667) =DA827999⊕333B504F⊕27999DA8

Lad os vende tilbage til lommeregner vi har brugt til XOR-operationerne og:

Gå indDA827999i inputEN.

VælgGRATISfra rullelisten nedenfor.

Gå ind333B504Fi inputB.

VælgGRATISfra rullelisten nedenfor.

Gå ind27999DA8i inputC.

Dette giver os et resultat af:

∑₀(6a09e667) = CE20B47E

Modulær tilføjelse af resultaterne

Hvis vi følger pilene fraMajboksen og∑boks, ser vi, at udgangene så sendes som input ind i en boks med en+symbol på den. Dette repræsenterermodulær tilføjelse, der, som vi allerede har beskrevet, er meget som normal addition, bortset fra at tallene simpelthen ruller tilbage til starten på et bestemt tidspunkt, i stedet for at blive ved med at vokse sig større. Hvis du ønsker en genopfriskning med flere detaljer, henvises til den tidligere modulære tilføjelsessektion.

Diagrammet kan repræsenteres ved hjælp af følgende formel:

Maj(a,b,c) + ∑₀(a) =3A6FE667+CE20B47E

Vi vil bruge samme lommeregner en gang til.

Gå ind3A6FE667ind i det første felt ogCE20B47Eind i den anden, og klik derefterBeregn. Dette burde give dig et svar på:

108909ae5

Hvis du er meget opmærksom, bemærker du måske, at ovenstående svar er ni cifre langt, mens hver af de foregående kun har været otte. Hvis du husker tilbage til, da vi introducerede begrebet modulær addition, nævnte vi, at det er ligesom almindelig addition, men det ruller bare tilbage til starten, når tallene kommer forbi et bestemt punkt.

Nå, den lommeregner, vi har brugt, er ikke specifikt til modulær addition - den udfører bare den normale addition, du lærte i folkeskolen (men med hexadecimale tal). Det betyder, at det ikke vil rulle tallene over, når det når grænsen. Indtil dette tidspunkt har vi bare været heldige, at ingen af ​​vores tidligere beregninger førte til et ni-cifret tal.

Denne gang er vi endt på ni cifre, hvor vi virkelig har brug for, at det kun er otte. Den gode nyhed er, at det er nemt at løse vores problem. Alt, hvad vi skal gøre, er at fjerne cifferet længst til venstre, nemlig1. Derfor er vores svar ikke rigtig108909ae5. I stedet er det:

08909ae5

Hvis du vender tilbage til diagrammet og sporer den linje, der forlader denne+boks som udgang, vil du se, at den forbinder med en anden linje, der indeholder input, som vi ikke har behandlet endnu.Vi bliver nødt til at lave nogle andre beregninger, før vi kan vende tilbage til dette punkt.

Den betingede funktion

Denne gang, lad os se på H_(i)e, H_(hvis, H_{(i) g}i diagrammet. De peger alle på kassemærketCh, hvilket angiver, at disse værdier fungerer som input i følgende funktion:

Ch(e, f, g) = (e OG f) ⊕ (IKKE e OG g)

Vi har allerede behandlet hver af disse operationer undtagenIKKE. Dette repræsenterer negation , som også er kendt som det logiske komplement. Vi vil ikke gå i detaljer om, hvordan det virker for at redde os fra at gå for meget på en tangent, men du kan enten henvise til linket eller stole på online-beregneren.

Endnu en gang har vi fjernet H_(jeg)fra e, f og g, simpelthen for at gøre det nemmere at læse. Vi arbejder stadig på runde 0, så disse værdier vil være initialiseringsvariablerne, som vi listede tidligere:

H_{(0) og}–510e527f

H_(0)f–9b05688c

H_(0)g–1f83d9ab

Bemærk, at i fremtidige runder vil variablerne for e, f og g være forskellige. For nu, lad os sætte disse initialiseringsvariabler ind i vores ligning:

Ch (510e527f, 9b05688c, 1f83d9ab) = (510e527f OG 9b05688c) ⊕ (IKKE 510e527f OG 1f83d9ab)

Vi bliver nødt til at dele denne ligning op i dele for at fuldende den med vores lommeregner . For første halvleg:

Gå ind510e527fi inputEN.

VælgOGfra rullelisten nedenfor.

Gå ind9b05688ci inputB.

Dette burde give dig et svar på:

1104400C

For anden halvdel af ligningen:

VælgIkkeknappen til venstre for inputEN.

Indtast 510e527f i inputEN.

VælgOGfra rullelisten nedenfor.

Indtast 1f83d9ab i inputB.

Dette skulle give dig et resultat af:

E818980

Lad os sætte disse svar tilbage i ligningen:

Ch(510e527f, 9b05688c, 1f83d9ab) = (1104400C) ⊕ (E818980)

Afslut at løse det ved at:

Sørger for detIKKEer ikke længere valgt.

Gå ind1104400Ci inputEN.

VælgGRATISfra rullelisten nedenfor.

Gå indE818980i inputB.

Dette burde give dig et svar på:

Ch(e, f, g) = 1F85C98C

∑₁: Cirkulært højreskift

SHA-2-beregningerne involveret i en enkelt runde.

Hvis du vender tilbage til diagrammet, vil du se, at H_(i)e, er ikke kun et input tilChligning, som vi lige har udført.Det bliver også et input til en anden boks markeret med en ∑. Denne boks angiver følgende beregning:

∑₁(e) = ROTR⁶(og) ⊕ R.O.T.R.^elleve(og) ⊕ R.O.T.R.²⁵(og)

Bemærk at dette∑₁(og)funktionen er næsten den samme som∑₀(en)funktion, som vi udførte iDen ∑₀operationafsnit. De to har dog forskellige værdier for de cirkulære højreskift.

Vi har udeladt H_(jeg)dele af ligningen endnu en gang for overskuelighedens skyld. Lad os tilslutteH_{(0) og}værdi forogværdier, for vi arbejder stadig påRunde 0. Som vi diskuterede iInitialiseringsvariablerneafsnit, værdien forH_{(0) og}er510e527f. Derfor:

∑₁(510e527f) = ROTR⁶(510e527f) ⊕ R.O.T.R.^elleve(510e527f) ⊕ R.O.T.R.²⁵(510e527f)

Vi har forklaret, hvordan disse højre cirkulære skift fungerer flere gange, så lad os gå til vores online lommeregner og indtast:

510e527f indVærdiSikrehexadecimalvælges fra rullemenuen til højre.

32 indStørrelse.

6 indFlytte.

Sørge for atHøjreer valgt tilRetning.

Klik påCirkulært skiftboks.

Klik påUdfør bitskiftknap.

Dette burde give os et svar på:

FD443949

Hold alle detaljer de samme, bortset fra at ændreFlytteværdi tilelleveog klik påUdfør bitskiftknappen endnu en gang. Dette burde give dig et svar på:

4FEA21CA

Gentag processen, denne gang skal du bare ændreFlytteværdi til 25. Vores svar bør være:

87293FA8

Nu har vi hvert af de resultater, vi skal bruge for at løse ligningen. Lad os sætte hver af de værdier, vi lige har fundet ud af, i formlen:

∑₁(510e527f) = FD443949⊕ 4FEA21CA⊕ 87293FA8

Lad os nu løse det ved at vende tilbage til vores lommeregner for XOR operationer:

Gå ind FD443949 i inputEN.

VælgGRATISfra rullelisten nedenfor.

Gå ind 4FEA21CA i inputB.

VælgGRATISfra rullelisten nedenfor.

Gå ind87293FA8i inputC.

Dette giver os et resultat af:

∑₁(510e527f) = 3587272B

Modulær tilføjelse

Lad os gå tilbage til diagrammet for at se, hvor vi skal gå videre:

SHA-2-beregningerne involveret i en enkelt runde.

Hvis vi ser øverst til højre, vil vi se, at arbejdsvariablen H_(i)hhar en pil, der fører til en kasse med enplustegnpå det. Outputtet fraChoperation, som vi allerede har gennemført, fører til den samme boks, hvilket betyder, at vi skal udføre modulær addition med disse to værdier. Vi er stadig midt i runde 0, så vi skal bruge initialiseringsvariablen H_(0)t, som vores værdi forh. Som vi diskuterede iInitialiseringsvariablenafsnit.

H_(0)t= 5be0cd19

Svaret på Ch-operationen var:

Ch(e, f, g) = 1F85C98C

Derfor skal vi finde en løsning på:

5be0cd19+1F85C98C

Lad os gå til vores online lommeregner til hexadecimal addition.

Gå ind5be0cd19ind i det første felt, og1F85C98Cind i det andet felt, og klik derefter på beregn. Dette giver os et resultat af:

7b6696a5

Mere modulær tilføjelse

Hvis du sporer pilen, der peger ud af denne boks med+symbol, vil du se, at det bliver et input til en anden lignende boks, hvilket indikerer mere modulær tilføjelse. Denne gang er det andet input resultatet, vi fik fra at udføre de cirkulære højre lort på ∑₁e) i den sidste∑₁: Cirkulært højreskiftafsnit. Svaret var:

∑₁(510e527f) = 3587272B

Så lad os tage resultatet fra det sidste afsnit og tilføje det til resultatet af∑₁(og). Ligningen er:

7b6696a5+3587272B

Gå til online lommeregner som vi lige brugte i forrige afsnit, og indtast7b6696a5ind i det første felt, og3587272Bind i det andet felt, og klik derefter på beregn. Dette giver os et resultat af:

b0edbdd0

Tilføjelse af W-værdien... med endnu mere modulær tilføjelse

Hvis du konsulterer diagrammet igen, vil du se, at outputtet fra den foregående operation går ind i en anden afmodulære tillægskasserangivet af+skilt. Denne gang føjes det til en af ​​W-værdierne, som er dele af vores polstrede besked, 'hashing er kompliceret' (i tilfælde af værdierne W₁₆-I₆₃, er de afledt af den polstrede meddelelse i stedet for at være dele af den).

Vi er stadig medRunde 0, så vi skal brugeI₀, som, som vi diskuterede iKonvertering til hexadecimalafsnit mod starten, er:

I₀– 68617368

Hvis vi tilføjer dette til en modulær additionsligning sammen med løsningen fra vores sidste afsnit, får vi:

68617368+b0edbdd0

Vend tilbage til det samme online lommeregner til tilføjelse af hexadecimale tal og input68617368ind i det første felt,derefter b0edbdd0ind i den anden. KlikBeregn, som vil give dig et svar på:

1194f3138

Som vi bemærkede iModulær tilføjelse af resultaternesektion, når et af vores resultater når ni cifre i længden i stedet for otte, skal vi rulle det tilbage ved blot at fjerne det længst til venstre,1. Derfor er det resultat, vi har brug for, faktisk ikke1194f3138. I stedet er det:

194f3138

Tilføjelse af den konstante K... gennem den altid pålidelige modulære tilføjelse

Med ovenstående svar i hånden peger output fra boksen på en anden, der har+ symbol, hvilket indikerer modulær tilføjelse endnu en gang. Denne gang siger den anden pil, der peger mod den, K_jeg, hvilket betyder, at nu er det tid til at tilføje konstanten K. Vi listede hver af de 64 værdier for K iKonstanten, Kafsnit. Den værdi, vi har brug for til den første runde, K₀er:

428a2f98

Så vores modulære additionsoperation skal inkludere denne værdi plus resultatet fra den foregående runde:

428a2f98+194f3138

Nu skal vi tilbage til vores online lommeregner for hexadecimal addition og enter428a2f98ind i det første felt, med194f3138i den anden. KlikkerBeregngiver os et resultat af:

5bd960d0

Den modulære tilføjelse slutter aldrig

Vend tilbage til diagrammet og følg outputtet fra den foregående operation. Den møder endnu en frygtet modulær additionsboks, denne gang med værdien H_(i)dsom sit andet input. Vi er stadig i runde 0, så vi skal bruge initialiseringsvariablen H_(0)d, som er:

a54ff53a

Derfor skal vi finde svaret på:

a54ff53a+5bd960d0

Når vi sætter disse værdier ind i det samme online lommeregner , vi ender med:

10129560a

Endnu en gang er vi løbet ind i ni cifre, så vi skal simpelthen slippe det længst til venstre1, som diskuteret iModulær tilføjelse af resultaterneafsnit. Derfor er vores svar i virkeligheden:

0129560a

Hvor kommer arbejdsvariablerne fra?

Hvis du følger linjen ud af +-symbolboksen, vil du se, at den ender i en række af kasser nederst, med netop denne boks markeretH_(i)e. Det har vi nævntRunde 0 starter med initialiseringsvariabler, men detde følgende runder bruger i stedet forskellige variabler.

Du har måske undret dig over, hvor disse skulle komme fra, og nu har du i det mindste en del af svaret.Værdierne i denne række af kasser nederst bliver de arbejdsvariabler, der bruges i næste runde.

I dette tilfælde initialiseringsvariablenH_(0)dblev føjet til, hvad der i det væsentlige er en blanding af de andre initialiseringsvariable H_{(0) og}, H_(0)f, H_(0)g, og H_(0)t, sammen med en del af vores inputmeddelelse, W_0,og konstanten, K₀. Den resulterende blanding,0129560a, bliver så arbejdsvariablenH_{(1 og}til runde 1.

De andre initialiseringsvariabler følger lignende processer, bliver modificeret og tilføjet til hinanden på mærkelige måder for at blive til nye arbejdsvariabler i næste runde. Du kan se på pilene, der peger mod den nederste række for at se, hvor hver af den næste rundes arbejdsvariable kommer fra.

Dette virker måske ikke så vigtigt, men det er en nøglekomponent i strukturen, der gør det muligt for hver SHA-2-hash at se radikalt anderledes ud, selv når kun et enkelt bogstav i inputtet ændres. Husk, vi er stadig kun en del af vejen gennem runde 0, og der er 63 flere runder tilbage, så der er meget større mulighed for at blande disse værdier.

Forener begge sider... med mere modulær tilføjelse

Husk tilbage tilModulær tilføjelse af resultaternesektion, hvor vi udførte modulær addition på følgende værdier:

Maj(a,b,c) + ∑₀(a) =08909ae5

Efter at vi havde fundet løsningen, måtte vi holde pause på den tråd i diagrammet, mens vi fandt ud af de andre komponenter. Nu har vi gjort alt, hvad vi skal gøre, og vi er klar til at gå tilbage til det.

Bare for at sikre, at du følger med, er vi i øjeblikket klden nederste + boks i venstre side af diagrammet, som er ført ind i af den ovenfor diskuterede ligning. Vores andet input i denne modulære additionsligning er løsningen fraDen modulære tilføjelse slutter aldrigafsnit, som var:

0129560a

Derfor forsøger vi at finde en løsning på:

08909ae5+0129560a

Lad os gå tilbage til vores online lommeregner og skriv ind08909ae5ind i det første felt, med0129560ai den anden. Når vi rammerBeregn, det giver os:

9b9f0ef

Vi kan tilføje et nul foran for at holde det konsistent med 8 cifre:

09b9f0ef

Dette svar bliver derefter placeret i H_(i)aspalte i nederste række, hvilket betyder, atdet bliver arbejdsvariablen H_(1)ai næste runde, runde 1.

Nu hvor vi har denne løsning, er vi endelig færdige med alle de mange beregninger, der er involveret iRunde 0.

De andre arbejdsvariabler

Vi har allerede diskuteret arbejdsvariablenH_(i)e, og nu arbejdsvariablenH_(i)a såvel. Nu er det tid til at dække, hvor resten af ​​arbejdsvariablerne kommer fra, så vi kan bruge dem i runde 1 og hver af de efterfølgende runder.

Som vi diskuterede, i runde 0, var arbejdsvariablerne et sæt foruddefinerede tal, som vi kaldte initialiseringsvariablerne:

• H_(0)a= 6a09e667
• H_(0)b= bb67ae85
• H_(0)c= 3c6ef372
• H_(0)d= a54ff53a
• H_{(0) og}= 510e527f
• H_(0)f= 9b05688c
• H_(0)g= 1f83d9ab
• H_(0)t= 5be0cd19

Nu er det tid til at finde ud af, hvad resten af ​​disse arbejdsvariabler vil være til starten af ​​runde 1. Heldigvis gør diagrammet det ret nemt:

SHA-2-beregningerne involveret i en enkelt runde.

Hvis vi ser på den nederste række, hvor der stårH_(i)b, kan vi spore pilen tilbage for at se, at værdien er simpelH_(i)a. SomH_(0)aer6a09e667, betyder det, at vores arbejdsvariabel for runde 1,H_(1)b, vil også være6a09e667.

Går med tilH_(i)ci nederste række ser vi, at pilen stammer fraH_(i)bboks i øverste række. DerforH_(0)bværdi,bb67ae85, bliver arbejdsvariablenH_(1)ci runde 1.

Når vi vender os tilH_(i)di nederste række ser vi, at pilen forbinder det medH_(i)cpå toppen. Derfor,H_(1)der den samme værdi somH_(0)c, som er3c6ef372.

Bevæger dig med, pilen for bundenH_(i)ekommer fra den modulære tilføjelse afH_(i)dog det resultat, som vi fik, da vi tilføjede konsonanten. Vi fandt ud af denne værdi iDen modulære tilføjelse slutter aldrigafsnit, derfor værdien forH_{(1 og}er0129560a.

Værdierne forH_(hvis,H_{(i) g}ogH_(i)her ligetil at finde ud af. Følger vi pilene fra disse værdier i nederste række, ser vi at pilene stammer fraH_(i)e,H_(hvisogH_{(i) g}, henholdsvis.

Derfor:

H_{(0) og}, som var 510e527f, bliverH_(1)f.

H_(0)f, som var 9b05688c, bliverH_(1)g.

H_(0)g, som var 1f83d9ab, bliverH_(1)h.

Bare for at opsummere er arbejdsvariablerne, som vi vil bruge som nogle af vores input til runde 1:

• H_(1)a= 09b9f0ef
• H_(1)b= 6a09e667
• H_(1)c= bb67ae85
• H_(1)d= 3c6ef372
• H_{(1 og}= 0129560a
• H_(1)f= 510e527f
• H_(1)g= 9b05688c
• H_(1)h= 1f83d9ab

Runde 1 (og efterfølgende runder)

Vi har afsluttet runde 0, og vi ved, hvad arbejdsvariablerne er for runde 1. Hvis du henviser tilbage tilKonvertering til hexadecimalsektion, kender vi også den W-værdi, vi skal bruge i runde 1:

I₁= 346E6720

Du kan også finde den K-værdi, vi har brug for iKonstanten, K, afsnit. Denne gang skal vi bruge værdien i den anden kolonne i den øverste række:

K₁=71374491

Vi har nu alle de oplysninger, vi behøver for at begynde runde 1. Lad os først henvise tilbage til diagrammet over hele algoritmen:

SHA-2-algoritmen

Hvis vi følger pilene, der kommer ud af bunden afRunde 0, vil du se, at de peger indrunde t. Runde t har også input af W_tog K_t.runde ter blot en stand-in for hver af de 62 mellemrumRunde 0ogRunde 63, fordi det ville have været upraktisk at trække 64 runder.

Forestil dig i stedet, at pilene fra runde 0 virkelig er på vej mod runde 1, og at de andre input virkelig er W₁og K₁.

Lad os nu henvise tilbage til diagrammet for en enkelt runde af SHA-2:

SHA-2-beregningerne involveret i en enkelt runde.

Som angivet af de to diagrammer, for at fuldføre runde 1, skal vi blot gentage hver af de operationer, vi udførte i runde 0. Den eneste forskel er, at vi starter med forskellige værdier. I stedet for W₀vi bruger W₁. I stedet for K₀vi bruger K₁. I stedet for alle H₀initialiseringsvariabler, bruger vi H₁arbejdsvariabler. Vi har lige listet hver af disse inputs, som vi skal bruge for at begynde runde 1, så du har alle de oplysninger, du behøver for at komme i gang.

Dit første skridt er at finde ud afMaj (a,b,c). Denne gang skal du bruge den nyeRunde 1input af:

• H_(1)a= 09b9f0ef
• H_(1)b= 6a09e667
• H_(1)c= bb67ae85

Vi beskrev processen iMaj operationenafsnit. Det involverede både AND-operationer og XOR-operationer, og vi gennemførte det gennem en række trin ved hjælp af online-beregnerne. Når du har gentaget processen med de nye inputværdier, kan du finde ud af, hvad du skal gøre ved enten at vende tilbage til diagrammet eller tilDen ∑₀operationafsnit i vores artikel.

I dette afsnit udførte vi en række cirkulære højreskift samt XOR-operationer. Denne gang skal du bruge den nye-enværdi, H_(1)a, som er:

09b9f0ef

Resten af ​​operationerne er de samme, inklusive antallet af bits, du skal skifte. Når du har resultatet, er det tid til at gå videre til næste trin, som du kan finde ved enten at konsultere diagrammet eller henvise tilbage gennem artiklen. Når du har dette resultat, skal du fortsætte med at skubbe fremad, hver gang du udfører de samme handlinger, men med de nye inputværdier, hvor det er relevant.

Som en opsummering,for at gennemføre runde 1, skal du have:

• UdførteMaj operation.
• Gennemførte∑₀operation.
• Brugte modulær tilføjelse på disse to tidligere resultater.

Derefter:

• Gennemførtebetinget funktion.
• Færdig med∑₁operation.
• Udført modulær addition på resultatet af den betingede funktion og værdien for H_(1)h
• Taget resultatet af det sidste trin og føjet det til resultatet af ∑₁drift gennem modulær addition
• Føjede dette resultat til W₁gennem modulær tilføjelse
• Brugte modulær tilføjelse til at tage resultatet fra det sidste trin og tilføje K₁
• Føjede resultatet fra det foregående trin til H_(1)dmed modulopbygning

Ved at følge disse trin skal du:

• Tag det resultat, du fik, da du tilføjede K₁(for to trin siden), og føj det til den løsning, du fik ved at bruge modulær tilføjelse til at kombinere resultaterne afMaj operationog∑₀operation(du fik dette svar i det tredje trin, nederst i det første sæt punktopstillinger)
• Brug diagrammet og vores beskrivelser iDe andre arbejdsvariablersektion for at finde ud af, hvilke værdier der bliver til H_(to)arbejdsvariabler, som du skal bruge til runde 2

Når du er på dette tidspunkt, er det tid for digstart runde 2, denne gang med H_(to)arbejdsvariabler, som du lige har fundet ud af sammen med W_toog K_to. Runde 2 fortsætter på nøjagtig samme måde, bortset fra at den bruger disse nye input, hvor det er relevant.

Når du er færdig med runde 2, har du de arbejdsvariable, du skal bruge til runde 3, og du skal bare bruge W₃og K₃værdier, som vi nævnte tidligere i artiklen for at fuldføre operationerne.

Denne proces gentages i runde 4 og 5 og så videre, hvor resultaterne bliver arbejdsvariablerne for næste runde. Den eneste komplikation kommer i runde 16, hvor du skal bruge W₁₆værdi, som vi allerede beregnede i den førsteModulær tilføjelseafsnit, som var i begyndelsen af ​​artiklen.

Opgaven bliver endnu mere kompleks for runde 17 til 63, fordi du selv skal beregne W-værdierne ved hjælp af metoden beskrevet ide andre W-værdierafsnit og efterfølgende dele af artiklen.

Forudsat at du overlever prøvelsen og formår at nå slutningen af ​​runde 63, vil du stå tilbage med otte H_(jeg)værdier som dine output fra hver af de beregninger, du gennemførte gennem hele runden.

Den sidste XOR

Hvis du vender tilbage til det overordnede diagram af SHA-2-funktionen, vil du se det sidste trin:

SHA-2-algoritmen

Du vil se, at udgangene fra runde 63, som er de otte endelige H-værdier, som du ville have fundet ud af på dette stadium, alle går ind i en række modulære additionsbokse. Disse felter har også andre inputpile, der sporer tilbage til H_(i-1). Dette betyder, at de andre input i hver af disse modulære additionsoperationer er initialiseringsvariablerne.

Derfor skal du gennemføre følgende modulære additionsberegninger:

• Finale H_-enværdi + H_(0)a= d6320dec
• Finale H_bværdi + H_(0)b= c80c83e4
• Finale H_cværdi + H_(0)c= c17915ee
• Finale H_dværdi + H_(0)d= 5de8587b
• Finale H_ogværdi + H_{(0) og}= b8118258
• Finale H_fværdi + H_(0)f= 759b2453
• Finale H_gværdi + H_(0)g= fce812d4
• Finale H_hværdi + H_(0)t= 7d3df56a

Der er kun én ting tilbage at gøre, som er at sammenkæde disse resultater. Dette er bare et fancy ord for at tilføje den ene til slutningen af ​​den anden i rækkefølge. Når du gør dette, vil du stå tilbage med:

d6320decc80c83e4c17915ee5de8587bb8118258759b2453fce812d47d3df56a

Ovenstående resultat er vores SHA-2-hash for 'hashing er kompliceret'.I diagrammet er dette repræsenteret vedH_jegpå bunden.

Større beskedinput

Hvis de indledende beskeddata havde været større end 448 bit, ville vi ikke være færdige endnu. Vi ville stadig skulle behandle hver af de resterende blokke, indtil hele inputdata var blevet cyklet gennem SHA-2-algoritmen.

Hvis dette var tilfældet, ville vi ikke have sammenkædet vores endelige resultater for at danne hashen. I stedet for hver af disse otteH_jegværdier ville være blevet initialiseringsvariablerne for den næste blok.

Trinnene ville have forløbet meget som ovenfor, bortset fra at denne gang ville vores første 16 W-værdier have været dele af den anden blok af inputdata. De næste 48 W-værdier ville være blevet afledt af disse 16 værdier i henhold til den formel, vi brugte imeddelelsesplan: finde de andre W-værdierafsnit.

Hvis der kun er to blokke af inputdata i alt, der skal behandles, så tilføjes de endelige H-værdier efter runde 63 af den anden blok til den anden bloks initialiseringsvariable på samme måde, som vi lige har demonstreret for den første blok . Disse resultater ville derefter blive sammenkædet for at danne SHA-2-hashen.

Hvis der er flere blokke, ville runde 63-output fra den anden blok i stedet blive initialiseringsvariablerne for den tredje blok. Denne proces vil fortsætte, indtil alle blokkene af inputdata er blevet behandlet. De otte output fra den sidste blok ville derefter blive sammenkædet i SHA-2-hashen på samme måde, som vi beregnede hashen for en enkelt blok af inputdata.