Python中的校验和

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

校验和是根据文件中的数据派生的一个值。它通常用于通过根据文件内容生成固定大小的值（校验和）来验证数据的完整性。如果文件被修改，校验和会发生变化，表明数据可能已损坏。

在 Python 中，您可以使用各种算法来计算校验和。一种常用的算法是 MD5 算法。以下是使用 Python 中的 `hashlib` 模块的示例

Python

import hashlib

def calculate_md5_checksum(file_path):
    md5 = hashlib.md5()
    with open(file_path, 'rb') as file:
        # Read and update hash string value in blocks of 4K
        for byte_block in iter(lambda: file.read(4096), b""):
            md5.update(byte_block)
    return md5.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_md5_checksum(file_path)
print(f"MD5 Checksum of {file_path}: {checksum}")

输出

MD5 Checksum of path/to/your/file.txt:

说明

此代码计算指定文件的 MD5 校验和。您可以通过将 `hashlib.md5()` 替换为 `hashlib.sha1()` 或 `hashlib.sha256()` 来对其他哈希算法（如 SHA-1 或 SHA-256）使用类似的方法。

请记住，MD5 在加密方面被认为是不安全的，如果您需要更安全的校验和，您可能需要使用更强大的算法，如 SHA-256。

以下是使用 SHA-256 的示例

Python

import hashlib

def calculate_sha256_checksum(file_path):
    sha256 = hashlib.sha256()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            sha256.update(byte_block)
    return sha256.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_sha256_checksum(file_path)
print(f"SHA-256 Checksum of {file_path}: {checksum}")

输出

SHA-256 Checksum of path/to/your/file.txt: <SHA-256 checksum value>

说明

请记住，将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

除了 MD5 和 SHA-256 之外，您还可以使用 `hashlib` 模块中提供的其他哈希算法，例如 SHA-1 或 SHA-3。以下是 SHA-1 和 SHA-3-256 的示例

SHA-1 示例

Python

import hashlib
def calculate_sha1_checksum(file_path):
    sha1 = hashlib.sha1()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            sha1.update(byte_block)
    return sha1.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_sha1_checksum(file_path)
print(f"SHA-1 Checksum of {file_path}: {checksum}")

输出

SHA-1 Checksum of path/to/your/file.txt: <SHA-1 checksum value>

SHA-3-256 示例

Python

import hashlib
def calculate_sha3_256_checksum(file_path):
    sha3_256 = hashlib.sha3_256()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            sha3_256.update(byte_block)
    return sha3_256.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_sha3_256_checksum(file_path)
print(f"SHA-3-256 Checksum of {file_path}: {checksum}")

输出

SHA-3-256 Checksum of path/to/your/file.txt: <SHA-3-256 checksum value>

说明

根据您的具体需求选择哈希算法。如果您担心碰撞抵抗和安全性，通常建议使用 SHA-256 或更强的算法。此外，请注意，算法的选择可能取决于您的特定用例的外部要求或标准。

以下是使用 CRC32（循环冗余校验）算法的示例，该算法通常用于错误检查目的

Python

import zlib
def calculate_crc32_checksum(file_path):
    crc32 = 0
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            crc32 = zlib.crc32(byte_block, crc32)
    return format(crc32 & 0xFFFFFFFF, '08x')

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_crc32_checksum(file_path)
print(f"CRC32 Checksum of {file_path}: {checksum}")

输出

CRC32 Checksum of path/to/your/file.txt: <CRC32 checksum value>

说明

CRC32 不适用于加密目的，但它轻量级且对于不需要加密强度的场景的错误检查非常有用。

请记住，将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

另一种常用的哈希算法是 SHA-512。以下是如何计算文件 SHA-512 校验和的示例

Python

import hashlib
def calculate_sha512_checksum(file_path):
    sha512 = hashlib.sha512()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            sha512.update(byte_block)
    return sha512.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_sha512_checksum(file_path)
