Python HMAC

HMAC è un metodo di hashing del messaggio popolare. Realizza questo usando una chiave crittografica segreta e una funzione hash crittografica. Può essere utilizzato per garantire la validità e l'autenticità dei dati. Invece di fare affidamento su un'infrastruttura chiave pubblica con certificati, ci consente di calcolare l'autenticità dei messaggi e l'integrità utilizzando una chiave condivisa tra due parti.

Il modulo HMAC in Python ci offre un'implementazione per questo metodo. Usa la forma di un algoritmo di hashing come input, che è uno degli algoritmi menzionati nel modulo Hashlib di Python. Questo articolo ti mostrerà come creare il codice di autenticazione dei messaggi con il modulo HMAC di Python usando semplici esempi.

Esempio 1:

Questo è il primo esempio dell'articolo. Il messaggio e il tasto (contrassegnati come "msgg" e key_val nel nostro codice) sono inizializzati per la prima volta nel codice di questo esempio. Utilizza quindi la chiave e l'algoritmo SHA1 per creare un codice di autenticazione del messaggio per il messaggio dato in tre modi distinti.

Costruiamo prima un'istanza di HMAC usando il nuovo metodo (), passandolo byte per la chiave e il messaggio e "sha1" per l'algoritmo di hashing.

Il nuovo () metodo genera un'istanza di HMAC con un messaggio iniziale basato su byte. Può quindi essere utilizzato per produrre codice per l'autenticazione dei messaggi. Senza il messaggio iniziale, possiamo solo creare un'istanza di HMAC. Ma a questo scopo richiederemo una chiave e "digestmod".

Una chiamata al metodo update () può essere utilizzata per aggiungere messaggi. La chiave deve seguire un formato byte. Il parametro DigestMod accetta i nomi di algoritmi di hashing sicuri dal modulo Hashlib.

Viene quindi stampato il codice di autenticazione del messaggio. L'istanza HMAC viene creata senza alcun messaggio iniziale nella seconda metà del codice. Successivamente, il messaggio verrà aggiunto utilizzando il metodo Update (). Il metodo update () aggiunge i messaggi passati come input a un messaggio già esistente. Possiamo chiamare questo metodo più volte e continuerà ad accumulare messaggi.

Infine, calcola e stampa il digest. Il codice nella terza sezione genera un'istanza di HMAC senza messaggio iniziale. Il metodo update () viene quindi utilizzato per aggiungere messaggi in due sezioni. Infine, calcola e stampa il digest. Infine, il codice pubblica le dimensioni di digest e blocca per ogni istanza HMAC.

Il metodo Digest () restituisce il codice di autenticazione dei messaggi dei dati. Il codice è in formato bytes. La dimensione dell'uscita è determinata dall'algoritmo di hashing sicuro di ingresso. Se l'algoritmo di hashing utilizzato nell'ingresso è sha1, l'uscita sarà di 20 byte. Per la tua comprensione del concetto, abbiamo allegato un'immagine dell'intero codice di seguito.

