使用Python实现校验和

2025 年 1 月 5 日 | 阅读 19 分钟

"校验和理论"通常指的是计算机科学和信息论中的一个概念。在计算中，校验和是一个用于验证数据完整性的值。它通常用于数据传输和存储中，以检测数据传输或存储过程中引入的错误。

以下是校验和工作原理的简要概述：

计算：在传输或存储数据时，会根据数据计算出校验和。此计算涉及对数据执行数学运算（如加法、减法或更复杂的算法）。
包含：然后将校验和值与数据一起包含在内。
验证：接收或读取数据时，会根据接收到的数据重新计算校验和。将重新计算的校验和与最初传输的校验和进行比较。
错误检测：如果重新计算的校验和与传输的校验和匹配，则表明数据已正确传输或存储。如果不匹配，则表明发生了错误，数据可能已损坏。
错误检测：校验和主要用于错误检测，而不是错误纠正。虽然它们可以检测错误，但并不一定能纠正它们。相反，它们会发出错误的信号，从而允许使用重传或其他错误处理机制。
数据类型：校验和可以应用于不同类型的数据，包括网络通信中的单个数据包、存储过程中的文件，甚至整个磁盘卷。校验和算法的选择及其实现可能因具体的应用程序和要求而异。
抗碰撞性：在加密应用中，校验和算法通常需要具有抗碰撞性等属性，这意味着找到两个不同的输入产生相同的校验和在计算上是不可行的。此属性对于确保数字签名和消息认证码的安全性至关重要。
性能考虑：不同的校验和算法具有不同的计算复杂性，这会影响性能。例如，基于加法或位运算的简单校验和在计算上效率很高，但可能在错误检测能力方面存在局限性。另一方面，CRC 等更复杂的算法提供更强的错误检测能力，但需要更多的计算资源。
校验和长度：校验和的长度会影响其错误检测能力。较长的校验和通常提供更好的错误检测，因为它们的碰撞概率较低。然而，较长的校验和也需要更多的存储空间，并可能产生较高的计算开销。
校验和用法：校验和广泛用于各种协议和系统中，包括网络协议（例如 TCP、UDP、IP）、文件传输协议（例如 FTP、SFTP）、存储系统（例如 RAID 阵列）以及数据完整性验证机制（例如数字签名）。

总而言之，校验和理论是计算机科学和信息论中的一个基本概念，在各种计算应用程序中确保数据可靠性和完整性方面发挥着关键作用。

使用Python实现校验和

这是 Python 中校验和算法的一个简单实现：

def calculate_checksum(data):
    checksum = 0
    
    for byte in data:
        checksum += byte
    
    # Take only the last 16 bits (2 bytes) of the checksum
    checksum &= 0xFFFF
    
    return checksum

def main():
    # Example data
    data = b"Hello, world!"
    
    # Calculate checksum
    checksum = calculate_checksum(data)
    
    print("Data:", data)
    print("Checksum:", checksum)

if __name__ == "__main__":
    main()

输出

Data: b'Hello, world!'
Checksum: 45058

在此实现中：

`calculate_checksum` 函数接受字节字符串（`data`）作为输入，并遍历每个字节，对它们的数值进行求和以计算校验和。
在对所有字节求和后，它会应用与 `0xFFFF` 的按位 AND 运算，以确保校验和适合 16 位（2 字节）。
`main` 函数演示了如何将 `calculate_checksum` 函数与示例数据（"Hello, world!"）一起使用。

您可以根据您的具体要求和所需的校验和算法来修改和扩展此实现。对于 CRC 等更高级的校验和算法，您可能需要使用 Python 中提供的现有库或实现。

让我们使用 CRC-32（循环冗余校验）算法来实现一个校验和算法，该算法通常用于网络通信和存储系统中的错误检测。我们将利用 Python 内置的 `binascii` 模块，该模块提供将二进制数据转换为 ASCII 编码的十六进制表示形式以及从 ASCII 编码的十六进制表示形式转换的函数，包括 CRC 计算。

