你的业务模式：
├── 统一安装包（所有客户用同一个安装包）
├── 内置通用公钥（用于初始验证）
└── 客户导入设备（客户自己添加设备）

问题：
1. 安装包如何区分不同客户？
2. 通用公钥的作用是什么？
3. 客户特定密钥如何注入？
4. 设备导入时如何与证书通信？

挑战1：统一 vs 定制
- 统一安装包 → 降低维护成本
- 客户定制 → 提高安全性
- 如何平衡？

挑战2：通用 vs 专属
- 通用公钥 → 所有客户都能用
- 专属密钥 → 每个客户独立
- 如何结合？

挑战3：安全 vs 便捷
- 安全 → 复杂的密钥管理
- 便捷 → 简单的部署流程
- 如何兼顾？

┌─────────────────────────────────┐
│   统一安装包                     │
│   ├── 平台代码                   │
│   ├── 通用公钥（内置）           │
│   └── 配置模板                   │
└─────────────────────────────────┘
              ↓ 安装
┌─────────────────────────────────┐
│   客户环境                       │
│   ├── 导入客户证书               │
│   ├── 导入客户密钥               │
│   └── 激活客户配置               │
└─────────────────────────────────┘
              ↓ 运行
┌─────────────────────────────────┐
│   双密钥验证                     │
│   ├── 通用公钥：验证平台签名     │
│   └── 客户密钥：验证设备身份     │
└─────────────────────────────────┘

通用公钥（Platform Public Key）：
├── 作用1：验证安装包完整性
│   └── 防止安装包被篡改
│
├── 作用2：验证平台签发的证书
│   └── 验证客户证书是否由平台签发
│
└── 作用3：建立初始信任
    └── 客户证书导入前的临时验证

