❌ 错误做法：
第1天：开始开发
第180天：完成所有功能
第181天：上线
  └── 风险：开发周期长、bug多、难以调试

✅ 正确做法：
第1阶段（30天）：实现核心功能 → 上线
第2阶段（30天）：增加高级功能 → 上线
第3阶段（30天）：完善安全机制 → 上线
  └── 好处：快速验证、及时反馈、降低风险

┌─────────────────────────────────────────────────┐
│              第1阶段：MVP（最小可行方案）         │
│              目标：快速上线，验证核心功能         │
│              时间：1个月                         │
├─────────────────────────────────────────────────┤
│ ✅ License基础验证（签名+时间）                  │
│ ✅ 设备证书认证                                  │
│ ✅ 简单的设备注册                                │
│ ❌ 不包含：密钥轮换、行为分析、设备迁移          │
└─────────────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────────────┐
│              第2阶段：增强安全                    │
│              目标：提升安全性和可靠性             │
│              时间：1个月                         │
├─────────────────────────────────────────────────┤
│ ✅ 硬件绑定                                      │
│ ✅ 挑战-响应认证                                 │
│ ✅ 密钥轮换机制                                  │
│ ✅ 时间可信度评估                                │
│ ❌ 不包含：行为分析、设备迁移                    │
└─────────────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────────────┐
│              第3阶段：完整方案                    │
│              目标：实现所有高级功能               │
│              时间：1个月                         │
├─────────────────────────────────────────────────┤
│ ✅ 行为模式分析                                  │
│ ✅ 设备迁移功能                                  │
│ ✅ 自动化运维                                    │
│ ✅ 监控告警                                      │
└─────────────────────────────────────────────────┘

# MVP版本的License验证（简化版）
def verify_license_mvp(license_file):
    """
    MVP版本：只验证最核心的内容
    """

    # 检查1：文件是否存在
    if not os.path.exists(license_file):
        return False, "License文件不存在"

    # 检查2：验证签名
    license_data = load_license(license_file)
    if not verify_signature(license_data):
        return False, "签名验证失败"

    # 检查3：验证时间（简单版）
    current_time = time.time()
    valid_until = license_data["valid_until"]

    if current_time > valid_until:
        return False, "License已过期"

    return True, "验证通过"

# MVP版本的设备认证（简化版）
def authenticate_device_mvp(device_id, certificate):
    """
    MVP版本：只验证证书
    """

    # 检查1：证书格式
    if not is_valid_certificate(certificate):
        return False, "证书无效"

    # 检查2：证书签名
    if not verify_certificate_signature(certificate):
        return False, "证书签名错误"

    # 检查3：证书有效期
    if not is_certificate_valid_time(certificate):
        return False, "证书已过期"

    return True, "认证成功"

# MVP版本的设备注册
def register_device_mvp(device_info):
    """
    MVP版本：简单注册
    """

    # 检查设备数量限制
    license = load_license()
    current_count = get_device_count()

    if current_count >= license["max_robots"]:
        return False, "设备数量已达上限"

    # 生成设备ID
    device_id = generate_device_id()

    # 保存设备信息
    save_device({
        "device_id": device_id,
        "serial_number": device_info["serial"],
        "registered_at": current_time()
    })

    return True, device_id

def generate_hardware_fingerprint():
    """
    生成硬件指纹
    """
    import platform
    import uuid

    hardware_info = {
        "cpu": platform.processor(),
        "mac": ':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff)
                        for i in range(0,8*6,8)][::-1]),
        "system": platform.system(),
        "machine": platform.machine()
    }

    fingerprint = hashlib.sha256(
        json.dumps(hardware_info, sort_keys=True).encode()
    ).hexdigest()

    return fingerprint

def challenge_response_auth(device_id):
    """
    实现挑战-响应认证
    """
    # 生成随机挑战
    challenge = secrets.token_bytes(32)

    # 发送给设备
    send_challenge(device_id, challenge)

    # 等待响应
    response = wait_for_response(device_id, timeout=10)

    # 验证签名
    return verify_signature(challenge, response["signature"])

def schedule_key_rotation():
    """
    定期检查并执行密钥轮换
    """
    devices = get_all_devices()

    for device in devices:
        keys = get_device_keys(device["id"])

        for key_type, key_info in keys.items():
            if should_rotate(key_info):
                rotate_key(device["id"], key_type)

