客户A（某医院集团）
├── 北京总院
│   ├── 50台设备
│   └── 数据中心1
│
├── 上海分院
│   ├── 30台设备
│   └── 数据中心2
│
└── 广州分院
    ├── 20台设备
    └── 数据中心3

如果只有一个证书：
- 所有地域共享同一个私钥
- 一个地域泄露 → 全部地域都不安全 ❌
- 无法单独撤销某个地域 ❌

如果每个地域独立证书：
- 如何证明它们都属于同一个客户？
- 如何建立信任关系？
- 如何统一管理？

┌─────────────────────────────────┐
│   第1层：客户主证书              │
│   - 证明客户身份                 │
│   - 由平台根证书签发             │
└─────────────────────────────────┘
              ↓ 签发
┌─────────────────────────────────┐
│   第2层：地域证书                │
│   - 证明地域身份                 │
│   - 由客户主证书签发             │
└─────────────────────────────────┘
              ↓ 签发
┌─────────────────────────────────┐
│   第3层：设备证书                │
│   - 证明设备身份                 │
│   - 由地域证书签发               │
└─────────────────────────────────┘

[平台根证书]
  ↓
[客户A主证书]
  ├─→ [北京地域证书]
  │     ├─→ [设备001证书]
  │     ├─→ [设备002证书]
  │     └─→ [设备003证书]
  │
  ├─→ [上海地域证书]
  │     ├─→ [设备101证书]
  │     └─→ [设备102证书]
  │
  └─→ [广州地域证书]
        ├─→ [设备201证书]
        └─→ [设备202证书]