Importa HMAC
msgg = "Python è facile."
key_val = "abcxyz"
hmac_one = hmac.new (key = key_val.encode (), msg = msgg.encode (), digestMod = "sha1")
Message_Digest_one = hmac_one.digerire()
Print (" - Message Digest One: ".Formato (hmac_one.nome, messaggio_digest_one))
hmac_two = hmac.new (key = key_val.encode (), digestMod = "sha1")
hmac_two.AGGIORNAMENTO (byte (msgg, codifica = "UTF-8")
message_digest_two = hmac_two.digerire()
print (" - Message Digest due: ".Formato (hmac_two.nome, messaggio_digest_two))
HMAC_THREE = HMAC.new (key = key_val.encode (), digestMod = "sha1")
HMAC_THREE.AGGIORNAMENTO (byte ("Programmazione è", codifica = "UTF-8"))
HMAC_THREE.AGGIORNAMENTO (byte ("facile e divertente", codifica = "UTF-8"))
Message_Digest_Three = hmac_three.digerire()
Print (" - Message Digest tre: ".Formato (HMAC_THREE.nome, messaggio_digest_three))
print ("\ nmessage digest dimensione per 1: , 2: e 3: ".Formato (hmac_one.digest_size, hmac_two.digest_size, hmac_three.digest_size,))
print ("dimensione del blocco dei messaggi per 1: , 2: e 3: ".Formato (hmac_one.block_size, hmac_two.block_size, hmac_three.misura del blocco,))

Qui, il messaggio di autenticazione e la dimensione del byte vengono visualizzati all'esecuzione del codice allegato.

Esempio 2:

Nel nostro secondo esempio, ti mostreremo come costruire i codici di autenticazione dei messaggi usando ancora una volta la tecnica HMAC, ma questa volta con l'algoritmo di hashing SHA256. Il nostro codice per questa sezione è quasi identico a quello del nostro esempio precedente, con alcune piccole differenze. Fa uso del riferimento della libreria di hashlib all'algoritmo SHA256.

Importa HMAC
Importa hashlib
msg_one = "Python è facile da imparare."
key_one = "AABBCCXXYYZZ"
hmac_one = hmac.new (key = key_one.encode (), msg = msg_one.ENCODE (), digestMod = hashlib.Sha256)
Message_Digest_one = hmac_one.digerire()
Print (" - Message Digest One: ".Formato (hmac_one.nome, messaggio_digest_one))
hmac_two = hmac.new (key = key_one.ENCODE (), digestMod = hashlib.Sha256)
hmac_two.AGGIORNAMENTO (byte (msg_one, encoding = "UTF-8"))
message_digest_two = hmac_two.digerire()
print (" - Message Digest due: ".Formato (hmac_two.nome, messaggio_digest_two))
HMAC_THREE = HMAC.new (key = key_one.ENCODE (), digestMod = hashlib.Sha256)
HMAC_THREE.AGGIORNAMENTO (byte ("apprendimento", codifica = "UTF-8"))
HMAC_THREE.AGGIORNAMENTO (bytes ("python", codifica = "UTF-8"))
Message_Digest_Three = hmac_three.digerire()
Print (" - Message Digest tre: ".Formato (HMAC_THREE.nome, messaggio_digest_three))
print ("\ nmessage digest dimensione per 1: , 2: e 3: ".Formato (hmac_one.digest_size, hmac_two.digest_size, hmac_three.digest_size,))
print ("dimensione del blocco dei messaggi per 1: , 2: e 3: ".Formato (hmac_one.block_size, hmac_two.block_size, hmac_three.misura del blocco,))

Ecco il risultato in cui è possibile vedere che abbiamo calcolato il codice di autenticazione del messaggio utilizzando l'algoritmo HMAC e SHA256.

Esempio 3:

Nel nostro terzo esempio, mostreremo come costruire un codice di autenticazione dei messaggi esagonali con la tecnica HMAC e SHA256 come backend. Il codice di questo esempio è identico a quello precedente, con l'eccezione che stiamo usando la tecnica HexDigest () per calcolare il codice di autenticazione esadecimale.

Il metodo hexdigest restituisce i dati come cifre esadecimali come codice di autenticazione del messaggio. Perché un byte può fare due cifre esadecimali, questo è il caso.

La dimensione dell'uscita è determinata dall'algoritmo di hashing sicuro di ingresso. Se viene utilizzato l'algoritmo di hashing di input sha1, ad esempio, il valore risultante sarà 40 cifre esadecimali.

Importa HMAC
Importa hashlib
msg_one = "All About Python."
key_one = "aaBBCCXYZ"
hmac_one = hmac.new (key = key_one.encode (), msg = msg_one.ENCODE (), digestMod = hashlib.Sha512)
Message_Digest_one = hmac_one.hexdigest ()
Print (" - Hex Message Digest One: ".Formato (hmac_one.nome, messaggio_digest_one))
hmac_two = hmac.new (key = key_one.ENCODE (), digestMod = hashlib.Sha512)
hmac_two.AGGIORNAMENTO (byte (msg_one, encoding = "UTF-8"))
message_digest_two = hmac_two.hexdigest ()
Print (" - Hex Message Digest due: ".Formato (hmac_two.nome, messaggio_digest_two))
HMAC_THREE = HMAC.new (key = key_one.ENCODE (), digestMod = hashlib.Sha512)
HMAC_THREE.AGGIORNAMENTO (bytes ("All About", codiing = "UTF-8"))
HMAC_THREE.Aggiornamento (byte ("Python Language.", codifica =" UTF-8 "))
Message_Digest_Three = hmac_three.hexdigest ()
Print (" - Hex Message Digest tre: ".Formato (HMAC_THREE.nome, messaggio_digest_three))
print ("\ nmessage digest dimensione per 1: , 2: e 3: ".Formato (hmac_one.digest_size, hmac_two.digest_size, hmac_three.digest_size,))
print ("dimensione del blocco dei messaggi per 1: , 2: e 3: ".Formato (hmac_one.block_size, hmac_two.block_size, hmac_three.misura del blocco,))

Di seguito è riportato lo screenshot di output in cui è possibile vedere che vengono visualizzati i messaggi di autenticazione e la dimensione del digest e le dimensioni del blocco.

Esempio 4:

Dimostriamo come produrre codice di autenticazione dei messaggi senza stabilire un'istanza dell'HMAC utilizzando il metodo digest () del modulo HMAC. digest (tasto, msg, digest) - impiega come input una chiave, un messaggio da codificare e l'algoritmo Digest genera un codice di autenticazione per il messaggio fornito.

Questo codice dimostra come utilizzare il metodo digest () per costruire un codice di autenticazione del messaggio per un messaggio specifico direttamente dalla chiave di input, piuttosto che creare un'istanza di HMAC come nell'esempio precedente. Poiché impiega un'implementazione C ottimizzata per la costruzione del digest, questo metodo è più veloce rispetto all'utilizzo di HMAC per creare codici di autenticazione per piccole comunicazioni.

Importa HMAC
Importa hashlib
msgg = "Python Programming"
key_one = "abcabcabc"
message_digest_one = hmac.digest (key = key_one.encode (), msg = msgg.encode (), digest = "sha3_256")
print ("Message Digest One: ".formato (messaggio_digest_one))
Message_Digest_Two = HMAC.digest (key = key_one.ENCODE (), msg = byte (msgg, encoding = "utf-8"), digest = hashlib.sha3_256)
print ("Message Digest Two: ".formato (messaggio_digest_two))

Ecco il risultato in cui è possibile vedere che il codice di autenticazione del messaggio viene creato utilizzando il digerire() metodo.

Conclusione:

HMAC è una tecnica di autenticazione basata sul messaggio di Hash Cryptografiche. La tecnica HMAC ampiamente utilizzata è discussa in dettaglio in questo post. L'idea principale di questo approccio è quella di utilizzare una chiave segreta condivisa per combinare un hash crittografico dei dati effettivi. Questo è al solo scopo di creare una chiave segreta condivisa. Abbiamo attraversato questa idea approfondita e fornito esempi per aiutarti a capirla.