Python Hmac

HMAC er en populær hashingmetode. Det oppnår dette ved å bruke en hemmelig kryptografisk nøkkel og en kryptografisk hasjfunksjon. Det kan brukes til å sikre gyldigheten og ektheten av data. I stedet for å stole på en offentlig nøkkelinfrastruktur med sertifikater, lar den oss beregne meldingens autentisitet og integritet ved å bruke en delt nøkkel mellom to parter.

HMAC -modulen i Python tilbyr oss en implementering for denne metoden. Den bruker formen av en hash -algoritme som en inngang, som er en av algoritmene som er nevnt i Pythons Hashlib -modul. Denne artikkelen vil vise deg hvordan du bygger meldingsgodkjenningskode med Pythons HMAC -modul ved hjelp av enkle eksempler.

Eksempel 1:

Dette er artikkelenes første eksempel. Meldingen og nøkkelen (merket som "MSGG" og Key_Val i koden vår) blir først initialisert i dette eksemplets kode. Den bruker deretter nøkkelen og SHA1 -algoritmen for å opprette en meldingsgodkjenningskode for den gitte meldingen på tre forskjellige måter.

Vi konstruerer først en forekomst av HMAC ved hjelp av den nye () metoden, og passerer den byte for nøkkelen og meldingen og "SHA1" for hash -algoritmen.

Den nye () metoden genererer en forekomst av HMAC med en byte-basert innledende melding. Den kan deretter brukes til å produsere kode for melding om melding. Uten startmeldingen kan vi bare bygge en forekomst av HMAC. Men vi vil kreve en nøkkel og "digestmod" for dette formålet.

En samtale til Update () -metoden kan brukes til å legge til meldinger. Nøkkelen må følge et BYTE -format. DigestMod -parameteren godtar navn på sikre hashingalgoritmer fra Hashlib -modulen.

Meldingsautentiseringskoden skrives deretter ut. HMAC -forekomsten opprettes uten noen startmelding i andre halvdel av koden. Etter det vil meldingen bli lagt til ved hjelp av oppdateringsmetoden () metoden. Update () -metoden legger til meldinger som er gitt inn som innspill til en melding som allerede eksisterer. Vi kan ringe denne metoden flere ganger, og den vil fortsette å samle meldinger.

Til slutt beregner og skriver den ut fordøyelsen. Koden i den tredje delen genererer en forekomst av HMAC uten innledende melding. Oppdateringsmetoden () brukes deretter til å legge til meldinger i to seksjoner. Til slutt beregner og skriver den ut fordøyelsen. Til slutt publiserer koden fordøyelsen og blokkeringsstørrelsene for hver HMAC -forekomst.

Digest () -metoden returnerer dataens meldingsgodkjenningskode. Koden er i byteformat. Utgangsstørrelsen bestemmes av inngangssikker hashingalgoritme. Hvis hashalgoritmen som brukes i inngangen er SHA1, vil utgangen være 20 byte. For din forståelse av konseptet har vi lagt ved et bilde av hele koden nedenfor.

Importer HMAC
MSGG = "Python er enkelt.""
key_val = "abcxyz"
hmac_one = hmac.Ny (Key = Key_val.encode (), msg = mssg.encode (), digestmod = "sha1")
Message_Digest_One = hmac_one.fordøye()
print (" - Melding Digest One: ".Format (HMAC_One.Navn, Message_Digest_one))
HMAC_TWO = HMAC.Ny (Key = Key_val.encode (), digestmod = "sha1")
hmac_two.OPPDATERING (BYTES (MSGG, CODING = "UTF-8"))
melding_digest_two = hmac_two.fordøye()
print (" - Melding fordøyelse to: ".Format (hmac_two.Navn, Message_Digest_two))
HMAC_THREE = HMAC.Ny (Key = Key_val.encode (), digestmod = "sha1")
hmac_three.OPPDATERING (Bytes ("Programmering er", Encoding = "UTF-8")))
hmac_three.OPPDATERING (Bytes ("Easy and Fun", Coding = "UTF-8"))
Message_Digest_three = hmac_three.fordøye()
PRINT (" - Melding Digest Three: ".Format (hmac_three.Navn, Message_Digest_Three))
print ("\ nMessage fordøyelsesstørrelse for 1: , 2: og 3: ".Format (HMAC_One.Digest_Size, HMAC_TWO.Digest_size, hmac_three.Digest_Size,))
print ("Meldingsblokkstørrelse for 1: , 2: og 3: ".Format (HMAC_One.Block_Size, HMAC_TWO.block_size, hmac_three.Block_Size,))

Her vises autentiseringsmeldingen og byte -størrelsen ved utførelse av den vedlagte koden.

Eksempel 2:

I vårt andre eksempel viser vi deg hvordan du konstruerer melding om godkjenningskoder ved hjelp av HMAC -teknikken en gang til, men denne gangen med SHA256 Secure Hashing Algorithm. Koden vår for denne delen er nesten identisk med den fra vårt tidligere eksempel, med noen få små forskjeller. Den benytter seg av Hashlib -bibliotekets referanse til SHA256 -algoritmen.

