006-数字证书与PKI体系

006-数字证书与PKI体系

难度：🔴 | 预计时间：100分钟 | 前置：005-数字签名与消息认证

学习目标

• 理解数字证书的结构和作用机制
• 掌握PKI（公钥基础设施）的核心组件和工作流程
• 了解证书颁发机构（CA）的职责和信任模型
• 熟悉X.509证书标准和证书链验证
• 能够设计和部署PKI系统解决实际问题

内容正文

数字证书概述

数字证书（Digital Certificate）是由可信第三方（证书颁发机构CA）签发的电子文档，用于证明公钥的所有者身份，解决公钥分发和认证问题。

数字证书的作用

graph TD
    A[公钥分发问题] --> B[如何确保公钥真实性？]
    B --> C[中间人攻击风险]
    
    D[数字证书解决方案] --> E[可信第三方CA]
    E --> F[证书签发]
    F --> G[身份绑定]
    G --> H[公钥认证]
    
    I[证书验证] --> J[检查CA签名]
    J --> K[验证证书链]
    K --> L[确认身份真实性]
    
    style C fill:#ff9999
    style H fill:#99ff99

数字证书的核心功能

功能	描述	实现方式
身份认证	证明公钥所有者身份	CA签名验证
完整性保护	防止证书被篡改	数字签名
不可否认性	证书持有者无法否认	CA权威签发
信任传递	通过信任链建立信任	证书链验证

X.509证书标准

X.509是最广泛使用的数字证书标准，定义了证书的格式和内容。

X.509证书结构

X.509证书字段详解

# 文件路径: crypto/x509_parser.py
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
import datetime

def parse_x509_certificate(cert_data):
    """解析X.509证书"""
    if isinstance(cert_data, str):
        cert_data = cert_data.encode()
    
    # 加载证书
    cert = x509.load_pem_x509_certificate(cert_data)
    
    # 提取证书信息
    cert_info = {
        'version': cert.version.name,
        'serial_number': str(cert.serial_number),
        'signature_algorithm': cert.signature_algorithm_oid._name,
        'issuer': cert.issuer.rfc4514_string(),
        'subject': cert.subject.rfc4514_string(),
        'not_valid_before': cert.not_valid_before,
        'not_valid_after': cert.not_valid_after,
        'public_key_algorithm': cert.public_key().__class__.__name__,
        'public_key_size': cert.public_key().key_size if hasattr(cert.public_key(), 'key_size') else 'N/A'
    }
    
    # 提取扩展字段
    extensions = {}
    for ext in cert.extensions:
        try:
            extensions[ext.oid._name] = str(ext.value)
        except:
            extensions[ext.oid._name] = 'Unable to parse'
    
    cert_info['extensions'] = extensions
    
    return cert_info

def create_self_signed_certificate():
    """创建自签名证书示例"""
    from cryptography.hazmat.primitives.asymmetric import rsa
    from cryptography.x509.oid import NameOID
    
    # 生成私钥
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    
    # 创建证书主体
    subject = issuer = x509.Name([
        x509.NameAttribute(NameOID.COUNTRY_NAME, "CN"),
        x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Beijing"),
        x509.NameAttribute(NameOID.LOCALITY_NAME, "Beijing"),
        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Test Organization"),
        x509.NameAttribute(NameOID.COMMON_NAME, "test.example.com"),
    ])
    
    # 创建证书
    cert = x509.CertificateBuilder().subject_name(
        subject
    ).issuer_name(
        issuer
    ).public_key(
        private_key.public_key()
    ).serial_number(
        x509.random_serial_number()
    ).not_valid_before(
        datetime.datetime.utcnow()
    ).not_valid_after(
        datetime.datetime.utcnow() + datetime.timedelta(days=365)
    ).add_extension(
        x509.SubjectAlternativeName([
            x509.DNSName("test.example.com"),
            x509.DNSName("www.test.example.com"),
        ]),
        critical=False,
    ).add_extension(
        x509.BasicConstraints(ca=False, path_length=None),
        critical=True,
    ).add_extension(
        x509.KeyUsage(
            digital_signature=True,
            key_encipherment=True,
            key_agreement=False,
            key_cert_sign=False,
            crl_sign=False,
            content_commitment=False,
            data_encipherment=False,
            encipher_only=False,
            decipher_only=False
        ),
        critical=True,
    ).sign(private_key, hashes.SHA256())
    
    return cert, private_key