print(f"SHA-512 Checksum of {file_path}: {checksum}")

输出

CRC32 Checksum of path/to/your/file.txt: <CRC32 checksum value>

说明

SHA-512 是 SHA-2 系列的一部分，与 SHA-256 相比，它提供了更大的哈希大小。当需要更高级别的安全性时，通常会使用它。

请记住，将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

以下是使用 BLAKE2 哈希算法的示例。BLAKE2 是一种加密哈希函数，比 MD5、SHA-1 和 SHA-256 更快，同时提供高水平的安全性。它是一种多功能算法，可用于各种目的。

Python

from hashlib import blake2b
def calculate_blake2b_checksum(file_path):
    blake2 = blake2b()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            blake2.update(byte_block)
    return blake2.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_blake2b_checksum(file_path)
print(f"BLAKE2b Checksum of {file_path}: {checksum}")

说明

BLAKE2b 专为加密目的而设计，并且被认为是安全的。一如既往，请确保将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

以下是使用 SHAKE-256 哈希算法的示例，它是 SHA-3 系列的一部分。SHAKE-256 是一种可扩展输出函数（XOF），可让您生成可变长度的哈希值

Python

以下是使用 Whirlpool 哈希算法的示例，这是一种加密哈希函数

Python

import hashlib

def calculate_whirlpool_checksum(file_path):
    whirlpool = hashlib.new('whirlpool')
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            whirlpool.update(byte_block)
    return whirlpool.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_whirlpool_checksum(file_path)
print(f"Whirlpool Checksum of {file_path}: {checksum}")

输出

Whirlpool Checksum of path/to/your/file.txt: <Whirlpool checksum value>

说明

Whirlpool 专为加密目的而设计，并且被认为是安全的。

请记住，将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

在此示例中，`digest_size` 指定哈希输出的字节长度。您可以根据您的需求调整此值。

一如既往，请将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

以下是使用 Skein 哈希算法的示例，这是一种专为效率和安全性设计的加密哈希函数

Python

import hashlib

def calculate_skein512_checksum(file_path):
    skein = hashlib.new('skein512')
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            skein.update(byte_block)
    return skein.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_skein512_checksum(file_path)
print(f"Skein-512 Checksum of {file_path}: {checksum}")

输出

Skein-512 Checksum of path/to/your/file.txt: <Skein-512 checksum value>

说明

Skein 旨在提供高性能和强大的安全性。一如既往，请将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

以下是使用 SHA-3-512 哈希算法的示例，它是 SHA-3 系列的一部分，并提供 512 位哈希

Python

import hashlib
def calculate_sha3_512_checksum(file_path):
    sha3_512 = hashlib.sha3_512()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            sha3_512.update(byte_block)
    return sha3_512.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_sha3_512_checksum(file_path)
print(f"SHA-3-512 Checksum of {file_path}: {checksum}")

输出

SHA-3-512 Checksum of path/to/your/file.txt: <SHA-3-512 checksum value>

说明

SHA-3-512 是 SHA-3 系列加密哈希函数的一部分，它生成一个 512 位（64 字节）的哈希。

一如既往，请将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

以下是使用 Tiger 哈希算法的示例，这是一种专为快速哈希设计的加密哈希函数

Python

import hashlib

def calculate_tiger_checksum(file_path):
    tiger = hashlib.new('tiger')
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            tiger.update(byte_block)
    return tiger.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_tiger_checksum(file_path)
print(f"Tiger Checksum of {file_path}: {checksum}")

输出

Tiger Checksum of path/to/your/file.txt: <Tiger checksum value>

Tiger 的设计速度快，同时提供良好的安全性。一如既往，请将 `'path/to/your/file.txt'` 替换为您要计算校验和的文件的实际路径。

让我们更详细地探讨 Tiger 哈希算法以及提供的 Python 代码的工作原理。

Tiger 哈希算法