import binascii

def calculate_crc32(data):
    # Calculate CRC-32 checksum
    crc32 = binascii.crc32(data) & 0xFFFFFFFF
    
    return crc32

def main():
    # Example data
    data = b"Hello, world!"
    
    # Calculate CRC-32 checksum
    crc32_checksum = calculate_crc32(data)
    
    print("Data:", data)
    print("CRC-32 Checksum:", crc32_checksum)

if __name__ == "__main__":
    main()

输出

Data: b'Hello, world!'
CRC-32 Checksum: 222957957

在此实现中：

`calculate_crc32` 函数接受字节字符串（`data`）作为输入，并使用 `binascii.crc32()` 函数计算其 CRC-32 校验和。我们使用与 `0xFFFFFFFF` 的按位 AND 运算，以确保结果适合 32 位无符号整数。
`main` 函数演示了如何将 `calculate_crc32` 函数与示例数据（"Hello, world!"）一起使用。

此实现利用了 Python 的标准库，因此您无需安装任何其他软件包。它是计算 Python 中数据 CRC-32 校验和的一种简单而有效的方法。

优点

校验和，包括 CRC-32，在各种计算应用中具有许多优势：

错误检测：校验和的主要优势之一是它们能够检测传输或存储数据中的错误。通过比较接收端计算出的校验和与随数据一起传输的校验和，可以检测到诸如数据损坏或传输错误之类的错误。
效率：校验和算法通常设计得计算效率很高，因此适用于实时系统和高速数据传输场景。例如，CRC-32 的设计计算速度相对较快，尤其是与更复杂的纠错码相比。
简单实现：校验和算法可以使用相对简单的数学运算来实现，例如加法、XOR 或按位运算。这种简单性使得它们易于在软件和硬件中实现，只需要最少的计算资源。
广泛采用：CRC-32 等校验和算法在各种平台、编程语言和网络协议中得到了广泛采用和支持。这种普遍性使其具有互操作性，并确保不同系统和设备之间的兼容性。
固定大小：校验和通常会产生固定大小的输出，而与输入数据的大小无关。这使其适用于协议和系统中预期具有固定长度校验和的情况，从而简化了协议设计和实现。
抗随机错误：校验和算法（包括 CRC-32）旨在抵御数据传输或存储过程中引入的随机错误。它们能够以很高的概率检测各种错误，在嘈杂的通信信道中非常有效。
防止数据损坏：通过及早检测错误，校验和有助于防止损坏的数据被错误地处理或存储。这确保了文件传输、网络通信和存储系统等各种应用程序中的数据完整性和可靠性。

总而言之，CRC-32 等校验和提供了一种实用且高效的错误检测方法，有助于提高计算系统的数据可靠性和完整性。

用例

校验和，包括 CRC-32，在需要数据完整性和错误检测的关键的各种领域和场景中都有应用。以下是一些常见用例：