# 示例使用
if __name__ == "__main__":
    # 创建自签名证书
    cert, private_key = create_self_signed_certificate()
    
    # 序列化证书
    cert_pem = cert.public_bytes(serialization.Encoding.PEM)
    print("生成的证书:")
    print(cert_pem.decode())
    
    # 解析证书
    cert_info = parse_x509_certificate(cert_pem)
    print("\n证书信息:")
    for key, value in cert_info.items():
        if key != 'extensions':
            print(f"{key}: {value}")
    
    print("\n扩展字段:")
    for ext_name, ext_value in cert_info['extensions'].items():
        print(f"{ext_name}: {ext_value}")

重要的X.509扩展字段

扩展字段	OID	用途	关键性
基本约束	2.5.29.19	标识是否为CA证书	关键
密钥用法	2.5.29.15	定义密钥的允许用途	关键
扩展密钥用法	2.5.29.37	更具体的密钥用途	非关键
主体备用名称	2.5.29.17	额外的主体标识	非关键
颁发者备用名称	2.5.29.18	额外的颁发者标识	非关键
CRL分发点	2.5.29.31	CRL下载地址	非关键
权威信息访问	1.3.6.1.5.5.7.1.1	OCSP和CA证书地址	非关键

PKI体系架构

PKI（Public Key Infrastructure，公钥基础设施）是支持公钥密码学应用的完整框架。

PKI核心组件

CA（证书颁发机构）

CA是PKI的核心，负责证书的签发、管理和撤销。

CA的职责

# 文件路径: crypto/ca_operations.py
import datetime
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID, ExtensionOID

