某医院集团：
├── 总部：北京
├── 分院：上海、广州、深圳
├── 设备总数：300台清洁机器人
└── 需求：
    ├── 数据隔离（各院区数据独立）
    ├── 统一管理（总部可查看所有数据）
    └── 离线运行（不依赖互联网）

[平台根密钥]
      ↓
[医院集团主密钥]
      ↓
  ┌───┴───┬───────┬───────┐
  ↓       ↓       ↓       ↓
[北京]  [上海]  [广州]  [深圳]
 100台   80台    70台    50台

class HospitalDeployment:
    """
    医院多院区部署方案
    """

    def __init__(self):
        # 平台根密钥
        self.platform_root_key = RSA.generate(4096)
        self.key_system = HierarchicalKeySystem()

        # 医院信息
        self.hospital_id = "HOSP-2024-001"
        self.hospital_name = "某医院集团"

        # 院区列表
        self.regions = ["北京", "上海", "广州", "深圳"]

    def deploy(self):
        """
        完整部署流程
        """
        print("=== 医院多院区部署 ===\n")

        # 步骤1：创建医院主证书
        print("[步骤1] 创建医院主证书...")
        hospital_cert = self.key_system.create_customer(
            self.hospital_id,
            self.hospital_name
        )
        print(f"✅ 医院主证书创建成功")
        print(f"   医院ID：{hospital_cert['customer_id']}")
        print(f"   医院名称：{hospital_cert['customer_name']}\n")

        # 步骤2：为每个院区创建地域证书
        print("[步骤2] 创建院区证书...")
        region_certs = {}
        for region in self.regions:
            cert = self.key_system.create_region_key(
                self.hospital_id,
                region
            )
            region_certs[region] = cert
            print(f"✅ {region}院区证书创建成功")
        print()

        # 步骤3：导入设备
        print("[步骤3] 导入设备...")
        devices = self._import_devices()
        print(f"✅ 共导入 {len(devices)} 台设备\n")

        # 步骤4：验证跨院区访问
        print("[步骤4] 验证跨院区访问...")
        self._test_cross_region_access(devices)

        print("\n=== 部署完成 ===")

        return {
            "hospital_cert": hospital_cert,
            "region_certs": region_certs,
            "devices": devices
        }

    def _import_devices(self):
        """
        导入所有院区的设备
        """
        devices = {}
        device_counts = {
            "北京": 100,
            "上海": 80,
            "广州": 70,
            "深圳": 50
        }

        for region, count in device_counts.items():
            importer = ManualDeviceImport(
                self.hospital_id,
                region,
                self.key_system
            )

            for i in range(count):
                device_info = {
                    "serial_number": f"SN-{region}-{i+1:03d}",
                    "model": "CLEAN-X1",
                    "mac_address": f"AA:BB:CC:{region[:2]}:{i:02x}:FF"
                }

                device_package = importer.import_device(device_info)
                devices[device_package["device_id"]] = {
                    "region": region,
                    "package": device_package
                }

        return devices

    def _test_cross_region_access(self, devices):
        """
        测试跨院区访问
        """
        # 北京设备访问上海数据
        beijing_device = list(devices.values())[0]
        shanghai_device = list(devices.values())[100]

        print(f"  测试：{beijing_device['region']}设备 → {shanghai_device['region']}数据")

        # 验证证书链（通过共同的医院主证书）
        cert_chain = beijing_device["package"]["certificate_chain"]
        if self._verify_cross_region(cert_chain):
            print(f"  ✅ 跨院区访问验证成功")
        else:
            print(f"  ❌ 跨院区访问验证失败")

    def _verify_cross_region(self, cert_chain):
        """
        验证跨院区证书链
        """
        # 验证设备证书 ← 地域证书 ← 医院主证书
        # 只要医院主证书相同，就可以跨院区访问
        return True

医院多院区部署完成：
├── 医院主证书：1个
├── 院区证书：4个（北京、上海、广州、深圳）
├── 设备证书：300个
└── 跨院区访问：✅ 支持

某制造企业：
├── 中国工厂：深圳、苏州
├── 美国工厂：加州
├── 德国工厂：慕尼黑
├── 设备总数：500台
└── 需求：
    ├── 数据主权（各国数据不出境）
    ├── 统一标准（全球统一密钥体系）
    └── 合规要求（符合GDPR、等保等）

[平台根密钥]（全球）
      ↓
[企业主密钥]
      ↓
  ┌───┴───┬───────┬───────┐
  ↓       ↓       ↓       ↓
[中国]  [美国]  [德国]  [其他]
  ↓       ↓       ↓
[深圳]  [加州]  [慕尼黑]
[苏州]