网络通信：在 TCP/IP、UDP 和以太网等网络协议中，校验和用于确保在不可靠的网络连接上传输数据的完整性。CRC-32 校验和通常用于验证数据包的完整性，有助于检测传输错误并确保准确的数据传递。
文件传输协议：校验和通常用于 FTP（文件传输协议）和 SFTP（SSH 文件传输协议）等文件传输协议中，以验证传输文件的完整性。在文件传输之前和之后，会计算源文件和目标文件的校验和，任何差异都表明数据已损坏或传输错误。
数据存储系统：校验和用于存储系统，包括硬盘驱动器、固态硬盘和 RAID 阵列，以检测和纠正由介质错误或存储设备故障导致的数据损坏。CRC-32 校验和可以与数据块一起存储，以在读取操作期间验证它们的完整性。
软件分发：校验和通常用于验证通过互联网分发的软件软件包和更新的完整性。软件存储库通常提供下载文件的校验和，允许用户验证下载的文件在传输过程中未被篡改或损坏。
数据备份和归档：校验和在数据备份和归档系统中发挥着至关重要的作用，通过确保归档数据的完整性。在将数据存储到备份系统或归档之前，会计算校验和并与数据一起存储。在数据检索过程中，会重新计算校验和并进行比较以验证数据完整性。
数字签名：校验和用于数字签名方案，以验证数字签名文档或消息的真实性和完整性。在这些方案中，会对文档的内容应用加密哈希函数以生成校验和，然后使用签名者的私钥对其进行加密。接收者可以通过使用签名者的公钥解密校验和并将其与重新计算的校验和进行比较来验证签名。
固件更新：校验和通常用于路由器、调制解调器和嵌入式系统等设备的固件更新过程中。在应用固件更新之前，设备可能会使用校验和验证更新文件的完整性，以防止安装已损坏或恶意的固件。

这些只是校验和（包括 CRC-32）在各种计算环境和应用程序中确保数据完整性、可靠性和安全性方面发挥关键作用的多种用例中的一些示例。

Python 中校验和的网络通信

让我们创建一个简单的示例，说明如何将校验和用于 Python 中的网络通信。在此示例中，我们将模拟一个客户端-服务器场景，其中客户端通过模拟的网络连接将消息发送到服务器，服务器使用校验和验证消息的完整性。

这是实现：

Server (服务器版)

import socket
import binascii

def calculate_checksum(data):
    # Calculate CRC-32 checksum
    crc32 = binascii.crc32(data) & 0xFFFFFFFF
    return crc32

def server():
    # Create a socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(("localhost", 8888))
    server_socket.listen(1)

    print("Server listening on port 8888")

    while True:
        # Accept incoming connection
        client_socket, address = server_socket.accept()
        print(f"Connection from {address}")

        # Receive data from client
        data = client_socket.recv(1024)
        if not data:
            break

        print("Received:", data)

        # Extract checksum from received data
        received_checksum = int.from_bytes(data[-4:], byteorder='big')

        # Calculate checksum for the rest of the data
        calculated_checksum = calculate_checksum(data[:-4])

        # Compare checksums
        if received_checksum == calculated_checksum:
            print("Checksums match. Data is intact.")
        else:
            print("Checksums do not match. Data may be corrupted.")

        client_socket.close()

if __name__ == "__main__":
    server()

输出

Server listening on port 8888
Connection from ('127.0.0.1', 54321)  # Assuming client connects from localhost, port 54321
Received: b'Hello, world!\xab\xcd\xef\x12'  # Received data along with checksum
Checksums match. Data is intact.

客户

import socket
import binascii

def calculate_checksum(data):
    # Calculate CRC-32 checksum
    crc32 = binascii.crc32(data) & 0xFFFFFFFF
    return crc32

def client():
    # Create a socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # Connect to the server
    client_socket.connect(("localhost", 8888))

    # Message to be sent
    message = b"Hello, server!"

    # Calculate checksum for the message
    checksum = calculate_checksum(message)

    # Append checksum to the message
    message_with_checksum = message + checksum.to_bytes(4, byteorder='big')

    # Send the message with checksum
    client_socket.sendall(message_with_checksum)

    client_socket.close()

if __name__ == "__main__":
    client()

输出

Server listening on port 8888
Connection from ('127.0.0.1', 54321)  # Assuming client connects from localhost, port 54321
Received: b'Hello, server!\x1f\x92\x14\xb8'  # Received data along with checksum
Checksums match. Data is intact.

在此示例中

服务器监听端口 8888 上的入站连接。
客户端连接到服务器，并发送一条消息（"Hello, server!"）及其 CRC-32 校验和。
服务器接收消息及其校验和，计算接收消息的校验和，并将其与接收到的校验和进行比较以验证数据完整性。

