Python in Cybersecurity: Hashing Files and Verifying Integrity with hashlib#

1
import hashlib
2
import os
3

4
def hash_file(filepath, algorithm='sha256', chunk_size=4096):
5
    """
6
    Calculates the hash of a file using a specified algorithm.
7

8
    Args:
9
        filepath (str): The path to the file.
10
        algorithm (str): The hashing algorithm to use (e.g., 'sha256', 'sha512').
11
        chunk_size (int): The size of chunks to read the file in.
12

13
    Returns:
14
        str or None: The hexadecimal digest of the file's hash, or None if the file is not found.
15
    """
16
    if not os.path.exists(filepath):
17
        print(f"Error: File not found at {filepath}")
18
        return None
19

20
    try:
21
        # Get the hash constructor function from hashlib
22
        hash_func = hashlib.new(algorithm)
23

24
        with open(filepath, 'rb') as f:
25
            # Read and update hash object in chunks
26
            while chunk := f.read(chunk_size):
27
                hash_func.update(chunk)
28

29
        # Return the hexadecimal digest
30
        return hash_func.hexdigest()
31

32
    except FileNotFoundError:
33
        print(f"Error: File not found at {filepath}")
34
        return None
35
    except Exception as e:
36
        print(f"An error occurred: {e}")
37
        return None
38

39
# Example Usage:
40
file_to_hash = 'my_sensitive_document.txt' # Replace with actual file path
41

42
# Create a dummy file for demonstration
43
if not os.path.exists(file_to_hash):
44
    with open(file_to_hash, 'w') as f:
45
        f.write("This is the original content of the file.\n")
46
        f.write("It will be hashed to check integrity.")
47

48
file_hash = hash_file(file_to_hash, 'sha256')
49

50
if file_hash:
51
    print(f"The SHA-256 hash of '{file_to_hash}' is:\n{file_hash}")
52

53
# Clean up the dummy file
54
# import os
55
# if os.path.exists(file_to_hash):
56
#    os.remove(file_to_hash)

1
import hashlib
2
import os
3

4
# Assuming the hash_file function from the previous section is available
5

6
def verify_file_integrity(filepath, known_hash, algorithm='sha256'):
7
    """
8
    Verifies the integrity of a file by comparing its hash to a known hash.
9

10
    Args:
11
        filepath (str): The path to the file.
12
        known_hash (str): The expected hexadecimal hash digest.
13
        algorithm (str): The hashing algorithm used for the known hash.
14

15
    Returns:
16
        bool or None: True if the hashes match, False if they don't,
17
                      None if an error occurred during hashing.
18
    """
19
    computed_hash = hash_file(filepath, algorithm)
20

21
    if computed_hash is None:
22
        # An error occurred during hashing (e.g., file not found)
23
        return None
24

25
    # Compare the computed hash with the known hash (case-insensitive comparison is common)
26
    return computed_hash.lower() == known_hash.lower()
27

28
# Example Usage:
29
file_to_verify = 'my_sensitive_document.txt' # Must be the same file as hashed before
30

31
# Need a known good hash - assuming we have it from a trusted source
32
# IMPORTANT: In a real scenario, this hash would not be generated from the file itself
33
# immediately before verification, but obtained from a separate, trusted source.
34
# For this example, we'll use the hash computed earlier for demonstration.
35
trusted_original_hash = 'a_known_good_hash_from_a_trusted_source' # Replace with the actual hash
36

37
# Let's simulate obtaining the hash from the previous step for demonstration
38
# In a real use case, this hash comes from OUTSIDE the system being checked.
39
# For example, from the software vendor's website or a secure database.
40
if os.path.exists(file_to_verify):
41
     trusted_original_hash = hash_file(file_to_verify, 'sha256')
42
     print(f"\n(For demo purposes, using computed hash as 'trusted': {trusted_original_hash})")
43
else:
44
     print("\nDummy file not found for verification example.")
45
     trusted_original_hash = None # Cannot proceed with verification
46

47

48
if trusted_original_hash:
49
    # Simulate a potential change in the file (e.g., malware infection, accidental edit)
50
    # Comment this out to see a successful verification
51
    # with open(file_to_verify, 'a') as f:
52
    #     f.write("\nThis line is added later.")
53
    # print("\n(Simulating file modification)")
54

55

56
    is_intact = verify_file_integrity(file_to_verify, trusted_original_hash, 'sha256')
57

58
    if is_intact is True:
59
        print(f"\nFile '{file_to_verify}' integrity verified successfully. Hashes match.")
60
    elif is_intact is False:
61
        print(f"\nFile '{file_to_verify}' integrity check failed. Hashes do NOT match.")
62
    else:
63
        print(f"\nIntegrity check could not be completed for '{file_to_verify}'.")
64

65

66
# Clean up the dummy file
67
# import os
68
# if os.path.exists(file_to_verify):
69
#    os.remove(file_to_verify)

1
# Assuming the hash_file function is defined as above
2

3
downloaded_file = 'path/to/downloaded/security_update.exe' # Replace with actual path
4
published_sha256 = 'a1b2c3d4e5f678901234567890abcdef1234567890abcdef1234567890abcdef' # Known good hash
5

6
computed_sha256 = hash_file(downloaded_file, 'sha256')
7

8
if computed_sha256:
9
    if computed_sha256.lower() == published_sha256.lower():
10
        print(f"Verification successful: The hash of '{downloaded_file}' matches the published hash.")
11
        print("File integrity is likely intact.")
12
    else:
13
        print(f"Verification failed: The hash of '{downloaded_file}' does NOT match the published hash.")
14
        print("The file may have been corrupted or tampered with. Do not use this file.")
15
        print(f"Computed hash: {computed_sha256}")
16
        print(f"Published hash: {published_sha256}")
17
else:
18
    print(f"Could not compute hash for '{downloaded_file}'. Verification failed.")