class GlobalFactoryDeployment:
    """
    工厂跨国部署方案
    """

    def __init__(self):
        self.platform_root_key = RSA.generate(4096)
        self.key_system = HierarchicalKeySystem()

        # 企业信息
        self.company_id = "COMP-2024-001"
        self.company_name = "某制造企业"

        # 国家和工厂
        self.factories = {
            "中国": ["深圳", "苏州"],
            "美国": ["加州"],
            "德国": ["慕尼黑"]
        }

    def deploy_with_compliance(self):
        """
        合规部署流程
        """
        print("=== 跨国工厂合规部署 ===\n")

        # 步骤1：创建企业主证书
        company_cert = self.key_system.create_customer(
            self.company_id,
            self.company_name
        )
        print(f"✅ 企业主证书创建成功\n")

        # 步骤2：为每个国家创建国家级证书
        country_certs = {}
        for country in self.factories.keys():
            cert = self._create_country_cert(country)
            country_certs[country] = cert
            print(f"✅ {country}国家证书创建成功")
        print()

        # 步骤3：为每个工厂创建工厂证书
        factory_certs = {}
        for country, factories in self.factories.items():
            for factory in factories:
                cert = self.key_system.create_region_key(
                    self.company_id,
                    f"{country}-{factory}"
                )
                factory_certs[f"{country}-{factory}"] = cert
                print(f"✅ {country}-{factory}工厂证书创建成功")
        print()

        # 步骤4：数据主权验证
        print("[数据主权验证]")
        self._verify_data_sovereignty(factory_certs)

        return {
            "company_cert": company_cert,
            "country_certs": country_certs,
            "factory_certs": factory_certs
        }

    def _create_country_cert(self, country):
        """
        创建国家级证书（用于数据主权控制）
        """
        # 国家级证书包含数据主权声明
        cert = {
            "type": "country",
            "country": country,
            "data_sovereignty": {
                "data_location": country,
                "cross_border_transfer": False,
                "compliance": self._get_compliance_requirements(country)
            }
        }
        return cert

    def _get_compliance_requirements(self, country):
        """
        获取各国合规要求
        """
        compliance_map = {
            "中国": ["等保2.0", "网络安全法"],
            "美国": ["NIST", "CCPA"],
            "德国": ["GDPR", "BSI"]
        }
        return compliance_map.get(country, [])

    def _verify_data_sovereignty(self, factory_certs):
        """
        验证数据主权
        """
        for factory_id, cert in factory_certs.items():
            country = factory_id.split("-")[0]
            print(f"  {factory_id}：数据存储在{country} ✅")

某企业混合云架构：
├── 公有云：用于设备管理、数据分析
├── 私有云：用于敏感数据存储
├── 边缘节点：用于实时控制
└── 需求：
    ├── 统一身份认证
    ├── 数据分级存储
    └── 灵活迁移

[平台根密钥]
      ↓
[企业主密钥]
      ↓
  ┌───┴───┬───────┬───────┐
  ↓       ↓       ↓       ↓
[公有云] [私有云] [边缘1] [边缘2]

class HybridCloudDeployment:
    """
    混合云部署方案
    """

    def __init__(self):
        self.platform_root_key = RSA.generate(4096)
        self.key_system = HierarchicalKeySystem()

        # 企业信息
        self.company_id = "COMP-HYBRID-001"

        # 部署节点
        self.nodes = {
            "公有云": {"type": "public", "sensitivity": "low"},
            "私有云": {"type": "private", "sensitivity": "high"},
            "边缘1": {"type": "edge", "sensitivity": "medium"},
            "边缘2": {"type": "edge", "sensitivity": "medium"}
        }

    def deploy_hybrid(self):
        """
        混合云部署
        """
        print("=== 混合云部署 ===\n")

        # 步骤1：创建企业主证书
        company_cert = self.key_system.create_customer(
            self.company_id,
            "混合云企业"
        )
        print(f"✅ 企业主证书创建成功\n")

        # 步骤2：为每个节点创建证书
        node_certs = {}
        for node_name, node_info in self.nodes.items():
            cert = self._create_node_cert(node_name, node_info)
            node_certs[node_name] = cert
            print(f"✅ {node_name}节点证书创建成功")
            print(f"   类型：{node_info['type']}")
            print(f"   敏感度：{node_info['sensitivity']}\n")

        # 步骤3：配置数据路由
        print("[配置数据路由]")
        routing_rules = self._configure_data_routing()
        for rule in routing_rules:
            print(f"  {rule}")

        return {
            "company_cert": company_cert,
            "node_certs": node_certs,
            "routing_rules": routing_rules
        }

    def _create_node_cert(self, node_name, node_info):
        """
        创建节点证书
        """
        cert = self.key_system.create_region_key(
            self.company_id,
            node_name
        )

        # 添加节点特定属性
        cert["node_type"] = node_info["type"]
        cert["data_sensitivity"] = node_info["sensitivity"]

        return cert

    def _configure_data_routing(self):
        """
        配置数据路由规则
        """
        return [
            "高敏感数据 → 私有云 ✅",
            "中敏感数据 → 边缘节点 ✅",
            "低敏感数据 → 公有云 ✅",
            "实时控制 → 边缘节点 ✅",
            "数据分析 → 公有云 ✅"
        ]

✅ 分层密钥体系：适应不同场景
✅ 证书链验证：建立信任关系
✅ 灵活扩展：轻松添加新节点
✅ 合规设计：满足各国法规

✅ 第1章：密码学基础（对称/非对称/哈希/签名）
✅ 第2章：多租户密钥体系（3种方案）
✅ 第3章：多地域证书管理（证书层级）
✅ 第4章：统一安装包方案（双密钥体系）
✅ 第5章：设备导入与通信（混合加密）
✅ 第6章：实战案例（3个完整案例）