方式1：只验证设备ID
问题：黑客可以伪造设备ID

方式2：只验证密码
问题：密码可能被窃取

方式3：只验证证书
问题：证书可能被复制

┌─────────────────────────────────┐
│       多因素认证（MFA）          │
├─────────────────────────────────┤
│ 第一因素：你有什么（证书）       │
│ 第二因素：你知道什么（密钥）     │
│ 第三因素：你是什么（行为特征）   │
└─────────────────────────────────┘

第一因素：银行卡（你有什么）
第二因素：密码（你知道什么）
第三因素：指纹（你是什么）

只有三个都对，才能取款 ✅

设备 → 平台：这是我的证书
平台：检查证书
  ├── 证书是否由可信CA签发？
  ├── 证书是否在有效期内？
  ├── 证书是否被撤销？
  └── 证书链是否完整？

def verify_device_certificate(device_id, certificate):
    """
    验证设备证书
    """

    # 检查1：证书格式是否正确
    if not is_valid_certificate_format(certificate):
        return False, "证书格式错误"

    # 检查2：证书是否由可信CA签发
    ca_public_key = load_ca_public_key()
    if not verify_certificate_signature(certificate, ca_public_key):
        return False, "证书签名验证失败"

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

    # 检查4：证书是否被撤销
    if is_certificate_revoked(certificate):
        return False, "证书已被撤销"

    # 检查5：证书中的设备ID是否匹配
    cert_device_id = extract_device_id(certificate)
    if cert_device_id != device_id:
        return False, "设备ID不匹配"

    return True, "证书验证通过"

场景：城门守卫验证将军身份

守卫：天王盖地虎（挑战）
将军：宝塔镇河妖（响应）
守卫：对上了，放行 ✅

如果是假冒的：
守卫：天王盖地虎（挑战）
假将军：？？？（不知道暗号）
守卫：不对，拿下 ❌

[步骤1：平台发送挑战]
平台 → 设备：这是一个随机数：ABC123

[步骤2：设备用私钥签名]
设备：用私钥对"ABC123"进行签名
设备：生成签名值：XYZ789

[步骤3：设备发送响应]
设备 → 平台：这是我的签名：XYZ789

[步骤4：平台验证签名]
平台：用设备的公钥验证签名
平台：验证"ABC123"的签名是否是"XYZ789"
  ├── 如果匹配 → 证明设备有私钥 ✅
  └── 如果不匹配 → 设备是假冒的 ❌

def challenge_response_auth(device_id):
    """
    挑战-响应认证
    """

    # 步骤1：生成随机挑战
    challenge = generate_random_challenge()  # "ABC123"

    # 步骤2：发送挑战给设备
    send_to_device(device_id, {
        "type": "challenge",
        "challenge": challenge,
        "timestamp": current_time()
    })

    # 步骤3：等待设备响应
    response = wait_for_device_response(device_id, timeout=10)

    if not response:
        return False, "设备响应超时"

    # 步骤4：验证响应
    device_signature = response["signature"]
    device_public_key = get_device_public_key(device_id)

    is_valid = verify_signature(
        data=challenge,
        signature=device_signature,
        public_key=device_public_key
    )

    if is_valid:
        return True, "挑战-响应验证通过"
    else:
        return False, "签名验证失败"

正常机器人的行为特征：
├── 连接频率：每5分钟连接一次
├── 数据量：每次上报100KB左右
├── 连接时段：工作时间（8:00-18:00）
├── 地理位置：固定在工厂内
└── 操作序列：先登录→上报数据→心跳→登出

异常行为示例：
├── 连接频率异常：突然每秒连接100次
├── 数据量异常：突然上报10GB数据
├── 时段异常：凌晨3点突然活跃
├── 位置异常：IP地址突然变到国外
└── 序列异常：不登录就直接上报数据

def verify_behavior_pattern(device_id, recent_behavior):
    """
    验证设备行为模式
    """

    # 获取设备的历史行为基线
    baseline = get_device_behavior_baseline(device_id)

    anomaly_score = 0

    # 检查1：连接频率
    if recent_behavior["connection_rate"] > baseline["connection_rate"] * 3:
        anomaly_score += 30

    # 检查2：数据量
    if recent_behavior["data_volume"] > baseline["data_volume"] * 5:
        anomaly_score += 25

    # 检查3：连接时段
    if is_unusual_time(recent_behavior["connection_time"]):
        anomaly_score += 20

    # 检查4：地理位置
    if recent_behavior["ip_address"] != baseline["ip_address"]:
        anomaly_score += 15

    # 检查5：操作序列
    if not is_valid_operation_sequence(recent_behavior["operations"]):
        anomaly_score += 10

    # 判断
    if anomaly_score >= 50:
        return False, f"行为异常（异常分数：{anomaly_score}）"
    elif anomaly_score >= 30:
        return True, f"行为可疑（异常分数：{anomaly_score}），需要额外验证"
    else:
        return True, "行为正常"

[设备请求连接]
      ↓
[因素1：证书验证]
  ├── 验证失败 → [拒绝连接] ❌
  └── 验证成功 ↓

[因素2：挑战-响应]
  ├── 验证失败 → [拒绝连接] ❌
  └── 验证成功 ↓

[因素3：行为验证]（可选）
  ├── 异常 → [触发告警] ⚠️
  └── 正常 ↓

[计算认证等级]
  ├── 高等级（3因素全过）→ [完全访问] ✅
  ├── 中等级（2因素通过）→ [受限访问] ⚠️
  └── 低等级（1因素通过）→ [只读访问] 🔒

