# hashlib Module#

1
import hashlib
2

3
data = "Hello World"
4

5
# Create SHA256 hash
6
hash_obj = hashlib.sha256(data.encode())
7
hash_value = hash_obj.hexdigest()
8

9
print(f"Data: {data}")
10
print(f"SHA256: {hash_value}")

1
Data: Hello World
2
SHA256: a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146

1
import hashlib
2

3
password = "admin123"
4
md5_hash = hashlib.md5(password.encode()).hexdigest()
5

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

1
import hashlib
2

3
data = "Secret Message"
4
sha1_hash = hashlib.sha1(data.encode()).hexdigest()
5

6
print(f"Data: {data}")
7
print(f"SHA1: {sha1_hash}")

1
import hashlib
2

3
def slow_hash(password, salt, iterations=10000):
4
    data = password.encode() + salt
5

6
    for _ in range(iterations):
7
        data = hashlib.sha256(data).digest()
8

9
    return data.hex()
10

11
# Hash with salt
12
salt = b'random_salt_value'
13
hashed = slow_hash("mypassword", salt)
14

15
print(f"Salted Hash: {hashed}")

1
import hashlib
2
import secrets
3

4
def hash_password(password):
5
    # Generate random salt
6
    salt = secrets.token_hex(16).encode()
7

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

11
    # Hash
12
    hashed = hashlib.sha256(data).hexdigest()
13

14
    # Store: salt + hash
15
    return salt.hex() + ":" + hashed
16

17
def check_password(password, stored):
18
    # Split into salt and hash
19
    salt_hex, stored_hash = stored.split(":", 1)
20
    salt = salt_hex.encode()
21

22
    # Hash input with same salt
23
    data = password.encode() + salt
24
    computed_hash = hashlib.sha256(data).hexdigest()
25

26
    # Compare
27
    return computed_hash == stored_hash
28

29
# Example usage
30
stored = hash_password("user123")
31
print(f"Stored: {stored}")
32

33
print("Valid login:", check_password("user123", stored))  # True
34
print("Invalid login:", check_password("wrong", stored))  # False

1
import hashlib
2

3
def get_file_hash(filepath):
4
    """Calculate SHA256 hash of a file"""
5
    sha256 = hashlib.sha256()
6

7
    with open(filepath, 'rb') as f:
8
        # Read file in chunks
9
        while chunk := f.read(4096):
10
            sha256.update(chunk)
11

12
    return sha256.hexdigest()
13

14
# Check if file has been modified
15
original_hash = "abc123def456..."
16
current_hash = get_file_hash("malware.exe")
17

18
if current_hash == original_hash:
19
    print("✅ File unchanged")
20
else:
21
    print("⚠️ File modified! Possible malware!")
22

23
# Compare two files
24
hash1 = get_file_hash("file1.txt")
25
hash2 = get_file_hash("file2.txt")
26

27
if hash1 == hash2:
28
    print("Files are identical")
29
else:
30
    print("Files are different")

1
import hashlib
2
import re
3

4
def identify_hash_type(hash_value):
5
    hash_value = hash_value.lower()
6

7
    # MD5 (32 hex chars)
8
    if re.match(r'^[a-f0-9]{32}$', hash_value):
9
        return "MD5"
10

11
    # SHA1 (40 hex chars)
12
    if re.match(r'^[a-f0-9]{40}$', hash_value):
13
        return "SHA1"
14

15
    # SHA256 (64 hex chars)
16
    if re.match(r'^[a-f0-9]{64}$', hash_value):
17
        return "SHA256"
18

19
    # SHA512 (128 hex chars)
20
    if re.match(r'^[a-f0-9]{128}$', hash_value):
21
        return "SHA512"
22

23
    return "Unknown"
24

25
# Test
26
print(identify_hash_type("5f4dcc3b5aa765d61d8327deb882cf99"))  # MD5
27
print(identify_hash_type("a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146"))  # SHA256

1
import hashlib
2

3
# Create simple rainbow table
4
rainbow_table = {}
5

6
# Common passwords (in real attacks, this has millions)
7
common_passwords = [
8
    "password", "123456", "admin", "root",
9
    "welcome", "qwerty", "letmein", "12345678"
10
]
11

12
# Pre-compute hashes
13
for password in common_passwords:
14
    hash_value = hashlib.md5(password.encode()).hexdigest()
15
    rainbow_table[hash_value] = password
16

17
print("Rainbow table created with", len(rainbow_table), "entries")
18

19
# Look up hash
20
target_hash = "5f4dcc3b5aa765d61d8327deb882cf99"
21

22
if target_hash in rainbow_table:
23
    print(f"✅ Password found: {rainbow_table[target_hash]}")
24
else:
25
    print("❌ Password not in table")
26

27
# This is why salts are important!

1
import hashlib
2
import secrets
3
import time
4

5
def generate_api_key():
6
    # Get random bytes + timestamp
7
    random_data = secrets.token_bytes(32)
8
    timestamp = str(time.time()).encode()
9

10
    # Combine and hash
11
    data = random_data + timestamp
12
    hash_value = hashlib.sha256(data).hexdigest()
13

14
    # Format: add separators
15
    return '-'.join([hash_value[i:i+8] for i in range(0, len(hash_value), 8)])
16

17
# Generate multiple keys
18
for i in range(3):
19
    print(f"API Key {i+1}: {generate_api_key()}")

1
import hashlib
2

3
def verify_download(filename, expected_hash):
4
    """Verify if downloaded file matches expected hash"""
5
    sha256 = hashlib.sha256()
6

7
    with open(filename, 'rb') as f:
8
        while chunk := f.read(8192):
9
            sha256.update(chunk)
10

11
    computed_hash = sha256.hexdigest()
12

13
    print(f"Expected: {expected_hash}")
14
    print(f"Computed: {computed_hash}")
15

16
    if computed_hash == expected_hash:
17
        print("✅ Download verified!")
18
        return True
19
    else:
20
        print("❌ Download corrupted or tampered!")
21
        return False
22

23
# Usage
24
expected = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
25
status = verify_download("downloaded_file.iso", expected)