HMAC

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 31 augusti 2017; kontroller kräver 38 redigeringar .

HMAC ( ibland står för hash-baserad meddelandeautentiseringskod , meddelandeautentiseringskod med hashfunktioner , eller som engelsk keyed-hash meddelandeautentiseringskod , meddelandeautentiseringskod som använder hashfunktioner med en nyckel) — inom datavetenskap ( kryptering ) , en av de mekanismer för att kontrollera informationens integritet för att säkerställa att data som överförs eller lagras i en opålitlig miljö inte har ändrats av obehöriga personer (se mannen i mitten ). HMAC-mekanismen använder impersonation insertion (MAC) , som beskrivs i RFC 2104 , i standarderna för organisationer ANSI , IETF , ISO och NIST . MAC är en standard som beskriver hur man utbyter data och hur man kontrollerar integriteten hos överförda data med hjälp av en hemlig nyckel. Två klienter som använder en MAC delar vanligtvis en delad hemlighet. HMAC - tillägg över MAC; mekanism för att utbyta data med hjälp av en hemlig nyckel (som i MAC) och hash-funktioner . Namnet kan specificera hashfunktionen som används [1] : HMAC- MD5 , HMAC- SHA1 , HMAC -RIPEMD128 , HMAC - RIPEMD160 , etc.

Historik

uppmärksammats[ av vem? ] att hashfunktioner (t.ex. MD5 , SHA-1 , RIPEMD128 , RIPEMD-160 ) vanligtvis är snabbare än symmetriska blockchiffer (t.ex. DES ). Det fanns en önskan om att använda hashfunktioner i MAC, och tillgången på färdiga bibliotek med implementeringar av olika hashfunktioner drev bara på denna idé.

Men det gick inte att använda vissa hash-funktioner i MAC. Till exempel kan MD5- hashfunktionen inte användas i en MAC, eftersom den bara tar ett argument - data (sträng, sekvens av byte) och inte använder en hemlig nyckel.

I juni 1996 [2] Hugo Krawczyk ( eng. Hugo Krawczyk , anställd på IBM ), Mihir Bellar ( eng. Mihir Bellare , anställd vid University of California i San Diego (UCSD) ) och Ran Cannetti ( eng. Ran Canetti , en IBM- anställd ) publicerade en beskrivning av HMAC-mekanismen, och i februari 1997 släppte de också RFC 2104 . I HMAC "blandades" data med nyckeln och hashfunktionen användes två gånger.

Andra mekanismer har föreslagits för att tillåta samtidig användning av data och en hemlig nyckel i befintliga hashalgoritmer, men HMAC har fått mest stöd. .

Fördelar med HMAC:

möjligheten att använda hashfunktioner som redan finns i mjukvaruprodukten;
inget behov av att göra ändringar i implementeringen av befintliga hashfunktioner (att göra ändringar kan leda till prestandaförsämring och försämring av kryptografisk styrka);
möjligheten att ersätta hashfunktionen om en säkrare eller snabbare hashfunktion blir tillgänglig.

HMAC-mekanismen har beskrivits i ANSI- , IETF- , ISO- och NIST- organisationernas standarder .

Applikation

Implementeringen av HMAC är obligatorisk ( eng. obligatorisk att implementera ) för protokollet IPsec .

HMAC används också i andra Internetprotokoll , såsom TLS .

Beskrivning av algoritmen

Notation

b, block_size— Blockstorlek i byte ;
H, hash- hashfunktion;
ipad- ett block av formen ( 0x36 0x36 0x36 ... 0x36 ), där byten 0x36upprepas ben gång; 0x36är en konstant, ett magiskt tal som ges i RFC 2104 ; "i" från "inre" [1] ;
K, key— hemlig nyckel (gemensam för avsändare och mottagare);
K0- ändrad nyckel K(minskad eller ökad till blockstorleken (till bbyte));
L— storlek i byte av strängen som returneras av hashfunktionen H; Lberor på den valda hashfunktionen och är vanligtvis mindre än blockstorleken;

