🔐 pycryptodome Module#

What is pycryptodome?#

pycryptodome is a powerful Python cryptography library. It provides tools for encryption, decryption, hashing, and analyzing cryptographic algorithms.

Why Use It in Cybersecurity?#

Encrypt and decrypt data
Hash passwords and data
Generate secure passwords
Decrypt captured data
Analyze weak encryption
Test cryptography implementations
Create secure communication tools

Installation#

1
pip install pycryptodome

Basic Usage#

Hashing with SHA256#

1
from Crypto.Hash import SHA256
2

3
data = "Hello World"
4
hash_obj = SHA256.new(data.encode())
5
hash_hex = hash_obj.hexdigest()
6

7
print(f"Data: {data}")
8
print(f"Hash: {hash_hex}")

Output:

1
Data: Hello World
2
Hash: a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146

MD5 Hash#

1
from Crypto.Hash import MD5
2

3
password = "admin123"
4
hash_obj = MD5.new(password.encode())
5
md5_hash = hash_obj.hexdigest()
6

7
print(f"Password: {password}")
8
print(f"MD5: {md5_hash}")

AES Encryption#

1
from Crypto.Cipher import AES
2
from Crypto.Random import get_random_bytes
3
import base64
4

5
# Generate key (must be 16, 24, or 32 bytes)
6
key = get_random_bytes(16)
7

8
# Data to encrypt
9
plaintext = "Secret Message"
10
pad_len = 16 - (len(plaintext) % 16)
11
plaintext = plaintext + ' ' * pad_len
12

13
# Create cipher
14
cipher = AES.new(key, AES.MODE_ECB)
15

16
# Encrypt
17
ciphertext = cipher.encrypt(plaintext.encode())
18
encrypted = base64.b64encode(ciphertext).decode()
19

20
print(f"Plaintext: {plaintext}")
21
print(f"Encrypted: {encrypted}")

AES Decryption#

1
from Crypto.Cipher import AES
2
import base64
3

4
# Key and encrypted data
5
key = b'sixteen byte key'  # Must match encryption key
6
encrypted = "base64_encoded_data_here"
7

8
# Decode and decrypt
9
ciphertext = base64.b64decode(encrypted)
10
cipher = AES.new(key, AES.MODE_ECB)
11
plaintext = cipher.decrypt(ciphertext).decode()
12

13
print(f"Decrypted: {plaintext.strip()}")

Generate Random Password#

1
from Crypto.Random import get_random_bytes
2
import string
3

4
# Generate random bytes
5
random_bytes = get_random_bytes(20)
6

7
# Convert to alphanumeric
8
chars = string.ascii_letters + string.digits
9
password = ''.join([random_bytes[i % len(random_bytes)] for i in range(16)])
10

11
print("Random Password:", password)
12

13
# Better way
14
import secrets
15
print("Secure Password:", secrets.token_hex(16))

Real-World Cybersecurity Uses#

1. Password Hashing for Authentication#

1
from Crypto.Hash import SHA256
2
from Crypto.Random import get_random_bytes
3

4
def hash_password(password, salt=None):
5
    if salt is None:
6
        salt = get_random_bytes(16)
7

8
    # Combine password + salt
9
    data = password.encode() + salt
10

11
    # Hash
12
    hash_obj = SHA256.new(data)
13
    return salt, hash_obj.hexdigest()
14

15
# Store these in database
16
salt, hashed = hash_password("user123")
17
print(f"Salt: {salt.hex()}")
18
print(f"Hash: {hashed}")
19

20
# Verify password
21
def verify_password(password, salt, stored_hash):
22
    _, computed_hash = hash_password(password, salt)
23
    return computed_hash == stored_hash
24

25
# Test
26
print("Valid:", verify_password("user123", salt, hashed))  # True
27
print("Invalid:", verify_password("wrong", salt, hashed))  # False

2. Decrypt Captured Network Traffic#

1
from Crypto.Cipher import AES
2
import base64
3

4
# Simulate captured encrypted traffic
5
captured_key = b'sixteen byte key'
6
captured_data = "U2FsdGVkX1+jE4BzZ..."
7

8
# Decrypt
9
try:
10
    decoded = base64.b64decode(captured_data)
11
    cipher = AES.new(captured_key, AES.MODE_CBC, iv=b'sixteen byte iv')
12
    decrypted = cipher.decrypt(decoded).decode()
13
    print("Decrypted Traffic:", decrypted)
14
except Exception as e:
15
    print("Decryption failed:", e)

3. Generate Secure Tokens#

1
from Crypto.Random import get_random_bytes
2
import base64
3

4
# Generate API token
5
token = base64.urlsafe_b64encode(get_random_bytes(32)).decode()
6
print("API Token:", token)
7

8
# Generate session ID
9
session_id = base64.urlsafe_b64encode(get_random_bytes(24)).decode()
10
print("Session ID:", session_id)

4. Check MD5 Weakness (Rainbow Tables)#

1
from Crypto.Hash import MD5
2

3
# Common password MD5 hashes
4
hashes = {
5
    "21232f297a57a5a743894a0e4a801fc3": "admin",
6
    "5f4dcc3b5aa765d61d8327deb882cf99": "password",
7
    "e10adc3949ba59abbe56e057f20f883e": "123456"
8
}
9

10
# Check if hash is in rainbow table
11
def check_md5(hash_value):
12
    if hash_value in hashes:
13
        return hashes[hash_value]
14
    return "Not found"
15

16
# Test
17
print(check_md5("5f4dcc3b5aa765d61d8327deb882cf99"))  # password
18
print(check_md5("unknown_hash"))  # Not found
19

20
# Why MD5 is weak: fast to compute, collisions possible
21
print("\n⚠️ MD5 is deprecated! Use SHA256 or better.")

5. RSA Encryption (Public Key)#

1
from Crypto.PublicKey import RSA
2
from Crypto.Cipher import PKCS1_OAEP
3

4
# Generate key pair
5
key = RSA.generate(2048)
6
private_key = key.export_key()
7
public_key = key.publickey().export_key()
8

9
print("Key pair generated!")
10

11
# Encrypt with public key
12
cipher_rsa = PKCS1_OAEP.new(key.publickey())
13
ciphertext = cipher_rsa.encrypt(b"Sensitive Data")
14
print("Encrypted:", ciphertext.hex())
15

16
# Decrypt with private key
17
decipher_rsa = PKCS1_OAEP.new(key)
18
decrypted = decipher_rsa.decrypt(ciphertext)
19
print("Decrypted:", decrypted.decode())

⚠️ Ethical Note#

Never hardcode encryption keys in code
Use strong algorithms (avoid MD5, RC4)
Always use unique salts for password hashing
Don’t roll your own crypto - use proven libraries

![Image: Encryption/decryption diagram placeholder]

Summary Table#

Algorithm	Use Case
`SHA256`	Secure hashing
`MD5`	Weak hashing (avoid)
`AES`	Symmetric encryption
`RSA`	Asymmetric encryption
`get_random_bytes()`	Secure random data

Quick Reference#

1
# Hashing
2
from Crypto.Hash import SHA256
3
h = SHA256.new(data.encode())
4
h.hexdigest()
5

6
# AES Encryption
7
from Crypto.Cipher import AES
8
cipher = AES.new(key, AES.MODE_ECB)
9
cipher.encrypt(data)
10

11
# Random data
12
from Crypto.Random import get_random_bytes
13
get_random_bytes(16)
14

15
# RSA Encryption
16
from Crypto.PublicKey import RSA
17
key = RSA.generate(2048)