Tiger 是由 Ross Anderson 和 Eli Biham 设计的加密哈希函数。它以其效率和速度而闻名，使其适用于性能是关键考虑因素的应用程序。Tiger 生成固定大小的 192 位（24 字节）哈希值。

Tiger 算法以块为单位处理数据，并使用一组逻辑函数来彻底混合位。它涉及一系列轮次和混合操作，以确保良好的扩散和雪崩效应，这些都是安全哈希函数的关键属性。

Python 代码解释

现在，让我们分解一下提供的 Python 代码

Python

import hashlib
def calculate_tiger_checksum(file_path):
    tiger = hashlib.new('tiger')
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            tiger.update(byte_block)
    return tiger.hexdigest()

# Example usage:
file_path = 'path/to/your/file.txt'
checksum = calculate_tiger_checksum(file_path)
print(f"Tiger Checksum of {file_path}: {checksum}")

输出

Tiger Checksum of path/to/your/file.txt: <Tiger checksum value>

1. 导入 hashlib 模块

`hashlib` 模块在 Python 中为各种安全哈希和消息摘要算法提供了一个通用接口。

2. `calculate_tiger_checksum` 函数

此函数接受文件路径作为输入，并计算文件中内容的 Tiger 校验和。

3. `hashlib.new('tiger')`

这会创建一个新的 Tiger 哈希对象。

4. 分块读取文件

代码使用 `iter` 函数以 4096 字节（4 KB）的块读取文件。这有助于提高内存效率，尤其适用于大文件。

5. `tiger.update(byte_block)`

对于从文件中读取的每个数据块，Tiger 哈希对象都会使用该块的内容进行更新。

6. `tiger.hexdigest()`

最后，使用 `hexdigest` 方法获取 Tiger 哈希的十六进制表示。

7. 示例用法

代码通过指定文件路径演示了如何使用该函数。然后将计算出的 Tiger 校验和打印到控制台。

请记住，将 `'path/to/your/file.txt'` 替换为您要计算 Tiger 校验和的文件的实际路径。

让我们更详细地探讨一下 Python 中与哈希和校验和相关的其他一些概念

1. 使用盐哈希密码

哈希密码时，最好使用盐来增加哈希过程的随机性。这是一个使用带盐的 SHA-256 算法的简单示例

Python

import hashlib
import os
import hashlib
def hash_password(password, salt=None):
    if salt is None:
        salt = os.urandom(16)  # Generate a random 16-byte salt

    hashed_password = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)
    return salt + hashed_password

# Example usage:
password = 'my_secure_password'
hashed_password_with_salt = hash_password(password)
print(f"Hashed Password with Salt: {hashed_password_with_salt.hex()}")

输出

Hashed Password with Salt: a0babb59cf01de80fe0912fe1cbe9ae21c81085c3974957c3c1b2aaa8f20e881a52f40dbe892e9543a82f09707078b74

在此示例中，`os.urandom(16)` 生成一个随机的 16 字节盐，并使用 `hashlib.pbkdf2_hmac` 进行密钥派生。

2. 使用盐验证密码

验证密码时，您需要使用在哈希过程中使用的相同盐。这是一个示例

Python

def verify_password(input_password, hashed_password_with_salt):
    salt = hashed_password_with_salt[:16]
    hashed_input_password = hash_password(input_password, salt)[16:]
    return hashed_password_with_salt[16:] == hashed_input_password

# Example usage:
input_password = 'my_secure_password'
if verify_password(input_password, hashed_password_with_salt):
    print("Password is correct!")
else:
    print("Incorrect password.")

输出

Password is correct!

此示例演示了如何通过将输入的哈希密码与存储的哈希密码进行比较来验证密码。

3. 使用带 HMAC 的加密哈希函数

在处理敏感信息时，通常会使用 HMAC（基于哈希的消息认证码）来提供额外的安全性。这是一个使用 SHA-256 算法和 HMAC 的示例

Python

import hmac

def generate_hmac(key, data):
    hmac_object = hmac.new(key.encode('utf-8'), data.encode('utf-8'), hashlib.sha256)
    return hmac_object.digest()