class CertificateAuthority:
    """证书颁发机构类"""
    
    def __init__(self, ca_cert, ca_private_key):
        self.ca_cert = ca_cert
        self.ca_private_key = ca_private_key
        self.issued_certificates = []
        self.revoked_certificates = []
    
    def issue_certificate(self, subject_name, public_key, validity_days=365, 
                         extensions=None):
        """签发证书"""
        # 生成序列号
        serial_number = x509.random_serial_number()
        
        # 设置有效期
        not_valid_before = datetime.datetime.utcnow()
        not_valid_after = not_valid_before + datetime.timedelta(days=validity_days)
        
        # 创建证书构建器
        builder = x509.CertificateBuilder()
        builder = builder.subject_name(subject_name)
        builder = builder.issuer_name(self.ca_cert.subject)
        builder = builder.public_key(public_key)
        builder = builder.serial_number(serial_number)
        builder = builder.not_valid_before(not_valid_before)
        builder = builder.not_valid_after(not_valid_after)
        
        # 添加基本扩展
        builder = builder.add_extension(
            x509.BasicConstraints(ca=False, path_length=None),
            critical=True
        )
        
        builder = builder.add_extension(
            x509.KeyUsage(
                digital_signature=True,
                key_encipherment=True,
                key_agreement=False,
                key_cert_sign=False,
                crl_sign=False,
                content_commitment=False,
                data_encipherment=False,
                encipher_only=False,
                decipher_only=False
            ),
            critical=True
        )
        
        # 添加颁发者密钥标识
        builder = builder.add_extension(
            x509.AuthorityKeyIdentifier.from_issuer_public_key(
                self.ca_cert.public_key()
            ),
            critical=False
        )
        
        # 添加主体密钥标识
        builder = builder.add_extension(
            x509.SubjectKeyIdentifier.from_public_key(public_key),
            critical=False
        )
        
        # 添加自定义扩展
        if extensions:
            for extension in extensions:
                builder = builder.add_extension(extension['extension'], 
                                              extension['critical'])
        
        # 签发证书
        certificate = builder.sign(self.ca_private_key, hashes.SHA256())
        
        # 记录已签发证书
        self.issued_certificates.append({
            'serial_number': serial_number,
            'certificate': certificate,
            'issue_date': not_valid_before,
            'expiry_date': not_valid_after,
            'status': 'valid'
        })
        
        return certificate
    
    def revoke_certificate(self, serial_number, reason=x509.ReasonFlags.unspecified):
        """撤销证书"""
        revocation_date = datetime.datetime.utcnow()
        
        # 查找证书
        for cert_info in self.issued_certificates:
            if cert_info['serial_number'] == serial_number:
                cert_info['status'] = 'revoked'
                cert_info['revocation_date'] = revocation_date
                cert_info['revocation_reason'] = reason
                
                # 添加到撤销列表
                self.revoked_certificates.append({
                    'serial_number': serial_number,
                    'revocation_date': revocation_date,
                    'reason': reason
                })
                return True
        
        return False
    
    def generate_crl(self):
        """生成证书撤销列表"""
        builder = x509.CertificateRevocationListBuilder()
        builder = builder.issuer_name(self.ca_cert.subject)
        builder = builder.last_update(datetime.datetime.utcnow())
        builder = builder.next_update(
            datetime.datetime.utcnow() + datetime.timedelta(days=7)
        )
        
        # 添加撤销的证书
        for revoked_cert in self.revoked_certificates:
            revoked_cert_builder = x509.RevokedCertificateBuilder()
            revoked_cert_builder = revoked_cert_builder.serial_number(
                revoked_cert['serial_number']
            )
            revoked_cert_builder = revoked_cert_builder.revocation_date(
                revoked_cert['revocation_date']
            )
            revoked_cert_builder = revoked_cert_builder.add_extension(
                x509.CRLReason(revoked_cert['reason']),
                critical=False
            )
            
            builder = builder.add_revoked_certificate(
                revoked_cert_builder.build()
            )
        
        # 签名CRL
        crl = builder.sign(self.ca_private_key, hashes.SHA256())
        return crl

def create_root_ca():
    """创建根CA"""
    # 生成根CA私钥
    root_private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=4096
    )
    
    # 创建根CA证书
    root_subject = x509.Name([
        x509.NameAttribute(NameOID.COUNTRY_NAME, "CN"),
        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Root CA Organization"),
        x509.NameAttribute(NameOID.COMMON_NAME, "Root CA"),
    ])
    
    root_cert = x509.CertificateBuilder().subject_name(
        root_subject
    ).issuer_name(
        root_subject  # 自签名
    ).public_key(
        root_private_key.public_key()
    ).serial_number(
        x509.random_serial_number()
    ).not_valid_before(
        datetime.datetime.utcnow()
    ).not_valid_after(
        datetime.datetime.utcnow() + datetime.timedelta(days=3650)  # 10年
    ).add_extension(
        x509.BasicConstraints(ca=True, path_length=None),
        critical=True,
    ).add_extension(
        x509.KeyUsage(
            digital_signature=True,
            key_cert_sign=True,
            crl_sign=True,
            key_encipherment=False,
            key_agreement=False,
            content_commitment=False,
            data_encipherment=False,
            encipher_only=False,
            decipher_only=False
        ),
        critical=True,
    ).add_extension(
        x509.SubjectKeyIdentifier.from_public_key(root_private_key.public_key()),
        critical=False,
    ).sign(root_private_key, hashes.SHA256())
    
    return root_cert, root_private_key