class RegionCertificateManager:
    """
    多地域证书管理系统
    """

    def __init__(self, platform_root_key):
        self.platform_root_key = platform_root_key
        self.customers = {}
        self.regions = {}
        self.devices = {}

    def create_customer_master_cert(self, customer_id, customer_name):
        """
        创建客户主证书
        """
        # 生成客户主密钥对
        customer_key = RSA.generate(2048)

        # 创建证书
        cert = {
            "type": "customer_master",
            "customer_id": customer_id,
            "customer_name": customer_name,
            "public_key": customer_key.publickey().export_key().decode(),
            "issued_at": datetime.now().isoformat(),
            "valid_until": (datetime.now() + timedelta(days=365)).isoformat(),
            "permissions": ["create_region", "revoke_region"]
        }

        # 用平台根私钥签名
        cert_data = json.dumps({k: v for k, v in cert.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(cert_data.encode())
        signature = pkcs1_15.new(self.platform_root_key).sign(hash_obj)
        cert["signature"] = base64.b64encode(signature).decode()

        # 保存
        self.customers[customer_id] = {
            "private_key": customer_key,
            "public_key": customer_key.publickey(),
            "certificate": cert
        }

        return cert

    def create_region_cert(self, customer_id, region_name, region_location):
        """
        为客户创建地域证书
        """
        # 获取客户主密钥
        customer = self.customers.get(customer_id)
        if not customer:
            raise Exception("客户不存在")

        # 生成地域密钥对
        region_key = RSA.generate(2048)

        # 创建地域证书
        cert = {
            "type": "region",
            "customer_id": customer_id,
            "region_name": region_name,
            "region_location": region_location,
            "public_key": region_key.publickey().export_key().decode(),
            "issued_at": datetime.now().isoformat(),
            "valid_until": (datetime.now() + timedelta(days=365)).isoformat(),
            "permissions": ["sign_device_cert"]
        }

        # 用客户主私钥签名
        cert_data = json.dumps({k: v for k, v in cert.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(cert_data.encode())
        signature = pkcs1_15.new(customer["private_key"]).sign(hash_obj)
        cert["signature"] = base64.b64encode(signature).decode()

        # 保存
        region_id = f"{customer_id}:{region_name}"
        self.regions[region_id] = {
            "private_key": region_key,
            "public_key": region_key.publickey(),
            "certificate": cert,
            "customer_cert": customer["certificate"]
        }

        return cert

    def create_device_cert(self, customer_id, region_name, device_info):
        """
        为设备创建证书
        """
        # 获取地域密钥
        region_id = f"{customer_id}:{region_name}"
        region = self.regions.get(region_id)
        if not region:
            raise Exception("地域不存在")

        # 生成设备密钥对
        device_key = RSA.generate(2048)

        # 创建设备证书
        cert = {
            "type": "device",
            "device_id": device_info["id"],
            "customer_id": customer_id,
            "region_name": region_name,
            "serial_number": device_info["serial"],
            "public_key": device_key.publickey().export_key().decode(),
            "issued_at": datetime.now().isoformat()
        }

        # 用地域私钥签名
        cert_data = json.dumps({k: v for k, v in cert.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(cert_data.encode())
        signature = pkcs1_15.new(region["private_key"]).sign(hash_obj)
        cert["signature"] = base64.b64encode(signature).decode()

        # 保存
        self.devices[device_info["id"]] = {
            "private_key": device_key,
            "certificate": cert,
            "cert_chain": [
                cert,
                region["certificate"],
                region["customer_cert"]
            ]
        }

        return {
            "device_id": device_info["id"],
            "private_key": device_key.export_key().decode(),
            "certificate": cert,
            "cert_chain": self.devices[device_info["id"]]["cert_chain"]
        }

    def verify_device_cert_chain(self, device_cert, cert_chain):
        """
        验证完整证书链
        """
        print(f"\n开始验证设备 {device_cert['device_id']} 的证书链...")

        # 第1步：验证设备证书（用地域公钥）
        region_cert = cert_chain[1]
        region_public_key = RSA.import_key(region_cert["public_key"])

        cert_data = json.dumps({k: v for k, v in device_cert.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(cert_data.encode())
        signature = base64.b64decode(device_cert["signature"])

        try:
            pkcs1_15.new(region_public_key).verify(hash_obj, signature)
            print("  ✅ 第1层：设备证书验证成功（用地域公钥）")
        except:
            print("  ❌ 第1层：设备证书验证失败")
            return False

        # 第2步：验证地域证书（用客户主公钥）
        customer_cert = cert_chain[2]
        customer_public_key = RSA.import_key(customer_cert["public_key"])

        cert_data = json.dumps({k: v for k, v in region_cert.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(cert_data.encode())
        signature = base64.b64decode(region_cert["signature"])

        try:
            pkcs1_15.new(customer_public_key).verify(hash_obj, signature)
            print("  ✅ 第2层：地域证书验证成功（用客户主公钥）")
        except:
            print("  ❌ 第2层：地域证书验证失败")
            return False

        # 第3步：验证客户主证书（用平台根公钥）
        platform_root_public = self.platform_root_key.publickey()

        cert_data = json.dumps({k: v for k, v in customer_cert.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(cert_data.encode())
        signature = base64.b64decode(customer_cert["signature"])

        try:
            pkcs1_15.new(platform_root_public).verify(hash_obj, signature)
            print("  ✅ 第3层：客户主证书验证成功（用平台根公钥）")
        except:
            print("  ❌ 第3层：客户主证书验证失败")
            return False

        print("\n✅ 完整证书链验证成功！")
        return True

场景：北京的设备001要访问上海的数据

问题：上海数据中心如何信任北京的设备？

解决方案：通过共同的客户主证书建立信任

验证流程：
1. 北京设备001提供证书链：
   [设备001证书] ← [北京地域证书] ← [客户A主证书]

2. 上海数据中心验证：
   - 验证设备001证书 ← 用北京地域公钥
   - 验证北京地域证书 ← 用客户A主公钥
   - 验证客户A主证书 ← 用平台根公钥

3. 上海数据中心确认：
   - 设备001属于客户A ✅
   - 客户A是合法客户 ✅
   - 允许访问 ✅

场景1：撤销单个设备
原因：设备丢失、报废
影响：只影响该设备

场景2：撤销整个地域
原因：地域关闭、安全事件
影响：该地域所有设备

场景3：撤销整个客户
原因：合同到期、违规
影响：该客户所有地域和设备

class CertificateRevocationList:
    """
    证书撤销列表
    """

    def __init__(self):
        self.revoked_certs = []

    def revoke_device(self, device_id, reason):
        """
        撤销设备证书
        """
        self.revoked_certs.append({
            "type": "device",
            "id": device_id,
            "reason": reason,
            "revoked_at": datetime.now().isoformat()
        })

    def revoke_region(self, customer_id, region_name, reason):
        """
        撤销地域证书（影响该地域所有设备）
        """
        self.revoked_certs.append({
            "type": "region",
            "customer_id": customer_id,
            "region_name": region_name,
            "reason": reason,
            "revoked_at": datetime.now().isoformat()
        })

    def revoke_customer(self, customer_id, reason):
        """
        撤销客户证书（影响该客户所有地域和设备）
        """
        self.revoked_certs.append({
            "type": "customer",
            "customer_id": customer_id,
            "reason": reason,
            "revoked_at": datetime.now().isoformat()
        })

    def is_revoked(self, cert):
        """
        检查证书是否被撤销
        """
        cert_type = cert["type"]

        if cert_type == "device":
            # 检查设备是否被撤销
            for revoked in self.revoked_certs:
                if revoked["type"] == "device" and revoked["id"] == cert["device_id"]:
                    return True, f"设备已被撤销：{revoked['reason']}"

                # 检查设备所属地域是否被撤销
                if revoked["type"] == "region" and \
                   revoked["customer_id"] == cert["customer_id"] and \
                   revoked["region_name"] == cert["region_name"]:
                    return True, f"地域已被撤销：{revoked['reason']}"

                # 检查设备所属客户是否被撤销
                if revoked["type"] == "customer" and \
                   revoked["customer_id"] == cert["customer_id"]:
                    return True, f"客户已被撤销：{revoked['reason']}"

        return False, "证书有效"

✅ 安全隔离：一个地域泄露不影响其他地域
✅ 灵活管理：可以单独撤销某个地域
✅ 跨地域信任：通过客户主证书建立信任
✅ 扩展性好：轻松添加新地域