hash-funktion H	b, byte	L, byte
MD5	64	16
SHA-1	64	tjugo
SHA-224	64	28
SHA-256	64	32
SHA-512/224	128	28
SHA-512/256	128	32
SHA-384	128	48
SHA-512	128	64
SHA3-224	144	28
SHA3-256	136	32
SHA3-384	104	48
SHA3-512	72	64
out = H( in ) b = length( in ) L = length( out )

opad- ett block av formen ( 0x5c 0x5c 0x5c ... 0x5c), där byten 0x5cupprepas ben gång; 0x5cär en konstant, ett magiskt tal som ges i RFC 2104 ; "o" från "yttre" [1] ;
text- ett meddelande (data) som kommer att överföras av avsändaren och vars äkthet kommer att verifieras av mottagaren;
när meddelandets längd texti bitar .

HMAC-algoritmen kan skrivas som en enkel formel [1] : där: $\operatörsnamn {HMAC} _{K}(text)=\operatörsnamn {H} {\Bigg (}(K_{0}\oplus opad)\|\operatörsnamn {H} {\Big (}(K_{ 0}\oplus ipad)\|text{\Big )}{\Bigg )},$

" " - operationen "bitvis XOR " eller "xor"; $\ plus$
" " - operationen " limning av strängar" (sekvenser av byte). $\|$

Schemat för HMAC-algoritmen visas i figurerna.

Stegen för HMAC-algoritmen listas nedan.

Få genom att minska eller öka nyckeln till blockstorleken (upp till byte).K0Kb

1.1. Om nyckellängden är Klika med blockstorleken, kopiera sedan Ktill utan ändringar och gå till steg 2.K0 OM längd( K ) == b DÅ : K_0 = K END_IF 1.2. Om nyckellängden är Kstörre än blockstorleken så Ktillämpar vi hash-funktionen på nyckeln H, får en Lsträng i bytestorlek, lägger till nollor till höger om denna sträng för att skapa en sträng i bbytestorlek, kopierar resultatet till och gå till steg 2.K0 OM längd( K ) > b DÅ : x = H( K ) // längd( x ) == L K_0 = nollor( x, b - L ) END_IF 1.3. Om nyckellängden är Kmindre än blockstorleken, lägg sedan till nollor till höger Kför att skapa en bsträng i bytestorlek, kopiera resultatet till (till exempel if (i byte) och (i byte), sedan nollbyte ( ) kommer att läggas till på höger sida ) och gå till steg 2.K0length( К ) = 20b = 64К64 - 20 = 440x00 OM längd( K ) < b DÅ : K_0 = nollor( K, b - längd( K ) ) END_IF

Få ett block i bytestorlek med hjälp av den bitvisa XOR- operationen ("xor", " " ):Sib $\ plus$

S i = xor( K 0 , ipad ) = K 0 ipad.

\ plus

Få ett block i bytestorlek med hjälp av den bitvisa XOR- operationen :Sob

So = xor( Ko , opad ) = Ko opad .

\ plus

Dela upp ett meddelande (data, uppsättning byte) texti block med storleksbyte b.
Limma en sträng (sekvens av byte) med varje meddelandeblock .SiМ
Använd hash-funktionen på strängen som erhölls i föregående steg Н.
Slå samman strängen med strängen som erhölls från hashfunktionen i föregående steg.SoH
Använd hash-funktionen på strängen som erhölls i föregående steg Н.

Nycklar som är mindre än Lbyte anses vara [1] osäkra ( eng. starkt avrådd ). Det rekommenderas [1] att välja nycklar slumpmässigt och ändra dem regelbundet. Nycklar som är större än Lbyte, ökar inte [1] funktionens styrka avsevärt, kan användas om det finns tvivel om slumpmässigheten hos de data som används för att skapa nyckeln och som tas emot från slumptalsgeneratorn.

Nyckelstorleken Кmåste vara större än eller lika med L/2byte .