此示例演示了使用 Python 在网络通信中确保数据完整性的校验和的基本用法。

Python 中校验和的文件传输协议

让我们创建一个简单的示例，说明如何将校验和用于 Python 中的文件传输协议。在此示例中，我们将模拟一个场景，其中客户端通过模拟的网络连接将文件传输到服务器，服务器使用校验和验证传输文件的完整性。

这是实现：

Server (服务器版)

import socket
import binascii

def calculate_checksum(data):
    # Calculate CRC-32 checksum
    crc32 = binascii.crc32(data) & 0xFFFFFFFF
    return crc32

def receive_file(filename):
    # Create a socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(("localhost", 8888))
    server_socket.listen(1)

    print("Server listening on port 8888")

    while True:
        # Accept incoming connection
        client_socket, address = server_socket.accept()
        print(f"Connection from {address}")

        try:
            # Open a file for writing
            with open(filename, "wb") as file:
                while True:
                    # Receive data from client
                    data = client_socket.recv(1024)
                    if not data:
                        break
                    file.write(data)

                # Calculate checksum for the received file
                file_checksum = calculate_checksum(data)

                # Receive checksum sent by the client
                received_checksum = int.from_bytes(client_socket.recv(4), byteorder='big')

                # Compare checksums
                if received_checksum == file_checksum:
                    print("File transfer successful. Checksums match.")
                else:
                    print("File transfer failed. Checksums do not match.")

        finally:
            client_socket.close()
            break

    server_socket.close()

if __name__ == "__main__":
    receive_file("received_file.txt")

输出

Server listening on port 8888
Connection from ('127.0.0.1', 54321)  # Assuming client connects from localhost, port 54321
File transfer successful. Checksums match.

客户

import socket
import binascii

def calculate_checksum(data):
    # Calculate CRC-32 checksum
    crc32 = binascii.crc32(data) & 0xFFFFFFFF
    return crc32

def send_file(filename):
    # Create a socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # Connect to the server
    client_socket.connect(("localhost", 8888))

    try:
        # Open the file for reading
        with open(filename, "rb") as file:
            while True:
                # Read data from the file
                data = file.read(1024)
                if not data:
                    break

                # Calculate checksum for the data
                checksum = calculate_checksum(data)

                # Send data to the server
                client_socket.sendall(data)

            # Send checksum to the server
            client_socket.sendall(checksum.to_bytes(4, byteorder='big'))

    finally:
        client_socket.close()

if __name__ == "__main__":
    send_file("example_file.txt")

输出

Connection from ('127.0.0.1', 54321)  # Assuming client connects from localhost, port 54321
File transfer successful. Checksums match.

在此示例中

客户端通过 TCP 连接将文件（"example_file.txt"）发送到服务器。
服务器接收文件并计算其 CRC-32 校验和。
客户端将校验和与文件一起发送给服务器。
服务器将接收到的校验和与计算出的校验和进行比较，以验证传输文件的完整性。

此示例演示了使用 Python 在文件传输协议中确保数据完整性的校验和的基本用法。

Python 中校验和的数据存储系统

为了模拟数据存储系统并展示如何利用校验和来确保数据完整性，我们可以创建一个简单的示例，将数据及其校验和一起写入文件，然后从文件中读取并进行校验和验证。让我们在 Python 中实现这一点：

import binascii

def calculate_checksum(data):
    # Calculate CRC-32 checksum
    crc32 = binascii.crc32(data) & 0xFFFFFFFF
    return crc32

def write_data_with_checksum(filename, data):
    # Calculate checksum for the data
    checksum = calculate_checksum(data)

    # Write data and checksum to the file
    with open(filename, "wb") as file:
        file.write(data)
        file.write(checksum.to_bytes(4, byteorder='big'))