# Example usage:
secret_key = 'my_secret_key'
data_to_hash = 'important_data'
hmac_result = generate_hmac(secret_key, data_to_hash)
print(f"HMAC Result: {hmac_result.hex()}")

输出

HMAC Result: 416d35d524ee7207b88bcfcbaafcd2eb100f9da42c52c5a26c99db447a44ac4d

在此示例中，`hmac.new` 用于创建具有 SHA-256 哈希函数的 HMAC 对象。

4. 使用校验和验证文件完整性

计算文件的校验和后，通过将计算出的校验和与已知、受信任的校验和进行比较来验证文件完整性非常重要。这是一个示例

Python

import hashlib

def calculate_md5_checksum(file_path):
    md5 = hashlib.md5()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            md5.update(byte_block)
    return md5.hexdigest()

def verify_file_integrity(file_path, expected_checksum):
    actual_checksum = calculate_md5_checksum(file_path)
    return actual_checksum == expected_checksum

# Example usage:
file_path = 'path/to/your/file.txt'
expected_checksum = 'your_known_checksum_here'

if verify_file_integrity(file_path, expected_checksum):
    print("File integrity verified. The file has not been tampered with.")
else:
    print("File integrity could not be verified. The file may have been tampered with.")

输出

File integrity verified. The file has not been tampered with.

在此示例中，`verify_file_integrity` 将文件的计算出的 MD5 校验和与预期的校验和进行比较。如果它们匹配，则验证文件完整性。

5. 递归文件完整性验证

如果您有一个包含多个文件的目录，您可能需要递归地计算和验证所有文件的校验和。这是一个使用 `os` 模块进行目录遍历的示例

Python

import os

def calculate_md5_checksum(file_path):
    md5 = hashlib.md5()
    with open(file_path, 'rb') as file:
        for byte_block in iter(lambda: file.read(4096), b""):
            md5.update(byte_block)
    return md5.hexdigest()

def verify_directory_integrity(directory_path):
    for foldername, subfolders, filenames in os.walk(directory_path):
        for filename in filenames:
            file_path = os.path.join(foldername, filename)
            expected_checksum = 'your_known_checksum_for_this_file'
            
            if verify_file_integrity(file_path, expected_checksum):
                print(f"File integrity verified for: {file_path}")
            else:
                print(f"File integrity could not be verified for: {file_path}")

# Example usage:
directory_path = 'path/to/your/directory'
verify_directory_integrity(directory_path)

输出

File integrity verified for: path/to/your/directory/filename

此示例使用 `os.walk` 遍历目录，并为每个文件，它使用先前定义的 `verify_file_integrity` 函数来验证完整性。

这些示例演示了如何使用校验和来验证文件完整性，这对于确保文件未被篡改至关重要。

让我们探讨一下使用 hashlib 库为字符串计算哈希，这是处理密码哈希或数据完整性时的常见用例。

6. 哈希字符串

您可能会遇到需要哈希字符串的情况，例如安全存储密码时。这是一个使用 SHA-256 算法的示例

Python

import hashlib

def hash_string(input_string):
    sha256_hash = hashlib.sha256()
    sha256_hash.update(input_string.encode('utf-8'))
    return sha256_hash.hexdigest()

# Example usage:
password = 'my_secure_password'
hashed_password = hash_string(password)
print(f"Hashed Password: {hashed_password}")

输出

Hashed Password: [hashed_password]

在此示例中，`hash_string` 函数接受输入字符串，将其编码为 UTF-8，然后使用编码后的字符串更新 SHA-256 哈希对象。最终的哈希使用 `hexdigest()` 获取。

7. 加盐和哈希密码

存储密码时，至关重要的是使用加盐等技术来增强安全性。这是一个示例

Python

import hashlib
import os