Figuren visar en mer effektiv [ förfina ] implementering av HMAC-MD5-algoritmen. Implementeringen skiljer sig åt i användningen av F. Denna implementering är användbar om de flesta meddelanden som MAC beräknas för är korta. Funktion F− Kompressionsfunktionen för hashfunktionen H. FDet tar en variabel noch ett bbyte -längdblock som argument . Fdelar upp blocket i en kedja av länkar med längden på varje länk i nbyte. Funktionen Fanropas en gång för varje ny knapp.

Pseudokod

Följande är ett exempel på implementering av HMAC i pseudokod :

FUNCTION hmac( key, msg ) : // Om nyckelstorleken är större än blockstorleken ... IF length( key ) > block_size DÅ : // Förkorta nyckeln till storleken på hashfunktionsresultatet nyckel = hash(nyckel) // (Storleken på hashresultatet är vanligtvis mindre än (inte lika med) hashblockstorleken) END_IF // Om nyckeln är mindre än hashblockstorleken ... IF length( key ) < block_size THEN : // Att komplettera nyckeln med en nollsekvens nyckel = nyckel ∥ nollor( block_size - length( key )) // operatorn "∥" utför sammanslagna strängar (sekvenser av byte) END_IF ipad = [ '\x36' * block_size ] // operatorn "*" indikerar antalet repetitioner av en sekvens av byte, // och block_size - storleken på hashfunktionsblocket, opad = [ '\x5c' * block_size ] ikeypad = ipad ⊕-tangent // operatorn "⊕" utför bitvis exklusiv OR (xor) knappsats = opad ⊕ tangent RETURN hash( okeypad ∥ hash( ikeypad ∥ msg ) ) // Operatör "∥" skarvar strängar END_FUNCTION

Kodexempel

Ett exempel på implementeringen av HMAC-MD5-algoritmen med funktionerna i Python -standardbiblioteket [3] :

import hmac , hashlib print ( hmac . new ( key = b 'secret_shared_key' , msg = open ( 'message.txt' , 'rb' ) . read (), digestmod = hashlib . md5 ) . hexdigest ())

En av de möjliga implementeringarna av HMAC-MD5-algoritmen i PHP [4] :