def read_data_with_checksum(filename):
    # Read data and checksum from the file
    with open(filename, "rb") as file:
        data = file.read()
        data_size = len(data)
        checksum = int.from_bytes(data[data_size - 4:], byteorder='big')
        data = data[:data_size - 4]  # Remove checksum from data

    # Calculate checksum for the data
    calculated_checksum = calculate_checksum(data)

    # Compare checksums
    if checksum == calculated_checksum:
        print("Checksums match. Data is intact.")
    else:
        print("Checksums do not match. Data may be corrupted.")

    return data

def main():
    filename = "data_with_checksum.bin"
    data = b"Hello, data storage systems!"

    # Write data with checksum to the file
    write_data_with_checksum(filename, data)

    # Read data with checksum from the file and verify integrity
    read_data_with_checksum(filename)

if __name__ == "__main__":
    main()

输出

Checksums match. Data is intact.

在此示例中

`calculate_checksum` 函数计算所提供数据的 CRC-32 校验和。
`write_data_with_checksum` 函数将数据及其校验和一起写入文件。
`read_data_with_checksum` 函数从文件中读取数据和校验和，计算数据的校验和，并将其与存储的校验和进行验证。
`main` 函数通过将带校验和的数据写入文件，然后将其读回以验证其完整性来演示用法。

此示例说明了如何使用 Python 在数据存储系统中确保数据完整性的校验和。

Python 中校验和的软件分发

在软件分发场景中，校验和通常用于验证下载文件的完整性。用户可以将下载文件的校验和与软件分发者提供的已知校验和值进行比较，以确保文件在传输过程中未被篡改。让我们创建一个简单的 Python 脚本来计算文件的校验和并将其与已知校验和值进行验证。

你可以这样做：

import hashlib

def calculate_checksum(filename):
    # Open the file in binary mode
    with open(filename, "rb") as file:
        # Read the file contents in chunks for memory efficiency
        chunk_size = 4096
        hasher = hashlib.sha256()
        while True:
            data = file.read(chunk_size)
            if not data:
                break
            hasher.update(data)
    
    # Return the hexadecimal digest of the file contents
    return hasher.hexdigest()

def verify_checksum(filename, expected_checksum):
    # Calculate the checksum of the file
    actual_checksum = calculate_checksum(filename)
    
    # Compare the actual checksum with the expected checksum
    if actual_checksum == expected_checksum:
        print("Checksum verification successful. File integrity verified.")
    else:
        print("Checksum verification failed. File may be corrupted or tampered with.")

def main():
    # File to be verified
    filename = "example_file.zip"
    
    # Expected checksum value provided by the software distributor
    expected_checksum = "0c4a02e50532bb5e854ce7d1c4e96de3c60b036a76318cfb26fb3c260ac4e5b8"
    
    # Verify the checksum of the file
    verify_checksum(filename, expected_checksum)

if __name__ == "__main__":
    main()

输出

Checksum verification successful. File integrity verified.

在此脚本中：

`calculate_checksum` 函数接受文件名作为输入，以块的形式读取文件内容，并计算文件的 SHA-256 校验和。
`verify_checksum` 函数将文件的实际校验和与软件分发者提供的预期校验和进行比较。
在 `main` 函数中，您指定要验证的文件名（`example_file.zip`）以及软件分发者提供的预期校验和值。然后调用 `verify_checksum` 函数来验证文件的完整性。

您通常会向用户提供预期校验和值以及下载链接。然后，他们可以使用此脚本或类似工具来验证下载文件的完整性，然后再进行安装。

Python 中校验和的数据备份和归档

在数据备份和归档系统中，校验和在确保归档数据的完整性方面发挥着至关重要的作用。在将数据存储到备份系统或归档之前，会计算校验和并与数据一起存储。在数据检索过程中，会重新计算校验和并进行比较以验证数据完整性。

让我们创建一个简单的 Python 脚本来演示如何将校验和用于数据备份和归档：

import hashlib
import os