# 示例使用
if __name__ == "__main__":
    # 创建根CA
    root_cert, root_private_key = create_root_ca()
    ca = CertificateAuthority(root_cert, root_private_key)
    
    print("根CA创建成功")
    print(f"根CA主体: {root_cert.subject.rfc4514_string()}")
    
    # 为用户签发证书
    user_private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    
    user_subject = x509.Name([
        x509.NameAttribute(NameOID.COUNTRY_NAME, "CN"),
        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "User Organization"),
        x509.NameAttribute(NameOID.COMMON_NAME, "user@example.com"),
    ])
    
    user_cert = ca.issue_certificate(
        subject_name=user_subject,
        public_key=user_private_key.public_key(),
        validity_days=365
    )
    
    print(f"\n用户证书签发成功")
    print(f"用户证书序列号: {user_cert.serial_number}")
    
    # 撤销证书
    ca.revoke_certificate(user_cert.serial_number, x509.ReasonFlags.key_compromise)
    print(f"证书已撤销")
    
    # 生成CRL
    crl = ca.generate_crl()
    print(f"CRL生成成功，包含 {len(crl)} 个撤销证书")

证书链和信任模型

证书链验证

# 文件路径: crypto/certificate_chain.py
from cryptography import x509
from cryptography.hazmat.primitives import hashes
from cryptography.exceptions import InvalidSignature

def verify_certificate_chain(cert_chain, trusted_roots):
    """验证证书链"""
    if not cert_chain:
        return False, "证书链为空"
    
    # 从叶子证书开始验证
    current_cert = cert_chain[0]
    
    for i in range(len(cert_chain)):
        if i == len(cert_chain) - 1:
            # 最后一个证书，需要在信任根中查找
            issuer_cert = None
            for root_cert in trusted_roots:
                if current_cert.issuer == root_cert.subject:
                    issuer_cert = root_cert
                    break
            
            if issuer_cert is None:
                return False, f"未找到可信的根证书"
        else:
            # 使用链中的下一个证书作为签发者
            issuer_cert = cert_chain[i + 1]
        
        # 验证证书签名
        try:
            issuer_public_key = issuer_cert.public_key()
            issuer_public_key.verify(
                current_cert.signature,
                current_cert.tbs_certificate_bytes,
                current_cert.signature_algorithm_oid._name
            )
        except InvalidSignature:
            return False, f"证书 {i} 签名验证失败"
        except Exception as e:
            return False, f"证书 {i} 验证出错: {str(e)}"
        
        # 检查证书有效期
        now = datetime.datetime.utcnow()
        if now < current_cert.not_valid_before:
            return False, f"证书 {i} 尚未生效"
        if now > current_cert.not_valid_after:
            return False, f"证书 {i} 已过期"
        
        # 检查颁发者和主体匹配
        if current_cert.issuer != issuer_cert.subject:
            return False, f"证书 {i} 颁发者与签发证书主体不匹配"
        
        # 移动到下一个证书
        current_cert = issuer_cert
    
    return True, "证书链验证成功"

def build_certificate_path(target_cert, intermediate_certs, trusted_roots):
    """构建证书路径"""
    path = [target_cert]
    current_cert = target_cert
    
    while True:
        # 检查是否已到达根证书
        if current_cert.issuer == current_cert.subject:
            # 自签名证书，检查是否在信任根中
            if current_cert in trusted_roots:
                break
            else:
                return None, "未找到有效的证书路径"
        
        # 查找签发者证书
        issuer_cert = None
        
        # 首先在中间证书中查找
        for cert in intermediate_certs:
            if current_cert.issuer == cert.subject:
                issuer_cert = cert
                break
        
        # 如果没找到，在信任根中查找
        if issuer_cert is None:
            for cert in trusted_roots:
                if current_cert.issuer == cert.subject:
                    issuer_cert = cert
                    break
        
        if issuer_cert is None:
            return None, "证书链中断，未找到签发者证书"
        
        # 避免循环
        if issuer_cert in path:
            return None, "证书链存在循环"
        
        path.append(issuer_cert)
        current_cert = issuer_cert
        
        # 防止无限循环
        if len(path) > 10:
            return None, "证书链过长"
    
    return path, "证书路径构建成功"