Importer HMAC
Importer hashlib
msg_one = "python er lett å lære.""
Key_one = "AABBCCXXYYZZ"
hmac_one = hmac.Ny (Key = Key_one.encode (), msg = msg_one.encode (), digestmod = hashlib.SHA256)
Message_Digest_One = hmac_one.fordøye()
print (" - Melding Digest One: ".Format (HMAC_One.Navn, Message_Digest_one))
HMAC_TWO = HMAC.Ny (Key = Key_one.encode (), digestmod = hashlib.SHA256)
hmac_two.OPPDATERING (byte (msg_one, koding = "UTF-8"))
melding_digest_two = hmac_two.fordøye()
print (" - Melding fordøyelse to: ".Format (hmac_two.Navn, Message_Digest_two))
HMAC_THREE = HMAC.Ny (Key = Key_one.encode (), digestmod = hashlib.SHA256)
hmac_three.OPPDATERING (Bytes ("Learn", Coding = "UTF-8"))
hmac_three.OPPDATERING (Bytes ("Python", Encoding = "UTF-8")))
Message_Digest_three = hmac_three.fordøye()
PRINT (" - Melding Digest Three: ".Format (hmac_three.Navn, Message_Digest_Three))
print ("\ nMessage fordøyelsesstørrelse for 1: , 2: og 3: ".Format (HMAC_One.Digest_Size, HMAC_TWO.Digest_size, hmac_three.Digest_Size,))
print ("Meldingsblokkstørrelse for 1: , 2: og 3: ".Format (HMAC_One.Block_Size, HMAC_TWO.block_size, hmac_three.Block_Size,))

Her er resultatet der du kan se at vi har beregnet meldingsgodkjenningskoden ved hjelp av HMAC -algoritmen og SHA256.

Eksempel 3:

I vårt tredje eksempel viser vi hvordan du konstruerer en HEX -meldingsautentiseringskode med HMAC -teknikken og SHA256 som backend. Dette eksemplets kode er identisk med den forrige, med unntak av at vi bruker Hexdigest () -teknikken for å beregne den heksadesimale autentiseringskoden.

Hexdigest -metoden returnerer data som heksadesimale sifre som en meldingsgodkjenningskode. Fordi en byte kan lage to heksadesimale sifre, er dette tilfelle.

Utgangsstørrelsen bestemmes av inngangssikker hashingalgoritme. Hvis SHA1 -inngangshashing -algoritmen brukes, for eksempel, vil den resulterende verdien være 40 heksadesimale sifre.

Importer HMAC
Importer hashlib
msg_one = "alt om python.""
Key_one = "AABBCCXYZ"
hmac_one = hmac.Ny (Key = Key_one.encode (), msg = msg_one.encode (), digestmod = hashlib.SHA512)
Message_Digest_One = hmac_one.Hexdigest ()
print (" - Hex Message Digest One: ".Format (HMAC_One.Navn, Message_Digest_one))
HMAC_TWO = HMAC.Ny (Key = Key_one.encode (), digestmod = hashlib.SHA512)
hmac_two.OPPDATERING (byte (msg_one, koding = "UTF-8"))
melding_digest_two = hmac_two.Hexdigest ()
print (" - Hex Message Digest Two: ".Format (hmac_two.Navn, Message_Digest_two))
HMAC_THREE = HMAC.Ny (Key = Key_one.encode (), digestmod = hashlib.SHA512)
hmac_three.OPPDATERING (Byte ("All About", Coding = "UTF-8"))
hmac_three.Oppdatering (byte ("Python Language.", koding =" utf-8 "))
Message_Digest_three = hmac_three.Hexdigest ()
print (" - Hex Message Digest Three: ".Format (hmac_three.Navn, Message_Digest_Three))
print ("\ nMessage fordøyelsesstørrelse for 1: , 2: og 3: ".Format (HMAC_One.Digest_Size, HMAC_TWO.Digest_size, hmac_three.Digest_Size,))
print ("Meldingsblokkstørrelse for 1: , 2: og 3: ".Format (HMAC_One.Block_Size, HMAC_TWO.block_size, hmac_three.Block_Size,))

Nedenfor er output -skjermbildet der du kan se at autentiseringsmeldingene og fordøyelsesstørrelsen og blokkeringsstørrelsen vises.

Eksempel 4:

Vi demonstrerer hvordan du produserer meldingsgodkjenningskode uten å etablere en forekomst av HMAC ved å bruke Digest () -metoden til HMAC -modulen. Digest (Key, MSG, Digest) - Det tar som en tast, en melding å kode, og Digest -algoritmen genererer en autentiseringskode for den oppgitte meldingen.

Denne koden viser hvordan du bruker Digest () -metoden for å konstruere en melding om godkjenningskode. Fordi den bruker en optimalisert C -implementering for å konstruere fordøyelsen, er denne metoden raskere enn å bruke HMAC for å lage autentiseringskoder for liten kommunikasjon.

Importer HMAC
Importer hashlib
MSGG = "Python -programmering"
key_one = "abcabcabc"
Message_Digest_One = HMAC.Digest (Key = Key_one.encode (), msg = mssg.encode (), digest = "sha3_256")
print ("Message Digest One: ".Format (Message_Digest_one))
melding_digest_two = hmac.Digest (Key = Key_one.encode (), msg = byte (msgg, koding = "utf-8"), digest = hashlib.SHA3_256)
PRINT ("Melding Digest Two: ".format (message_digest_two))

Her er resultatet som du kan se at meldingsgodkjenningskoden opprettes ved å bruke fordøye() metode.

Konklusjon:

HMAC er en kryptografisk hasjfunksjonsbasert meldingsautentiseringsteknikk. Den mye brukte HMAC -teknikken er diskutert i detalj i dette innlegget. Hovedideen med denne tilnærmingen er å bruke en delt hemmelig nøkkel for å kombinere en kryptografisk hasj av de faktiske dataene. Dette er for det eneste formål å lage en delt hemmelig nøkkel. Vi har gått gjennom denne ideen og gitt eksempler for å hjelpe deg med å forstå den.