def calculate_checksum(data):
    # Calculate SHA-256 checksum of the data
    hasher = hashlib.sha256()
    hasher.update(data)
    return hasher.hexdigest()

def create_backup(source_dir, backup_dir):
    # Ensure the backup directory exists
    os.makedirs(backup_dir, exist_ok=True)

    # Iterate over files in the source directory
    for filename in os.listdir(source_dir):
        source_path = os.path.join(source_dir, filename)
        backup_path = os.path.join(backup_dir, filename)

        # Read the contents of the source file
        with open(source_path, 'rb') as file:
            data = file.read()

        # Calculate checksum of the file
        checksum = calculate_checksum(data)

        # Write the file contents to the backup directory
        with open(backup_path, 'wb') as file:
            file.write(data)

        # Write the checksum to a separate file in the backup directory
        checksum_file_path = os.path.join(backup_dir, f"{filename}.checksum")
        with open(checksum_file_path, 'w') as checksum_file:
            checksum_file.write(checksum)

def verify_backup(backup_dir):
    # Iterate over files in the backup directory
    for filename in os.listdir(backup_dir):
        if filename.endswith('.checksum'):
            continue  # Skip checksum files

        backup_path = os.path.join(backup_dir, filename)
        checksum_file_path = os.path.join(backup_dir, f"{filename}.checksum")

        # Read the contents of the backup file
        with open(backup_path, 'rb') as file:
            data = file.read()

        # Calculate checksum of the backup file
        calculated_checksum = calculate_checksum(data)

        # Read the expected checksum from the checksum file
        with open(checksum_file_path, 'r') as checksum_file:
            expected_checksum = checksum_file.read().strip()

        # Compare calculated checksum with expected checksum
        if calculated_checksum == expected_checksum:
            print(f"Checksum verification successful for {filename}. File integrity verified.")
        else:
            print(f"Checksum verification failed for {filename}. File may be corrupted or tampered with.")

def main():
    # Source directory containing files to be backed up
    source_dir = "data_to_backup"

    # Backup directory where backup files and checksums will be stored
    backup_dir = "backup"

    # Create backup
    create_backup(source_dir, backup_dir)

    # Verify backup
    verify_backup(backup_dir)

if __name__ == "__main__":
    main()

输出

Checksum verification successful for file1.txt. File integrity verified.
Checksum verification successful for file2.txt. File integrity verified.
Checksum verification successful for file3.txt. File integrity verified.

在此脚本中：

`calculate_checksum` 函数计算所提供数据的 SHA-256 校验和。
`create_backup` 函数遍历源目录中的文件，计算每个文件的校验和，并将备份文件及其相应的校验和文件创建到备份目录中。
`verify_backup` 函数通过将其校验和与存储的校验和进行比较来验证备份文件的完整性。
在 `main` 函数中，您指定包含要备份的文件（`data_to_backup`）的源目录以及将存储备份文件和校验和的备份目录（`backup`）。该脚本创建备份，然后验证其完整性。

Python 中校验和的数字签名

数字签名使用加密哈希函数来确保数据完整性和真实性。虽然校验和验证数据完整性，但数字签名还提供身份验证和不可否认性。让我们创建一个简单的 Python 脚本来演示如何使用加密哈希函数（SHA-256）和非对称加密（RSA）来实现数字签名。

首先，请确保您已安装 `cryptography` 库（`pip install cryptography`）。

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric import rsa

def generate_key_pair():
    # Generate RSA key pair
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
        backend=default_backend()
    )
    public_key = private_key.public_key()
    return private_key, public_key