def authenticate_device_full(device_id, auth_request):
    """
    完整的多因素认证流程
    """

    auth_results = {
        "certificate": None,
        "challenge": None,
        "behavior": None
    }

    # 因素1：证书验证
    cert_result = verify_device_certificate(
        device_id,
        auth_request["certificate"]
    )
    auth_results["certificate"] = cert_result

    if not cert_result[0]:
        return {
            "authenticated": False,
            "level": "DENIED",
            "reason": "证书验证失败",
            "factors": auth_results
        }

    # 因素2：挑战-响应
    challenge_result = challenge_response_auth(device_id)
    auth_results["challenge"] = challenge_result

    if not challenge_result[0]:
        return {
            "authenticated": False,
            "level": "DENIED",
            "reason": "挑战-响应失败",
            "factors": auth_results
        }

    # 因素3：行为验证（可选）
    if should_verify_behavior(device_id):
        behavior_result = verify_behavior_pattern(
            device_id,
            auth_request.get("recent_behavior", {})
        )
        auth_results["behavior"] = behavior_result

    # 计算认证等级
    passed_factors = sum([
        1 if auth_results["certificate"][0] else 0,
        1 if auth_results["challenge"][0] else 0,
        1 if auth_results.get("behavior") and auth_results["behavior"][0] else 0
    ])

    if passed_factors == 3:
        level = "HIGH"
    elif passed_factors == 2:
        level = "MEDIUM"
    else:
        level = "LOW"

    return {
        "authenticated": True,
        "level": level,
        "factors": auth_results
    }

假设黑客在尝试破解密钥：
- 如果密钥永不更换 → 黑客有无限时间
- 如果密钥30天一换 → 黑客只有30天
  └── 30天内破解不了，密钥就换了

触发密钥轮换的情况：
├── 定期轮换：到达轮换周期
├── 主动轮换：检测到安全威胁
├── 被动轮换：密钥泄露
└── 强制轮换：管理员手动触发

[阶段1：准备阶段]
检测到需要轮换 → 生成新密钥 → 加密新密钥
        ↓
[阶段2：分发阶段]
平台 → 设备：这是你的新密钥
设备：收到新密钥 → 存储到安全区域
        ↓
[阶段3：验证阶段]
设备 → 平台：用新密钥签名测试
平台：验证新密钥是否正常工作
  ├── 验证失败 → 回滚到旧密钥
  └── 验证成功 ↓

[阶段4：激活阶段]
平台：激活新密钥
设备：开始使用新密钥
        ↓
[阶段5：清理阶段]
等待24小时（缓冲期）
废弃旧密钥 → 从系统中删除

def rotate_device_key(device_id, key_type):
    """
    执行密钥轮换
    """

    try:
        # 阶段1：生成新密钥
        new_key = generate_new_key(key_type)

        # 创建轮换事务
        transaction = {
            "transaction_id": generate_uuid(),
            "device_id": device_id,
            "key_type": key_type,
            "old_key_id": get_current_key_id(device_id, key_type),
            "new_key_id": new_key["key_id"],
            "status": "IN_PROGRESS",
            "started_at": current_time()
        }

        # 阶段2：分发新密钥到设备
        distribution_result = distribute_key_to_device(
            device_id,
            new_key,
            transaction["transaction_id"]
        )

        if not distribution_result["success"]:
            transaction["status"] = "FAILED"
            transaction["error"] = distribution_result["error"]
            return transaction

        # 阶段3：验证新密钥
        verification_result = verify_new_key(
            device_id,
            new_key["key_id"]
        )

        if not verification_result["success"]:
            # 回滚
            rollback_key_rotation(transaction)
            transaction["status"] = "ROLLED_BACK"
            return transaction

        # 阶段4：激活新密钥
        activate_new_key(device_id, key_type, new_key["key_id"])

        # 阶段5：延迟废弃旧密钥
        schedule_old_key_revocation(
            device_id,
            transaction["old_key_id"],
            delay_hours=24
        )

        transaction["status"] = "COMPLETED"
        transaction["completed_at"] = current_time()

        return transaction

    except Exception as e:
        return {
            "status": "ERROR",
            "error": str(e)
        }

需要撤销密钥的情况：
├── 设备丢失或被盗
├── 设备报废
├── 检测到密钥泄露
├── 设备行为异常
└── 客户要求注销设备

[步骤1：触发撤销]
管理员/系统 → 撤销请求
        ↓
[步骤2：记录撤销]
添加到撤销列表（CRL）
记录撤销时间和原因
        ↓
[步骤3：通知设备]
平台 → 设备：你的密钥已被撤销
设备：停止使用密钥
        ↓
[步骤4：拒绝连接]
设备尝试连接 → 平台检查CRL → 发现已撤销 → 拒绝连接

# 撤销列表数据结构
revocation_list = {
    "version": "1.0",
    "updated_at": "2024-12-01 10:00:00",
    "revoked_keys": [
        {
            "key_id": "KEY-2024-001",
            "device_id": "DEVICE-001",
            "revoked_at": "2024-11-01 10:00:00",
            "reason": "设备丢失",
            "revoked_by": "admin@company.com"
        },
        {
            "key_id": "KEY-2024-002",
            "device_id": "DEVICE-002",
            "revoked_at": "2024-11-15 15:30:00",
            "reason": "检测到异常行为",
            "revoked_by": "system"
        }
    ]
}

多因素认证 = 银行取款（卡+密码+指纹）
挑战-响应 = 对暗号（天王盖地虎）
密钥轮换 = 定期换门锁
密钥撤销 = 挂失银行卡

┌─────────────────────────────────┐
│      设备认证完整流程            │
├─────────────────────────────────┤
│ 第1步：证书验证（你有什么）      │
│ 第2步：挑战-响应（你知道什么）   │
│ 第3步：行为分析（你是什么）      │
│ 第4步：计算认证等级              │
│ 第5步：授予相应权限              │
└─────────────────────────────────┘