证书撤销机制

CRL（证书撤销列表）

# 文件路径: crypto/crl_operations.py
from cryptography import x509
from cryptography.hazmat.primitives import hashes
import datetime

def parse_crl(crl_data):
    """解析CRL"""
    if isinstance(crl_data, str):
        crl_data = crl_data.encode()
    
    crl = x509.load_pem_x509_crl(crl_data)
    
    crl_info = {
        'issuer': crl.issuer.rfc4514_string(),
        'last_update': crl.last_update,
        'next_update': crl.next_update,
        'revoked_certificates': []
    }
    
    for revoked_cert in crl:
        revoked_info = {
            'serial_number': str(revoked_cert.serial_number),
            'revocation_date': revoked_cert.revocation_date
        }
        
        # 获取撤销原因
        try:
            reason_ext = revoked_cert.extensions.get_extension_for_oid(
                x509.oid.CRLEntryExtensionOID.CRL_REASON
            )
            revoked_info['reason'] = reason_ext.value.reason.name
        except x509.ExtensionNotFound:
            revoked_info['reason'] = 'unspecified'
        
        crl_info['revoked_certificates'].append(revoked_info)
    
    return crl_info

def check_certificate_revocation_crl(certificate, crl):
    """通过CRL检查证书撤销状态"""
    for revoked_cert in crl:
        if revoked_cert.serial_number == certificate.serial_number:
            return True, revoked_cert.revocation_date
    
    return False, None

OCSP（在线证书状态协议）

# 文件路径: crypto/ocsp_client.py
import requests
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.x509.ocsp import OCSPRequestBuilder, OCSPResponseStatus
import base64

def create_ocsp_request(certificate, issuer_certificate):
    """创建OCSP请求"""
    builder = OCSPRequestBuilder()
    builder = builder.add_certificate(certificate, issuer_certificate, hashes.SHA1())
    
    request = builder.build()
    return request

def send_ocsp_request(ocsp_url, ocsp_request):
    """发送OCSP请求"""
    request_data = ocsp_request.public_bytes(serialization.Encoding.DER)
    
    headers = {
        'Content-Type': 'application/ocsp-request',
        'Content-Length': str(len(request_data))
    }
    
    try:
        response = requests.post(ocsp_url, data=request_data, headers=headers, timeout=10)
        response.raise_for_status()
        return response.content
    except requests.RequestException as e:
        raise Exception(f"OCSP请求失败: {str(e)}")

def parse_ocsp_response(response_data):
    """解析OCSP响应"""
    try:
        ocsp_response = x509.ocsp.load_der_ocsp_response(response_data)
        
        if ocsp_response.response_status != OCSPResponseStatus.SUCCESSFUL:
            return None, f"OCSP响应状态: {ocsp_response.response_status.name}"
        
        # 获取证书状态
        certificate_status = ocsp_response.certificate_status
        
        if isinstance(certificate_status, x509.ocsp.OCSPCertStatus):
            return 'good', None
        elif isinstance(certificate_status, x509.ocsp.OCSPRevokedStatus):
            return 'revoked', {
                'revocation_time': certificate_status.revocation_time,
                'revocation_reason': certificate_status.revocation_reason
            }
        elif isinstance(certificate_status, x509.ocsp.OCSPUnknownStatus):
            return 'unknown', None
        else:
            return None, "未知的证书状态"
    
    except Exception as e:
        return None, f"OCSP响应解析失败: {str(e)}"

def check_certificate_revocation_ocsp(certificate, issuer_certificate, ocsp_url):
    """通过OCSP检查证书撤销状态"""
    try:
        # 创建OCSP请求
        ocsp_request = create_ocsp_request(certificate, issuer_certificate)
        
        # 发送请求
        response_data = send_ocsp_request(ocsp_url, ocsp_request)
        
        # 解析响应
        status, details = parse_ocsp_response(response_data)
        
        return status, details
    
    except Exception as e:
        return None, str(e)