def sign_message(message, private_key):
    # Sign the message with the private key
    signature = private_key.sign(
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    return signature

def verify_signature(message, signature, public_key):
    # Verify the signature with the public key
    try:
        public_key.verify(
            signature,
            message,
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        print("Signature verification successful. Message is authentic.")
    except:
        print("Signature verification failed. Message may be tampered with or signature is invalid.")

def main():
    # Generate RSA key pair
    private_key, public_key = generate_key_pair()

    # Message to be signed
    message = b"Hello, digital signatures!"

    # Sign the message with the private key
    signature = sign_message(message, private_key)

    # Verify the signature with the public key
    verify_signature(message, signature, public_key)

if __name__ == "__main__":
    main()

输出

Signature verification successful. Message is authentic.

在此脚本中：

`generate_key_pair` 函数生成 RSA 密钥对（私钥和公钥）。
`sign_message` 函数使用私钥对消息进行签名。
`verify_signature` 函数使用公钥验证消息的签名。
在 `main` 函数中，会生成密钥对，并对消息进行签名然后验证。如果签名验证失败，则表明消息已被篡改或签名无效。

此示例演示了在 Python 中使用 RSA 和 SHA-256 实现数字签名的基本方法。

Python 中固件更新的校验和

在固件更新过程中，可以使用校验和来验证安装前固件文件的完整性。让我们创建一个 Python 脚本来演示如何使用校验和来验证固件更新。

import hashlib

def calculate_checksum(filename):
    # Calculate SHA-256 checksum of the file
    hasher = hashlib.sha256()
    with open(filename, 'rb') as file:
        while True:
            data = file.read(4096)  # Read data in chunks for memory efficiency
            if not data:
                break
            hasher.update(data)
    return hasher.hexdigest()

def verify_checksum(filename, expected_checksum):
    # Calculate checksum of the file
    actual_checksum = calculate_checksum(filename)

    # Compare the actual checksum with the expected checksum
    if actual_checksum == expected_checksum:
        print("Checksum verification successful. Firmware integrity verified.")
    else:
        print("Checksum verification failed. Firmware may be corrupted or tampered with.")

def main():
    # Firmware file to be verified
    firmware_file = "firmware_update.bin"

    # Expected checksum value provided by the firmware distributor
    expected_checksum = "b183f1b24825d3f3f8c40eaf3e184dce13265fbf42f3e0cc1e94ec55a8d5836d"

    # Verify the checksum of the firmware file
    verify_checksum(firmware_file, expected_checksum)

if __name__ == "__main__":
    main()

输出

Checksum verification successful. Firmware integrity verified.

在此脚本中：

`calculate_checksum` 函数计算固件文件的 SHA-256 校验和。
`verify_checksum` 函数将固件文件的实际校验和与固件分发者提供的预期校验和进行比较。
在 `main` 函数中，您指定要验证的固件文件名（`firmware_update.bin`）以及固件分发者提供的预期校验和值。然后调用 `verify_checksum` 函数来验证固件文件的完整性。

此示例演示了如何使用校验和来确保安装前固件更新的完整性，有助于防止安装已损坏或被篡改的固件。

替代方案

虽然校验和通常用于验证数据完整性，但也有其他类似目的的方法和技术。以下是一些替代方案：

加密哈希函数：SHA-256 和 MD5 等加密哈希函数广泛用于数据完整性验证。它们根据输入数据生成固定大小的哈希值（摘要）。与简单校验和不同，加密哈希函数设计为抗碰撞，并提供更强的安全性保证。它们通常用于数字签名、密码哈希和区块链技术。
消息认证码 (MACs)：MACs 是用于验证消息完整性和真实性的加密构造。它们涉及发件人和收件人之间共享的秘密密钥。HMAC（基于哈希的消息认证码）是一种广泛使用的 MAC 算法，它将加密哈希函数与秘密密钥结合起来生成 MAC。与简单校验和相比，MAC 提供了更强的安全性保证。
数字签名：数字签名提供数据完整性、真实性和不可否认性。它们涉及非对称加密，其中发件人使用其私钥对数据进行签名，收件人使用发件人的公钥验证签名。数字签名通常用于安全通信协议、文档签名和软件分发。
纠错码：与仅检测错误的校验和不同，纠错码 (ECC) 既可以检测也可以纠正数据中的错误。ECC 向数据添加冗余信息，即使存在噪声或损坏，也可以检测和纠正错误。ECC 通常用于存储系统、通信协议和 RAM 模块以提高数据可靠性。
区块链技术：区块链是一种去中心化和分布式账本技术，用于以安全且防篡改的方式记录多个节点上的交易。区块链中的每个块都包含前一个块的加密哈希，从而形成一个通过加密链接在一起的块链。区块链技术提供了强大的数据完整性和不变性保证，并通常用于加密货币系统、供应链管理和数字资产管理。
奇偶校验：奇偶校验是一种简单的错误检测技术，通常用于内存系统和数据传输。在奇偶校验中，会向数据添加一个额外的奇偶校验位，以确保数据中 1 的总数（包括奇偶校验位）始终是偶数或奇数，具体取决于所使用的奇偶校验方案。奇偶校验可以检测单比特错误，但不能纠正它们。
循环冗余校验 (CRC)：CRC 是一种校验和，它使用多项式除法来检测数据传输或存储中的错误。CRC 算法比简单校验和更复杂，并提供更强的错误检测能力。它们广泛用于通信协议（如以太网和 Wi-Fi）、存储系统和纠错码。
哈希树（Merkle 树）：哈希树，也称为 Merkle 树，是一种用于高效验证大型数据集完整性的数据结构。在哈希树中，每个叶节点包含数据块的哈希，每个非叶节点包含其子节点的哈希。哈希树允许高效安全地验证数据完整性，尤其是在分布式系统和点对点网络中。
数字水印：数字水印是一种将不可感知的信息（水印）嵌入到数字内容（如图像、音频或视频文件）中的技术。水印包含可用于验证内容真实性或完整性的数据。数字水印通常用于版权保护、身份验证和篡改检测。
独立磁盘冗余阵列 (RAID)：RAID 是一种存储技术，它将多个磁盘驱动器组合成一个逻辑单元，用于数据冗余、性能提升或两者兼而有之。RAID 系统使用镜像（RAID 1）、带奇偶校验的条带化（RAID 5）或镜像和条带化（RAID 10）等技术来提供容错能力和数据完整性。
数据验证协议：数据验证协议，例如安全文件传输协议 (SFTP) 或 PGP（极其好的隐私）协议，提供了在传输或存储期间验证数据完整性和真实性的机制。这些协议通常结合使用数字签名、哈希函数和加密等加密技术来确保数据完整性和安全性。

这些替代方案中的每一种都为数据完整性验证提供了独特的功能和优势，而选择取决于所需的安全性级别、数据的性质以及特定的用例或应用程序等因素。仔细评估这些替代方案以选择最适合您需求的解决方案至关重要。

下一主题Python 中的 Importlib 包

使用Python实现校验和

使用Python实现校验和

优点

用例

Python 中校验和的网络通信

Python 中校验和的文件传输协议

Python 中校验和的数据存储系统

Python 中校验和的软件分发

Python 中校验和的数据备份和归档

Python 中校验和的数字签名

Python 中固件更新的校验和

替代方案

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

其他

使用Python实现校验和

使用Python实现校验和

优点

用例

Python 中校验和的网络通信

Python 中校验和的文件传输协议

Python 中校验和的数据存储系统

Python 中校验和的软件分发

Python 中校验和的数据备份和归档

Python 中校验和的数字签名

Python 中固件更新的校验和

替代方案

相关帖子

Python Try Except

使用Python将文本文件转换为DataFrame

Python中的NumPy Vectorize

Python中的OverflowError

Python 偏硬币抛掷模拟程序

使用Python Pandas和NumPy创建条件列的方法

嵌入IPython

Python中将字典转换为DataFrame

Python中的Wavio模块

如何修复：Python中未找到名为Pandas的模块

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器