funktion hmac ( $key , $data ) { $b = 64 ; // blockstorlek enligt RFC 2104 if ( strlen ( $key ) > $ b ) { $key = pack ( "H*" , md5 ( $key ) ); } $key = str_pad ( $key , $b , chr ( 0x00 ) ); $ipad = str_pad ( '' , $b , chr ( 0x36 ) ); $opad = str_pad ( '' , $b , chr ( 0x5c ) ); $k_ipad = $nyckel ^ $ipad ; $k_opad = $nyckel ^ $opad ; returnera md5 ( $k_opad . pack ( "H*" , md5 ( $k_ipad . $data ) ) ); }

Exempel på arbete

Låt oss visa ett exempel på hur algoritmen fungerar för olika indata.

Den första parametern är en nyckel Kpå 160 bitar (20 byte). Den andra parametern är meddelandet textsom kommer att skickas av avsändaren och autentiseras av mottagaren. Vid utgången får vi en autentiseringskod på 160 bitar.

HMAC( K, text ) = HMAC( 00000000000000000000000000000000000000000, "" ) = 740ca4e7a701540b385df12fe57cff57 HMAC( K, text ) = HMAC( 00000000000000000000000000000000000000000, "Hej världen" ) = a0e026219366a56cf843bd2051831327 HMAC( K, text ) = HMAC( 00000000000000000000000000000000000000001, "1" ) = c6b1d8489a204918643086ce346b86bc

Låt oss ta en närmare titt på HMAC -SHA1- algoritmen med en 20-byte nyckel.

Vi har: ett textmeddelande text = "Hello World"och en 20-byte nyckel i hexadecimal formK = 0x707172737475767778797a7b7c7d7e7f80818283

Steg 1. Fyll nyckeln Kmed noll byte till storleken på blocket. Blockstorleken för en SHA-1- hashfunktion är 64 byte.

K0:
70717273 74757677 78797a7b 7c7d7e7f
80818283 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000

Steg 2. Vi utför den bitvisa XOR-operationen med konstanten 0x36.

K0 $\oplus$ ipad :
46474445 42434041 4e4f4c4d 4a4b4849
b6b7b4b5 36363636 36363636 36363636
36363636 36363636 36363636 36363636
36363636 36363636 36363636 36363636

Steg 3. Vi limmar det ursprungliga meddelandet med strängen som togs emot i steg 2.

( K $\oplus$ ipad ) || text :
46474445 42434041 4e4f4c4d 4a4b4849
b6b7b4b5 36363636 36363636 36363636
36363636 36363636 36363636 36363636
36363636 36363636 36363636 36363636
48656c6c 6f20576f 726c64

Steg 4. Använd SHA-1- hashfunktionen på strängen som erhölls i föregående steg.

H( ( K $\oplus$ ipad ) || text ) :
0d42b899 d804e19e bfd86fc4 4f414045 dfc9e39a

Steg 5. Utför den bitvisa XOR-operationen med konstanten 0x5c.

K0 $\oplus$ opad :
2c2d2e2f 28292a2b 24252627 20212223
dcdddedf 5c5c5c5c 5c5c5c5c 5c5c5c5c
5c5c5c5c 5c5c5c5c 5c5c5c5c 5c5c5c5c
5c5c5c5c 5c5c5c5c 5c5c5c5c 5c5c5c5c

Steg 6. Sammanfoga strängen som erhölls i steg 4 med strängen som erhölls i steg 5.

( K0 $\oplus$ opad ) || H( ( K $\oplus$ ipad ) || text ) :
2c2d2e2f 28292a2b 24252627 20212223
dcdddedf 5c5c5c5c 5c5c5c5c 5c5c5c5c
5c5c5c5c 5c5c5c5c 5c5c5c5c 5c5c5c5c
5c5c5c5c 5c5c5c5c 5c5c5c5c 5c5c5c5c
0d42b899 d804e19e bfd86fc4 4f414045
dfc9e39a

Steg 7. Använd SHA-1- hashfunktionen på strängen som erhölls i föregående steg.

HMAC( K, text ) = H( ( K0 $\oplus$ opad ) || H( ( K $\oplus$ ipad ) || text ) ) :
2e492768 aa339e32 a9280569 c5d02626 2b912431

Resultat. Vi har en sträng HMAC( K, text )på 20 byte.

Användningsproblem

Den resulterande autentiseringskoden låter dig verifiera att data inte har ändrats på något sätt sedan de skapades, överfördes eller lagrades av en pålitlig källa. För denna typ av verifiering är det till exempel nödvändigt att två parter som litar på varandra i förväg kommer överens om användningen av en hemlig nyckel som bara är känd för dem. Detta garanterar äktheten av källan och meddelandet. Nackdelen med detta tillvägagångssätt är uppenbart – det måste finnas två parter som litar på varandra.

Säkerhet

Säkerheten för alla MAC-funktioner baserade på inbyggda hashfunktioner beror på styrkan hos den underliggande hashfunktionen. Attraktionen med HMAC är att dess skapare kunde bevisa det exakta förhållandet mellan styrkan hos inbyggda hashfunktioner och styrkan hos HMAC.

Säkerheten för imitera insättningsfunktionen (MAC) uttrycks vanligtvis i termer av sannolikheten för en framgångsrik attack med mängden tid som spenderas på den, samt att ta emot ett par (meddelande - MAC) skapat med samma nyckel. I huvudsak är det bevisat i BELL96a att för en given ansträngningsnivå (tid, meddelande - MAC) på ett meddelande som genereras av en slutanvändare, är sannolikheten för en framgångsrik attack på en HMAC likvärdig med en attack på en inbyggd hashfunktion:

I den första typen av attack kan vi betrakta komprimeringsfunktionerna F som likvärdiga med en hashfunktion som appliceras på ett meddelande som består av ett enda block med längd B-bitar. För att göra detta är inmatningen av hashfunktionen ett slumpmässigt värde av längden N bitar. En attack på en hashfunktion kräver antingen en uttömmande sökning av nyckeln, som har en ordningskomplexitetsnivå på , eller en "födelsedagsattack" , som är ett specialfall av den andra attacken, som diskuteras nedan. $2^{{n}}$
I den andra typen av attack letar angriparen efter två meddelanden Мoch М', som hämtas från samma hashfunktion: H( M ) = H( M' ). Denna typ av attack är också känd som en födelsedagsattack . Svårighetsgraden för denna attack är för en hash av längd . Baserat på detta ifrågasätts säkerheten för MD5- hashfunktionen, eftersom komplexitetsnivån för den , som inte längre ser omöjlig ut med modern $2^{{n/2}}$ n $2^{64}$ [ när? ] teknologier. Betyder detta att en 128-bitars hashfunktion som MD5 inte är lämplig för HMAC? Svaret på denna fråga är nej, vilket kommer att följa av följande argument . När en angripare attackerar MD5 kan han välja vilken uppsättning meddelanden som helst och arbeta offline för att hitta kollisioner. Eftersom angriparen känner till hashalgoritmen och de initiala villkoren kan angriparen skapa en hashkod för vart och ett av meddelandena. Men när angriparen attackerar HMAC kommer angriparen inte att kunna generera ett par ("meddelande", "kod") i ett fjärrläge (offline), eftersom angriparen inte känner till nyckeln K. Alltså måste angriparen följa sekvensen av meddelanden som genereras av HMAC med samma nyckel och utföra en attack på dem. En hashkod på 128 bitar kräver block eller bitar som genereras med samma nyckel. För en 1 Gbit-anslutning skulle man behöva följa flödet av meddelanden, om nyckeln inte ändras, i 150 000 år för att lyckas. Om hastigheten är avgörande är det alltså helt acceptabelt att använda MD5 snarare än SHA-1 som de inbyggda hash-funktionerna för HMAC. $2^{64}$ $2^{{72}}$ K