def analyze_device_behavior(device_id):
    """
    分析设备行为模式
    """
    # 获取历史行为
    history = get_behavior_history(device_id, days=30)

    # 计算基线
    baseline = calculate_baseline(history)

    # 检测异常
    current = get_current_behavior(device_id)
    anomaly_score = detect_anomaly(current, baseline)

    return anomaly_score

def create_migration_package(device_ids):
    """
    创建迁移包
    """
    devices = [get_device(id) for id in device_ids]

    package = {
        "devices": devices,
        "created_at": current_time(),
        "expires_at": current_time() + 7 * 86400
    }

    # 加密并签名
    encrypted = encrypt_package(package)
    signed = sign_package(encrypted)

    return signed

# Docker Compose 部署示例
version: '3.8'

services:
  license-validator:
    image: robot-platform/license-validator:latest
    environment:
      - LICENSE_FILE=/app/license/platform.lic
      - DB_PATH=/app/data/license.db
    volumes:
      - ./license:/app/license:ro
      - ./data:/app/data
    ports:
      - "8080:8080"

  device-registry:
    image: robot-platform/device-registry:latest
    depends_on:
      - license-validator
    environment:
      - VALIDATOR_URL=http://license-validator:8080
    volumes:
      - ./data:/app/data
    ports:
      - "8081:8081"

方案A：人工导入新License
1. 客户联系销售续费
2. 销售生成新License文件
3. 客户导入新License
4. 平台自动切换

方案B：在线续费（需要网络）
1. 平台检测到即将过期
2. 提示客户在线续费
3. 自动下载新License

1. 立即撤销泄露的密钥
2. 生成新密钥
3. 通知设备更新
4. 监控异常访问

1. 使用时间可信度评估（第4章）
2. 收集多种时间证据
3. 综合判断是否被篡改
4. 低可信度时进入保护模式

# 不要每次请求都验证License
# 使用缓存，每小时验证一次

license_cache = {
    "data": None,
    "verified_at": 0,
    "ttl": 3600  # 1小时
}

def get_license():
    if time.time() - license_cache["verified_at"] > license_cache["ttl"]:
        # 重新验证
        license_cache["data"] = verify_license()
        license_cache["verified_at"] = time.time()

    return license_cache["data"]

# 不要一个一个认证设备
# 批量处理，提高效率

def authenticate_devices_batch(device_ids):
    """
    批量认证设备
    """
    results = {}

    # 批量查询数据库
    devices = get_devices_batch(device_ids)

    # 并行验证
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = {
            executor.submit(authenticate_device, d): d["id"]
            for d in devices
        }

        for future in as_completed(futures):
            device_id = futures[future]
            results[device_id] = future.result()

    return results

需要监控的指标：
├── License状态
│   ├── 剩余天数
│   ├── 设备数量使用率
│   └── 功能使用情况
│
├── 设备状态
│   ├── 在线设备数
│   ├── 认证失败次数
│   └── 异常行为次数
│
└── 系统状态
    ├── 验证响应时间
    ├── 密钥轮换成功率
    └── 错误日志数量

第1个月：MVP上线
  └── License基础验证 + 设备证书认证

第2个月：增强安全
  └── 硬件绑定 + 挑战-响应 + 密钥轮换

第3个月：完整方案
  └── 行为分析 + 设备迁移 + 自动化运维

✅ 第1章：私有化部署和双层授权的基本概念
✅ 第2章：License的结构、签名和验证机制
✅ 第3章：设备密钥的种类和管理原则
✅ 第4章：离线环境下的时间控制机制
✅ 第5章：多因素认证和密钥轮换流程
✅ 第6章：设备迁移的安全方案
✅ 第7章：分阶段实施和技术选型

                [私有化部署授权系统]
                        ↓
        ┌───────────────┴───────────────┐
        ↓                               ↓
   [平台License]                   [设备密钥]
        ↓                               ↓
    ┌───┴───┐                      ┌────┴────┐
    ↓       ↓                      ↓         ↓
  [签名]  [时间]                [认证]    [轮换]
    ↓       ↓                      ↓         ↓
  [防篡改][防过期]              [多因素]  [定期更新]