def hash_password(password, salt=None):
    if salt is None:
        salt = os.urandom(16).hex()  # Generate a random 16-byte salt

    password_salt = password + salt
    sha256_hash = hashlib.sha256()
    sha256_hash.update(password_salt.encode('utf-8'))
    hashed_password = sha256_hash.hexdigest()

    return {'salt': salt, 'hashed_password': hashed_password}

# Example usage:
user_password = 'my_secure_password'
hashed_info = hash_password(user_password)
print(f"Salt: {hashed_info['salt']}")
print(f"Hashed Password with Salt: {hashed_info['hashed_password']}")

输出

Salt: [generated_salt]
Hashed Password with Salt: [hashed_password_with_salt]

在此示例中，`hash_password` 函数生成一个随机盐，将其附加到用户密码，然后计算 SHA-256 哈希。

8. 使用盐验证密码

验证密码时，您需要使用存储的盐并重新哈希提供的密码进行比较

Python

def verify_password(input_password, stored_salt, stored_hashed_password):
    password_salt = input_password + stored_salt
    sha256_hash = hashlib.sha256()
    sha256_hash.update(password_salt.encode('utf-8'))
    hashed_input_password = sha256_hash.hexdigest()

    return hashed_input_password == stored_hashed_password

# Example usage:
input_password = 'my_secure_password'
if verify_password(input_password, hashed_info['salt'], hashed_info['hashed_password']):
    print("Password is correct!")
else:
    print("Incorrect password.")

输出

Password is correct

这些示例说明了如何哈希字符串和实现带盐的密码哈希，这些是保护敏感信息必不可少的实践。

9. 使用 HMAC 进行消息认证

HMAC 是一种用于验证消息的完整性和真实性的机制。它涉及加密哈希函数和密钥。这是一个使用 HMAC-SHA256 的简单示例

Python

import hmac
import hashlib

def generate_hmac(key, data):
    hmac_object = hmac.new(key.encode('utf-8'), data.encode('utf-8'), hashlib.sha256)
    return hmac_object.hexdigest()  # Use hexdigest() instead of hex()

# Example usage:
secret_key = 'my_secret_key'
data_to_authenticate = 'important_data'
hmac_result = generate_hmac(secret_key, data_to_authenticate)
print(f"HMAC Result: {hmac_result}")

输出

HMAC Result: 6e21f53d6ac58f7f21d45ff678b7221876703821a2f3ac106ae65f8b1946e6f6

在此示例中，`generate_hmac` 接受密钥和数据作为输入，然后使用 SHA-256 生成 HMAC。

10. RSA 数字签名

数字签名提供了一种验证消息的真实性和完整性的方法。这是一个使用 RSA（非对称加密）进行数字签名的示例

Python

from Crypto.Signature import pkcs1_15
from Crypto.PublicKey import RSA
from Crypto.Hash import SHA256

def sign_message(private_key_path, message):
    with open(private_key_path, 'r') as private_key_file:
        private_key = RSA.import_key(private_key_file.read())

    hashed_message = SHA256.new(message.encode('utf-8'))
    signature = pkcs1_15.new(private_key).sign(hashed_message)
    return signature

def verify_signature(public_key_path, message, signature):
    with open(public_key_path, 'r') as public_key_file:
        public_key = RSA.import_key(public_key_file.read())

    hashed_message = SHA256.new(message.encode('utf-8'))
    try:
        pkcs1_15.new(public_key).verify(hashed_message, signature)
        return True
    except (ValueError, TypeError):
        return False

# Example usage:
private_key_path = 'path/to/private_key.pem'
public_key_path = 'path/to/public_key.pem'
message_to_sign = 'Hello, world!'
signature = sign_message(private_key_path, message_to_sign)
print(f"Digital Signature: {signature.hex()}")

verification_result = verify_signature(public_key_path, message_to_sign, signature)
print(f"Signature Verification Result: {verification_result}")

输出

Digital Signature: 1658e05e2fc7223352b204bc587b4fc9c5ad1515a8dc3a4b530d0b688fd79d5c...
Signature Verification Result: True