class UnifiedInstaller:
    """
    统一安装包构建器
    """

    def __init__(self, platform_root_key):
        self.platform_root_key = platform_root_key
        self.platform_public_key = platform_root_key.publickey()

    def build_installer(self, version):
        """
        构建统一安装包
        """
        installer = {
            "version": version,
            "build_time": datetime.now().isoformat(),

            # 内置通用公钥
            "platform_public_key": self.platform_public_key.export_key().decode(),

            # 平台配置
            "platform_config": {
                "api_endpoint": "https://platform.example.com",
                "update_server": "https://update.example.com",
                "support_email": "support@example.com"
            },

            # 客户配置模板（待填充）
            "customer_config_template": {
                "customer_id": None,
                "customer_name": None,
                "customer_certificate": None,
                "region_certificates": []
            }
        }

        # 签名整个安装包
        installer_data = json.dumps({k: v for k, v in installer.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(installer_data.encode())
        signature = pkcs1_15.new(self.platform_root_key).sign(hash_obj)
        installer["signature"] = base64.b64encode(signature).decode()

        return installer

    def verify_installer(self, installer):
        """
        验证安装包完整性
        """
        # 提取公钥
        platform_public_key = RSA.import_key(installer["platform_public_key"])

        # 验证签名
        installer_data = json.dumps({k: v for k, v in installer.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(installer_data.encode())
        signature = base64.b64decode(installer["signature"])

        try:
            pkcs1_15.new(platform_public_key).verify(hash_obj, signature)
            print("✅ 安装包验证成功，未被篡改")
            return True
        except:
            print("❌ 安装包验证失败，可能被篡改")
            return False

class CustomerActivation:
    """
    客户激活系统
    """

    def __init__(self, installer):
        self.installer = installer
        self.platform_public_key = RSA.import_key(installer["platform_public_key"])

    def activate_customer(self, customer_cert, customer_private_key):
        """
        激活客户配置
        """
        print("\n开始激活客户...")

        # 第1步：验证客户证书（用通用公钥）
        print("  [1/4] 验证客户证书...")
        if not self._verify_customer_cert(customer_cert):
            raise Exception("客户证书验证失败")
        print("  ✅ 客户证书验证成功")

        # 第2步：导入客户密钥
        print("  [2/4] 导入客户密钥...")
        self.customer_private_key = RSA.import_key(customer_private_key)
        self.customer_public_key = self.customer_private_key.publickey()
        print("  ✅ 客户密钥导入成功")

        # 第3步：生成客户配置
        print("  [3/4] 生成客户配置...")
        customer_config = {
            "customer_id": customer_cert["customer_id"],
            "customer_name": customer_cert["customer_name"],
            "customer_certificate": customer_cert,
            "activated_at": datetime.now().isoformat(),
            "status": "active"
        }
        print("  ✅ 客户配置生成成功")

        # 第4步：保存配置
        print("  [4/4] 保存配置...")
        self._save_config(customer_config)
        print("  ✅ 配置保存成功")

        print("\n✅ 客户激活完成！")
        return customer_config

    def _verify_customer_cert(self, customer_cert):
        """
        验证客户证书（用平台通用公钥）
        """
        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(self.platform_public_key).verify(hash_obj, signature)
            return True
        except:
            return False

    def _save_config(self, config):
        """
        保存客户配置到本地
        """
        with open("/etc/platform/customer.conf", "w") as f:
            json.dump(config, f, indent=2)

class SecureBootstrap:
    """
    安全启动系统
    """

    def __init__(self):
        self.installer = None
        self.customer_config = None

    def bootstrap(self):
        """
        安全启动流程
        """
        print("\n=== 平台启动中 ===\n")

        # 阶段1：验证安装包
        print("[阶段1] 验证安装包完整性...")
        self.installer = self._load_installer()
        if not self._verify_installer():
            raise Exception("安装包验证失败，启动中止")
        print("✅ 安装包验证成功\n")

        # 阶段2：加载客户配置
        print("[阶段2] 加载客户配置...")
        self.customer_config = self._load_customer_config()
        if not self.customer_config:
            print("⚠️  未找到客户配置，进入初始化模式")
            return "INIT_MODE"
        print(f"✅ 客户配置加载成功：{self.customer_config['customer_name']}\n")

        # 阶段3：验证客户证书
        print("[阶段3] 验证客户证书...")
        if not self._verify_customer_cert():
            raise Exception("客户证书验证失败，启动中止")
        print("✅ 客户证书验证成功\n")

        # 阶段4：初始化密钥系统
        print("[阶段4] 初始化密钥系统...")
        self._init_key_system()
        print("✅ 密钥系统初始化成功\n")

        print("=== 平台启动完成 ===\n")
        return "RUNNING"

    def _verify_installer(self):
        """
        验证安装包
        """
        platform_public_key = RSA.import_key(self.installer["platform_public_key"])
        installer_data = json.dumps({k: v for k, v in self.installer.items() if k != "signature"}, sort_keys=True)
        hash_obj = SHA256.new(installer_data.encode())
        signature = base64.b64decode(self.installer["signature"])

        try:
            pkcs1_15.new(platform_public_key).verify(hash_obj, signature)
            return True
        except:
            return False

    def _load_customer_config(self):
        """
        加载客户配置
        """
        try:
            with open("/etc/platform/customer.conf", "r") as f:
                return json.load(f)
        except FileNotFoundError:
            return None

    def _verify_customer_cert(self):
        """
        验证客户证书
        """
        customer_cert = self.customer_config["customer_certificate"]
        platform_public_key = RSA.import_key(self.installer["platform_public_key"])

        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_public_key).verify(hash_obj, signature)
            return True
        except:
            return False

    def _init_key_system(self):
        """
        初始化密钥系统
        """
        # 加载客户密钥
        # 初始化设备验证系统
        # 启动密钥轮换任务
        pass

[步骤1：平台方]
构建统一安装包
  ├── 内置平台通用公钥
  ├── 签名安装包
  └── 发布安装包
        ↓
[步骤2：客户方]
下载并安装
  ├── 验证安装包签名
  ├── 解压安装
  └── 进入初始化模式
        ↓
[步骤3：平台方]
为客户生成证书
  ├── 生成客户主证书
  ├── 生成地域证书
  └── 打包交付给客户
        ↓
[步骤4：客户方]
导入证书激活
  ├── 导入客户证书
  ├── 导入客户私钥
  ├── 验证证书（用通用公钥）
  └── 激活客户配置
        ↓
[步骤5：客户方]
重启平台
  ├── 验证安装包
  ├── 加载客户配置
  ├── 验证客户证书
  └── 进入运行模式
        ↓
[步骤6：客户方]
导入设备
  ├── 设备请求注册
  ├── 平台验证设备
  ├── 签发设备证书
  └── 设备开始工作

# ========== 平台方：构建安装包 ==========
platform_root_key = RSA.generate(4096)
installer_builder = UnifiedInstaller(platform_root_key)
installer = installer_builder.build_installer(version="1.0.0")

print("✅ 统一安装包构建完成")
print(f"   版本：{installer['version']}")
print(f"   内置通用公钥：{installer['platform_public_key'][:50]}...")

# ========== 客户方：安装并验证 ==========
print("\n--- 客户A开始安装 ---")
if installer_builder.verify_installer(installer):
    print("✅ 安装包验证成功，开始安装...")

# ========== 平台方：为客户A生成证书 ==========
key_system = HierarchicalKeySystem()
customer_cert = key_system.create_customer("CUST-A", "某医院")
customer_private_key = key_system.customer_master_keys["CUST-A"]["private_key"].export_key().decode()

print("\n✅ 客户A证书生成完成")
print(f"   客户ID：{customer_cert['customer_id']}")
print(f"   客户名称：{customer_cert['customer_name']}")

# ========== 客户方：激活客户配置 ==========
print("\n--- 客户A激活配置 ---")
activation = CustomerActivation(installer)
customer_config = activation.activate_customer(customer_cert, customer_private_key)

# ========== 客户方：安全启动 ==========
print("\n--- 平台启动 ---")
bootstrap = SecureBootstrap()
status = bootstrap.bootstrap()
print(f"平台状态：{status}")

1. 安装包完整性
   ├── 平台私钥签名
   ├── 通用公钥验证
   └── 防止安装包被篡改

2. 客户证书验证
   ├── 平台签发客户证书
   ├── 通用公钥验证客户证书
   └── 防止伪造客户

3. 双密钥隔离
   ├── 通用公钥：验证平台签名
   ├── 客户密钥：验证设备身份
   └── 职责分离，降低风险

4. 启动时验证
   ├── 每次启动都验证
   ├── 多层验证
   └── 确保运行环境安全

风险1：通用公钥泄露
影响：攻击者可以验证平台签名（但无法伪造）
缓解：通用公钥本来就是公开的，泄露不影响安全

风险2：客户私钥泄露
影响：攻击者可以伪造该客户的设备
缓解：只影响该客户，不影响其他客户

风险3：安装包被替换
影响：客户安装了恶意软件
缓解：签名验证失败，无法启动

✅ 统一维护：一个安装包，所有客户通用
✅ 安全隔离：客户密钥独立，互不影响
✅ 灵活部署：支持离线激活
✅ 防篡改：多层签名验证