PKI应用场景

SSL/TLS证书

# 文件路径: crypto/ssl_certificate.py
import ssl
import socket
from cryptography import x509
from cryptography.hazmat.primitives import serialization

def get_ssl_certificate(hostname, port=443):
    """获取SSL证书"""
    context = ssl.create_default_context()
    
    with socket.create_connection((hostname, port), timeout=10) as sock:
        with context.wrap_socket(sock, server_hostname=hostname) as ssock:
            # 获取证书链
            cert_der = ssock.getpeercert(binary_form=True)
            cert_chain = ssock.getpeercert_chain()
            
            # 解析主证书
            certificate = x509.load_der_x509_certificate(cert_der)
            
            return certificate, cert_chain

def verify_ssl_certificate(hostname, certificate):
    """验证SSL证书"""
    errors = []
    
    # 检查主体备用名称
    try:
        san_ext = certificate.extensions.get_extension_for_oid(
            x509.oid.ExtensionOID.SUBJECT_ALTERNATIVE_NAME
        )
        
        dns_names = [name.value for name in san_ext.value 
                    if isinstance(name, x509.DNSName)]
        
        if hostname not in dns_names:
            # 检查通配符匹配
            wildcard_match = False
            for dns_name in dns_names:
                if dns_name.startswith('*.'):
                    domain = dns_name[2:]
                    if hostname.endswith('.' + domain) or hostname == domain:
                        wildcard_match = True
                        break
            
            if not wildcard_match:
                errors.append(f"主机名 {hostname} 不在证书的SAN中")
    
    except x509.ExtensionNotFound:
        # 检查Common Name
        try:
            cn = certificate.subject.get_attributes_for_oid(
                x509.oid.NameOID.COMMON_NAME
            )[0].value
            
            if cn != hostname:
                errors.append(f"主机名 {hostname} 与证书CN {cn} 不匹配")
        except (IndexError, AttributeError):
            errors.append("证书缺少主机名信息")
    
    # 检查有效期
    import datetime
    now = datetime.datetime.utcnow()
    
    if now < certificate.not_valid_before:
        errors.append("证书尚未生效")
    
    if now > certificate.not_valid_after:
        errors.append("证书已过期")
    
    # 检查密钥用法
    try:
        key_usage = certificate.extensions.get_extension_for_oid(
            x509.oid.ExtensionOID.KEY_USAGE
        ).value
        
        if not (key_usage.digital_signature and key_usage.key_encipherment):
            errors.append("证书密钥用法不适合SSL/TLS")
    
    except x509.ExtensionNotFound:
        pass
    
    return len(errors) == 0, errors

# 示例使用
if __name__ == "__main__":
    hostname = "www.google.com"
    
    try:
        certificate, cert_chain = get_ssl_certificate(hostname)
        print(f"获取 {hostname} 的SSL证书成功")
        print(f"证书主体: {certificate.subject.rfc4514_string()}")
        print(f"证书颁发者: {certificate.issuer.rfc4514_string()}")
        print(f"有效期: {certificate.not_valid_before} 到 {certificate.not_valid_after}")
        
        # 验证证书
        is_valid, errors = verify_ssl_certificate(hostname, certificate)
        print(f"证书验证: {'通过' if is_valid else '失败'}")
        
        if errors:
            print("验证错误:")
            for error in errors:
                print(f"  - {error}")
    
    except Exception as e:
        print(f"获取SSL证书失败: {str(e)}")

代码签名证书

# 文件路径: crypto/code_signing.py
import hashlib
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding

def sign_code(code_data, private_key, certificate):
    """代码签名"""
    # 计算代码哈希
    code_hash = hashlib.sha256(code_data).digest()
    
    # 创建签名
    signature = private_key.sign(
        code_hash,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    
    # 创建签名包
    signature_package = {
        'code_hash': code_hash.hex(),
        'signature': signature.hex(),
        'certificate': certificate.public_bytes(serialization.Encoding.PEM).decode(),
        'algorithm': 'RSA-PSS-SHA256'
    }
    
    return signature_package

def verify_code_signature(code_data, signature_package):
    """验证代码签名"""
    try:
        # 解析签名包
        code_hash = bytes.fromhex(signature_package['code_hash'])
        signature = bytes.fromhex(signature_package['signature'])
        cert_pem = signature_package['certificate'].encode()
        
        # 加载证书
        certificate = x509.load_pem_x509_certificate(cert_pem)
        
        # 验证代码哈希
        computed_hash = hashlib.sha256(code_data).digest()
        if computed_hash != code_hash:
            return False, "代码已被修改"
        
        # 验证签名
        public_key = certificate.public_key()
        public_key.verify(
            signature,
            code_hash,
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        
        return True, "代码签名验证成功"
    
    except Exception as e:
        return False, f"签名验证失败: {str(e)}"

实践练习

练习1：PKI系统搭建

任务：搭建完整的PKI系统

• 创建根CA和中间CA
• 实现证书签发和撤销功能
• 部署CRL和OCSP服务

验收标准：能够完成完整的证书生命周期管理。

练习2：证书链验证

任务：实现证书链验证算法

• 构建证书路径
• 验证证书签名和有效期
• 检查证书撤销状态

验收标准：能够正确验证各种证书链。

练习3：SSL证书分析

任务：分析真实网站的SSL证书

• 获取和解析SSL证书
• 验证证书链和撤销状态
• 分析证书的安全配置

验收标准：能够全面评估SSL证书的安全性。

常见问题（FAQ）

Q1：自签名证书和CA签名证书有什么区别？
A：主要区别：

• 信任来源：自签名依赖自身，CA签名依赖第三方
• 浏览器支持：CA证书被浏览器信任，自签名会警告
• 适用场景：自签名适合内部测试，CA证书适合生产环境
• 成本：自签名免费，CA证书需要付费

Q2：证书过期了怎么办？
A：处理方法：

• 更新证书：在过期前申请新证书
• 自动续期：使用Let’s Encrypt等自动化工具
• 监控告警：设置证书过期提醒
• 应急处理：临时使用自签名证书

Q3：如何选择合适的CA？
A：选择标准：

• 信任度：浏览器和操作系统的信任
• 价格：证书费用和服务成本
• 服务：技术支持和SLA保证
• 功能：支持的证书类型和扩展

Q4：什么是证书透明度（CT）？
A：CT的作用：

• 公开记录：所有证书都被公开记录
• 监控保护：检测恶意或错误签发的证书
• 合规要求：某些浏览器要求CT日志
• 安全增强：提高PKI系统的透明度

总结

本章详细介绍了数字证书与PKI体系，主要包括：

• 数字证书：X.509标准、证书结构和扩展字段
• PKI架构：CA、RA、证书存储库等核心组件
• 证书管理：签发、撤销、更新的完整流程
• 信任模型：证书链验证和信任传递机制
• 应用场景：SSL/TLS、代码签名等实际应用

PKI是现代网络安全的基础设施，为数字身份认证提供了完整的解决方案。

下一步

• 前往：007-网络安全协议
• 扩展阅读：《PKI实施指南》Carlisle Adams
• 实践建议：使用OpenSSL搭建测试PKI环境

参考与引用

• RFC 5280 - X.509证书和CRL配置文件 (2008)
• RFC 6960 - 在线证书状态协议 (2013)
• CA/Browser Forum基线要求 (2023)
• 《PKI安全解决方案》Russ Housley (2002)

更新记录

• 更新时间: 2024-01-20 | 更新内容: 创建数字证书与PKI体系章节，包含X.509标准、CA操作、证书链验证等详细内容 | 更新人: Assistant