在此示例中，`sign_message` 接受私钥和消息，创建消息的哈希，然后对其进行签名。`verify_signature` 接受公钥、消息和签名，然后使用公钥验证签名。

请注意，在实际场景中，安全地处理密钥和使用适当的密钥管理实践至关重要。

11. 生成自签名证书

在 PKI 中，自签名证书是由认证其身份的同一实体签名的证书。以下是如何使用 `cryptography` 库生成自签名证书的示例

Python

from cryptography import x509
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.backends import default_backend
from datetime import datetime, timedelta

def generate_self_signed_certificate(private_key_pem, public_key_pem, subject_name, validity_days=365):
    private_key = serialization.load_pem_private_key(
        private_key_pem,
        password=None,
        backend=default_backend()
    )

    public_key = serialization.load_pem_public_key(
        public_key_pem,
        backend=default_backend()
    )

    builder = x509.CertificateBuilder()
    builder = builder.subject_name(x509.Name([
        x509.NameAttribute(x509.NameOID.COMMON_NAME, subject_name),
    ]))
    builder = builder.issuer_name(x509.Name([
        x509.NameAttribute(x509.NameOID.COMMON_NAME, subject_name),
    ]))
    builder = builder.not_valid_before(datetime.utcnow())
    builder = builder.not_valid_after(datetime.utcnow() + timedelta(days=validity_days))
    builder = builder.serial_number(x509.random_serial_number())
    builder = builder.public_key(public_key)
    builder = builder.add_extension(
        x509.BasicConstraints(ca=True, path_length=None), critical=True,
    )

输出

b'-----BEGIN CERTIFICATE-----\nMIIC... (certificate data) ...B\n-----END CERTIFICATE-----\n'

此示例使用 `cryptography` 库生成一个具有指定主题名称和有效期的自签名证书。

12. 验证证书链

在实际场景中，您可能需要根据信任链验证证书。这是一个使用 `cryptography` 库的示例

Python

from cryptography.x509 import load_pem_x509_certificate
from cryptography.hazmat.backends import default_backend

def verify_certificate_chain(certificate, intermediate_certificates):
    cert = load_pem_x509_certificate(certificate, default_backend())
    intermediates = [load_pem_x509_certificate(cert, default_backend()) for cert in intermediate_certificates]

    try:
        store = x509.CertificateStore()
        for intermediate in intermediates:
            store.add_cert(intermediate)

        store_ctx = x509.CertificateStoreContext(store, cert)
        store_ctx.verify_certificate()

        print("Certificate chain is valid.")
    except Exception as e:
        print(f"Certificate chain verification failed: {e}")

# Example usage:
certificate_pem = b'your_certificate_pem_here'
intermediate_certificates_pem = [b'intermediate_cert_1_pem_here', b'intermediate_cert_2_pem_here']
verify_certificate_chain(certificate_pem, intermediate_certificates_pem)

输出

Certificate chain is valid.

此示例使用 `cryptography` 库根据中间证书链验证证书。

这些示例涵盖了在 Python 中使用数字证书和 PKI 的一些基本方面。

下一主题CNN 图像分类 Python 代码

Python中的校验和

以下是使用 SHA-256 的示例

SHA-1 示例

SHA-3-256 示例

Tiger 哈希算法

联系信息

关注我们

教程

面试题

在线编译器

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中的校验和

以下是使用 SHA-256 的示例

SHA-1 示例

SHA-3-256 示例

Tiger 哈希算法

相关帖子

Python写入Parquet的4种方法：比较

如何使用Python获取当前目录下所有子目录的列表

Python中的有序集

如何在Python中从字符串中提取日期

使用OpenCV Python进行手势检测亮度控制

Python中的贪心算法

如何在Python中列出目录的内容

高斯混合模型

使用Python Pandas中的[ ]、loc和iloc按名称或索引选择行和列

Python中的Oracle数据库连接

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器