Se även

Meddelandeautentiseringskod (MAC)
IPsec- protokoll
MD5 hashfunktion
RSA
SHA-1 hashfunktion
DES

Källor

Black W. Internetsäkerhetsprotokoll. Moskva: förlaget "Peter". 2001. ISBN 5-318-00002-9 (original engelska ISBN: ISBN 0-13-014249-2 ).
RFC 2104 . Krawczyk H., Bellare M., Canetti R. "HMAC: Keyed-hashing för meddelandeautentisering". februari 1997
Stallings W. Principer och metoder för kryptografi och nätverkssäkerhet. 2005. ISBN 0-13-187316-4 .

Anteckningar

↑ 1 2 3 4 5 6 7 Krawczyk H., Bellare M., Canetti R. "HMAC: Keyed-hashing för meddelandeautentisering". RFC 2104 Arkiverad 15 april 2021 på Wayback Machine . februari 1997
↑ Mihir Bellare, Ran Canetti och Hugo Krawczyk. Nyckelhash-funktioner för meddelandeautentisering. 1996. Ladda ner PDF Arkiverad 9 maj 2009 på Wayback Machine .
↑ implementering i Python (eng.) (nedlänk) . - källkod. Arkiverad från originalet den 4 juni 2012.
↑ PHP-implementering ( otillgänglig länk) . - källkod. Arkiverad från originalet den 4 juni 2012.

Länkar

HMAC (engelska) .
RFC 2104 . HMAC. februari 1997
RFC 4226 . M'Raihi D., Bellare M., Hoornaert F., Naccache D., Ranen O. " HOTP : en HMAC-baserad engångslösenordsalgoritm". december 2005
Generera HMAC Online . Online HMAC-generator.