Python’s hashlib Library

Python’s hashlib is a robust library that allows for hashing, a crucial aspect of many cryptographic operations and data integrity checks. Hashing is the process of converting data of arbitrary size into a fixed-size output, usually represented in hexadecimal form. The hashlib module provides a common interface to various secure hashing algorithms and HMAC (Hash-based Message Authentication Code) implementations. This library plays a pivotal role in security applications, file integrity checks, and data validation.

Why Use Hashlib?

  • Data Integrity: Ensuring that data hasn’t been tampered with during transmission.
  • Password Hashing: Storing passwords securely by hashing them instead of keeping them as plain text.
  • Digital Signatures: Confirming the authenticity of messages or documents.
  • Unique Identification: Generating unique IDs for files or objects based on their content.

Key Features of hashlib

  • Cryptographic Hashing: Includes secure hashing algorithms like SHA-1, SHA-256, SHA-512, and more.
  • HMAC: Supports HMAC (Hash-based Message Authentication Code) for enhanced security.
  • Cross-Platform: Works seamlessly across various operating systems.
  • Native Implementations: Python bindings for high-speed implementations in C.

Supported Hash Functions

Secure Hash Algorithms (SHA)

SHA algorithms are widely used in security applications:

  • SHA-1: Produces a 160-bit hash value, used in legacy systems.
  • SHA-224, SHA-256, SHA-384, SHA-512: Part of the SHA-2 family, these algorithms provide progressively longer hashes.


Produces a 128-bit hash value. Although MD5 is faster than SHA, it’s no longer considered secure for cryptographic purposes due to vulnerabilities.


BLAKE2 is faster than MD5 and SHA-1 while providing similar or better security.


The latest standard from the NIST, offering enhanced security compared to SHA-2.

Using Hashlib in Python

Basic Hashing

Here’s a basic example of generating a hash using SHA-256:

import hashlib

# Create a SHA-256 hash object
sha256 = hashlib.sha256()

# Update the hash object with bytes
sha256.update(b"Hello, hashlib!")

# Get the hexadecimal representation of the hash
hash_result = sha256.hexdigest()
print(f"SHA-256 Hash: {hash_result}")

Hashing with Salt

Salting adds additional data to the input to defend against certain types of attacks.

import os

# Generate a random salt
salt = os.urandom(16)

# Concatenate salt with data and hash
data = b"password123"
sha256.update(salt + data)
salted_hash = sha256.hexdigest()
print(f"Salted SHA-256 Hash: {salted_hash}")

File Hashing

To compute the hash of a file:

def file_hash(filename, hash_alg=hashlib.sha256):
    hasher = hash_alg()
    with open(filename, 'rb') as f:
        while chunk :=
    return hasher.hexdigest()

# Example usage
file_hash_value = file_hash('example.txt')
print(f"File SHA-256 Hash: {file_hash_value}")

HMAC with hashlib

HMAC ensures the integrity and authenticity of data, especially in network communications.

import hmac

key = b"supersecretkey"
message = b"Important message"

# Create HMAC object using SHA-256
hmac_obj =, message, hashlib.sha256)

# Get HMAC in hexadecimal
hmac_hex = hmac_obj.hexdigest()
print(f"HMAC (SHA-256): {hmac_hex}")

BLAKE2 Hashing

BLAKE2 comes in two versions, blake2b for large outputs (up to 64 bytes) and blake2s for smaller ones (up to 32 bytes).

# BLAKE2b Hash Example
blake2b_hash = hashlib.blake2b(b"Example data").hexdigest()
print(f"BLAKE2b Hash: {blake2b_hash}")

# BLAKE2s Hash Example
blake2s_hash = hashlib.blake2s(b"Example data").hexdigest()
print(f"BLAKE2s Hash: {blake2s_hash}")

SHA-3 Hashing

SHA-3 is the latest member of the Secure Hash Algorithm family.

# SHA3-256 Hash Example
sha3_256_hash = hashlib.sha3_256(b"Example data").hexdigest()
print(f"SHA3-256 Hash: {sha3_256_hash}")

# SHA3-512 Hash Example
sha3_512_hash = hashlib.sha3_512(b"Example data").hexdigest()
print(f"SHA3-512 Hash: {sha3_512_hash}")

Comparing Hashes

Comparing hashes is simple with hashlib. Here’s a function that compares the hash of a string with a known hash:

def compare_hashes(data, expected_hash, hash_alg=hashlib.sha256):
    hasher = hash_alg()
    return hasher.hexdigest() == expected_hash

# Example usage
data_to_check = b"Check this string"
expected = hashlib.sha256(data_to_check).hexdigest()
print(compare_hashes(data_to_check, expected))

Secure Password Hashing

For secure password storage, you should use hashlib along with a cryptographic salt. Here’s an example using SHA-256:

import os

def hash_password(password, salt=None):
    if salt is None:
        salt = os.urandom(16)
    hasher = hashlib.sha256()
    hasher.update(salt + password.encode())
    return salt, hasher.hexdigest()

# Example usage
salt, hashed_pw = hash_password('mysecurepassword')
print(f"Salt: {salt.hex()}, Hash: {hashed_pw}")

# To verify the password later:
def verify_password(stored_hash, password, salt):
    _, new_hash = hash_password(password, salt)
    return stored_hash == new_hash

# Verification
print(verify_password(hashed_pw, 'mysecurepassword', salt))


Python’s hashlib is a versatile library offering a range of cryptographic hash functions and HMACs. Whether it’s verifying data integrity, securely storing passwords, or ensuring message authenticity, hashlib provides the tools needed for secure and reliable hashing.