struct rpmb_data_frame {
    uint8_t stuff_bytes[196];        // 填充字节 (196字节)
    uint8_t key_mac[32];            // HMAC-SHA256认证码 (32字节)
    uint8_t data[256];              // 数据载荷 (256字节)
    uint8_t nonce[16];              // 随机数 (16字节)
    uint8_t write_counter[4];       // 写计数器 (4字节)
    uint8_t address[2];             // 块地址 (2字节)
    uint8_t block_count[2];         // 块数量 (2字节)
    uint8_t op_result[2];           // 操作结果 (2字节)
    uint8_t msg_type[2];            // 消息类型 (2字节)
} __packed;                         // 总计512字节

#define RPMB_MSG_TYPE_REQ_AUTH_KEY_PROGRAM          0x0001  // 密钥编程请求
#define RPMB_MSG_TYPE_REQ_WRITE_COUNTER_VAL_READ    0x0002  // 读写计数器请求
#define RPMB_MSG_TYPE_REQ_AUTH_DATA_WRITE           0x0003  // 认证数据写请求
#define RPMB_MSG_TYPE_REQ_AUTH_DATA_READ            0x0004  // 认证数据读请求
#define RPMB_MSG_TYPE_REQ_RESULT_READ               0x0005  // 读取结果请求

#define RPMB_MSG_TYPE_RESP_AUTH_KEY_PROGRAM         0x0100  // 密钥编程响应
#define RPMB_MSG_TYPE_RESP_WRITE_COUNTER_VAL_READ   0x0200  // 读写计数器响应
#define RPMB_MSG_TYPE_RESP_AUTH_DATA_WRITE          0x0300  // 认证数据写响应
#define RPMB_MSG_TYPE_RESP_AUTH_DATA_READ           0x0400  // 认证数据读响应

#define RPMB_RESULT_OK                              0x00    // 操作成功
#define RPMB_RESULT_GENERAL_FAILURE                 0x01    // 一般错误
#define RPMB_RESULT_AUTH_FAILURE                    0x02    // 认证失败
#define RPMB_RESULT_COUNTER_FAILURE                 0x03    // 计数器错误
#define RPMB_RESULT_ADDRESS_FAILURE                 0x04    // 地址错误
#define RPMB_RESULT_WRITE_FAILURE                   0x05    // 写入失败
#define RPMB_RESULT_READ_FAILURE                    0x06    // 读取失败
#define RPMB_RESULT_AUTH_KEY_NOT_PROGRAMMED         0x07    // 密钥未编程
#define RPMB_RESULT_MASK                            0x3F    // 结果掩码
#define RPMB_RESULT_WR_CNT_EXPIRED                  0x80    // 写计数器过期

static const uint8_t rpmb_test_key[RPMB_KEY_MAC_SIZE] = {
    0xD3, 0xEB, 0x3E, 0xC3, 0x6E, 0x33, 0x4C, 0x9F,
    0x98, 0x8C, 0xE2, 0xC0, 0xB8, 0x59, 0x54, 0x61,
    0x0D, 0x2B, 0xCF, 0x86, 0x64, 0x84, 0x4D, 0xF2,
    0xAB, 0x56, 0xE6, 0xC6, 0x1B, 0xB7, 0x01, 0xE4
};

static TEE_Result tee_rpmb_key_gen(uint8_t *key, uint32_t len)
{
    if (!key || RPMB_KEY_MAC_SIZE != len)
        return TEE_ERROR_BAD_PARAMETERS;
    
    DMSG("RPMB: Using test key");
    memcpy(key, rpmb_test_key, RPMB_KEY_MAC_SIZE);
    return TEE_SUCCESS;
}

static TEE_Result tee_rpmb_key_gen(uint8_t *key, uint32_t len)
{
    uint8_t message[RPMB_EMMC_CID_SIZE];
    
    if (!key || RPMB_KEY_MAC_SIZE != len)
        return TEE_ERROR_BAD_PARAMETERS;
    
    /*
     * 基于eMMC CID生成RPMB密钥
     * 需要屏蔽可变字段:
     * CID [55:48]: PRV (产品版本，FFU时可能改变)
     * CID [07:01]: CRC (CRC7校验和)
     * CID [00]: 未使用
     */
    memcpy(message, rpmb_ctx->cid, RPMB_EMMC_CID_SIZE);
    memset(message + RPMB_CID_PRV_OFFSET, 0, 1);  // 清除PRV字段
    memset(message + RPMB_CID_CRC_OFFSET, 0, 1);  // 清除CRC字段
    
    // 使用HUK派生RPMB密钥
    return huk_subkey_derive(HUK_SUBKEY_RPMB, message, sizeof(message),
                           key, len);
}

struct tee_rpmb_ctx {
    uint8_t key[RPMB_KEY_MAC_SIZE];     // RPMB认证密钥 (32字节)
    uint8_t cid[RPMB_EMMC_CID_SIZE];    // eMMC卡标识符 (16字节)
    uint32_t wr_cnt;                    // 当前写计数器值
    uint16_t max_blk_idx;               // 最大支持的块索引
    uint16_t rel_wr_blkcnt;             // 每次可靠写的最大块数
    uint16_t dev_id;                    // eMMC设备ID
    
    // 状态标志
    bool wr_cnt_synced;                 // 写计数器已同步
    bool key_derived;                   // 密钥已派生
    bool key_verified;                  // 密钥已验证
    bool dev_info_synced;               // 设备信息已同步
    bool legacy_operation;              // 使用传统接口
    bool reinit;                        // 需要重新初始化
    enum thread_shm_type shm_type;      // 共享内存类型
};

static TEE_Result tee_rpmb_mac_calc(uint8_t *mac, uint32_t macsize,
                                   uint8_t *key, uint32_t keysize,
                                   struct rpmb_data_frame *datafrms,
                                   uint16_t blkcnt)
{
    TEE_Result res;
    void *ctx = NULL;
    int i;
    
    // 参数验证
    if (!mac || !key || !datafrms)
        return TEE_ERROR_BAD_PARAMETERS;
    
    // 分配HMAC上下文
    res = crypto_mac_alloc_ctx(&ctx, TEE_ALG_HMAC_SHA256);
    if (res)
        return res;
    
    // 初始化HMAC
    res = crypto_mac_init(ctx, key, keysize);
    if (res != TEE_SUCCESS)
        goto func_exit;
    
    // 对每个数据帧计算HMAC
    for (i = 0; i < blkcnt; i++) {
        res = crypto_mac_update(ctx, datafrms[i].data,
                               RPMB_MAC_PROTECT_DATA_SIZE);
        if (res != TEE_SUCCESS)
            goto func_exit;
    }
    
    // 计算最终MAC值
    res = crypto_mac_final(ctx, mac, macsize);
    
func_exit:
    crypto_mac_free_ctx(ctx);
    return res;
}

#define RPMB_DATA_OFFSET            (RPMB_STUFF_DATA_SIZE + RPMB_KEY_MAC_SIZE)
#define RPMB_MAC_PROTECT_DATA_SIZE  (RPMB_DATA_FRAME_SIZE - RPMB_DATA_OFFSET)

// MAC保护的数据包括:
// - data[256]: 数据载荷
// - nonce[16]: 随机数
// - write_counter[4]: 写计数器
// - address[2]: 块地址
// - block_count[2]: 块数量
// - op_result[2]: 操作结果
// - msg_type[2]: 消息类型
// 总计284字节

#define RPMB_STORAGE_START_ADDRESS      0       // RPMB存储起始地址
#define RPMB_FS_FAT_START_ADDRESS       512     // FAT表起始地址
#define RPMB_FS_MAGIC                   0x52504D42  // "RPMB"魔数
#define FS_VERSION                      2       // 文件系统版本

struct rpmb_fs_partition {
    uint32_t rpmb_fs_magic;         // 文件系统魔数
    uint32_t fs_version;            // 版本号
    uint32_t write_counter;         // 写计数器镜像
    uint32_t fat_start_address;     // FAT表起始地址
    uint8_t reserved[112];          // 保留字段
} __packed;                         // 总计128字节

#define FILE_IS_ACTIVE                  (1u << 0)   // 文件活跃标志
#define FILE_IS_LAST_ENTRY              (1u << 1)   // 最后条目标志
#define TEE_RPMB_FS_FILENAME_LENGTH     224         // 文件名最大长度

struct rpmb_fat_entry {
    uint32_t start_address;                         // 文件起始地址
    uint32_t data_size;                            // 数据大小
    uint32_t flags;                                // 标志位
    uint32_t unused;                               // 保留字段
    uint8_t fek[TEE_FS_KM_FEK_SIZE];              // 文件加密密钥(16字节)
    char filename[TEE_RPMB_FS_FILENAME_LENGTH];    // 文件名(224字节)
} __packed;                                        // 总计256字节

struct rpmb_file_handle {
    struct rpmb_fat_entry fat_entry;               // FAT条目
    const TEE_UUID *uuid;                          // TA UUID
    char filename[TEE_RPMB_FS_FILENAME_LENGTH];   // 文件名
    uint32_t rpmb_fat_address;                     // FAT条目在RPMB中的地址
};

struct rpmb_fat_entry_dir {
    struct rpmb_fat_entry *rpmb_fat_entry_buf;     // FAT条目缓冲区
    uint32_t idx_curr;                             // 当前索引
    uint32_t num_buffered;                         // 缓冲条目数
    uint32_t num_total_read;                       // 总读取条目数
    bool last_reached;                             // 是否到达末尾
};

// 缓存配置
#define RPMB_BUF_MAX_ENTRIES (CFG_RPMB_FS_CACHE_ENTRIES + CFG_RPMB_FS_RD_ENTRIES)

#define RPMB_EMMC_CID_SIZE 16

struct rpmb_dev_info {
    uint8_t cid[RPMB_EMMC_CID_SIZE];    // eMMC卡标识符
    uint8_t rpmb_size_mult;             // RPMB大小倍数 (EXT CSD[168])
    uint8_t rel_wr_sec_c;               // 可靠写扇区数 (EXT CSD[222])
    uint8_t ret_code;                   // 返回码
};

// RPMB容量计算
// rpmb_size = rpmb_size_mult * 128KB
// 例如: rpmb_size_mult = 32 → RPMB容量 = 4MB

// 可靠写能力
// rel_wr_sec_c 定义了每次原子写操作的最大扇区数
// 通常为1个扇区(512字节)或更多

static TEE_Result rpmb_init(uint16_t dev_id)
{
    TEE_Result res = TEE_SUCCESS;
    
    // 1. 分配RPMB上下文
    if (!rpmb_ctx) {
        rpmb_ctx = calloc(1, sizeof(struct tee_rpmb_ctx));
        if (!rpmb_ctx)
            return TEE_ERROR_OUT_OF_MEMORY;
    }
    
    // 2. 获取设备信息
    res = rpmb_get_dev_info(dev_id);
    if (res != TEE_SUCCESS)
        goto func_exit;
    
    // 3. 派生RPMB密钥
    res = tee_rpmb_key_gen(rpmb_ctx->key, RPMB_KEY_MAC_SIZE);
    if (res != TEE_SUCCESS)
        goto func_exit;
    rpmb_ctx->key_derived = true;
    
    // 4. 验证密钥和读取写计数器
    res = rpmb_verify_key_and_get_counter(dev_id);
    if (res != TEE_SUCCESS)
        goto func_exit;
    
    // 5. 初始化FAT缓存
    res = rpmb_fs_setup();
    
func_exit:
    if (res != TEE_SUCCESS) {
        free(rpmb_ctx);
        rpmb_ctx = NULL;
    }
    return res;
}

static TEE_Result rpmb_write_data(uint16_t dev_id, uint16_t blk_idx,
                                 uint8_t *data_ptr, uint16_t blkcnt)
{
    TEE_Result res;
    struct rpmb_data_frame *datafrm = NULL;
    struct rpmb_req *req = NULL;
    uint8_t mac[RPMB_KEY_MAC_SIZE];
    uint32_t req_size = 0;
    uint16_t msg_type = RPMB_MSG_TYPE_REQ_AUTH_DATA_WRITE;
    
    // 1. 分配数据帧
    datafrm = alloc_data_frame();
    if (!datafrm)
        return TEE_ERROR_OUT_OF_MEMORY;
    
    // 2. 填充数据帧
    memcpy(datafrm->data, data_ptr, blkcnt * RPMB_DATA_SIZE);
    u16_to_bytes(msg_type, datafrm->msg_type);
    u16_to_bytes(blk_idx, datafrm->address);
    u16_to_bytes(blkcnt, datafrm->block_count);
    u32_to_bytes(rpmb_ctx->wr_cnt, datafrm->write_counter);
    
    // 3. 计算MAC
    res = tee_rpmb_mac_calc(mac, RPMB_KEY_MAC_SIZE,
                           rpmb_ctx->key, RPMB_KEY_MAC_SIZE,
                           datafrm, blkcnt);
    if (res != TEE_SUCCESS)
        goto func_exit;
    
    memcpy(datafrm->key_mac, mac, RPMB_KEY_MAC_SIZE);
    
    // 4. 构建请求
    req_size = sizeof(struct rpmb_req) + 
               blkcnt * sizeof(struct rpmb_data_frame);
    req = thread_rpc_alloc_payload(req_size);
    if (!req) {
        res = TEE_ERROR_OUT_OF_MEMORY;
        goto func_exit;
    }
    
    req->cmd = RPMB_CMD_DATA_REQ;
    req->dev_id = dev_id;
    req->block_count = blkcnt;
    memcpy(TEE_RPMB_REQ_DATA(req), datafrm, 
           blkcnt * sizeof(struct rpmb_data_frame));
    
    // 5. 发送请求
    res = thread_rpc_cmd(OPTEE_MSG_RPC_CMD_RPMB, 1, &param);
    
    // 6. 处理响应和验证结果
    if (res == TEE_SUCCESS) {
        res = rpmb_verify_write_result(dev_id);
        if (res == TEE_SUCCESS)
            rpmb_ctx->wr_cnt++; // 更新写计数器
    }
    
func_exit:
    free_data_frame(datafrm);
    thread_rpc_free_payload(req);
    return res;
}

static TEE_Result rpmb_read_data(uint16_t dev_id, uint16_t blk_idx,
                                uint8_t *data_ptr, uint16_t blkcnt)
{
    TEE_Result res;
    struct rpmb_data_frame *datafrm = NULL;
    struct rpmb_req *req = NULL;
    uint8_t mac[RPMB_KEY_MAC_SIZE];
    uint8_t nonce[RPMB_NONCE_SIZE];
    
    // 1. 生成随机nonce
    res = crypto_rng_read(nonce, RPMB_NONCE_SIZE);
    if (res != TEE_SUCCESS)
        return res;
    
    // 2. 构建读请求数据帧
    datafrm = alloc_data_frame();
    if (!datafrm)
        return TEE_ERROR_OUT_OF_MEMORY;
    
    memcpy(datafrm->nonce, nonce, RPMB_NONCE_SIZE);
    u16_to_bytes(RPMB_MSG_TYPE_REQ_AUTH_DATA_READ, datafrm->msg_type);
    u16_to_bytes(blk_idx, datafrm->address);
    u16_to_bytes(blkcnt, datafrm->block_count);
    
    // 3. 发送读请求
    req = build_rpmb_req(RPMB_CMD_DATA_REQ, dev_id, datafrm, 1);
    res = thread_rpc_cmd(OPTEE_MSG_RPC_CMD_RPMB, 1, &param);
    if (res != TEE_SUCCESS)
        goto func_exit;
    
    // 4. 验证响应MAC
    res = rpmb_verify_read_response(datafrm, blkcnt, nonce);
    if (res != TEE_SUCCESS)
        goto func_exit;
    
    // 5. 复制数据
    memcpy(data_ptr, datafrm->data, blkcnt * RPMB_DATA_SIZE);
    
func_exit:
    free_data_frame(datafrm);
    thread_rpc_free_payload(req);
    return res;
}

// 每次写操作前验证写计数器
static TEE_Result verify_write_counter(uint32_t expected_counter)
{
    if (rpmb_ctx->wr_cnt != expected_counter) {
        EMSG("Write counter mismatch: expected %u, got %u",
             expected_counter, rpmb_ctx->wr_cnt);
        return TEE_ERROR_SECURITY;
    }
    return TEE_SUCCESS;
}

// MAC保护的数据字段:
struct rpmb_mac_data {
    uint8_t data[256];              // 用户数据
    uint8_t nonce[16];              // 随机数(读操作)
    uint8_t write_counter[4];       // 写计数器
    uint8_t address[2];             // 块地址
    uint8_t block_count[2];         // 块数量
    uint8_t op_result[2];           // 操作结果
    uint8_t msg_type[2];            // 消息类型
} __packed;

// 使用事务日志确保文件系统操作原子性
static TEE_Result atomic_update_fat_entry(struct rpmb_fat_entry *entry)
{
    TEE_Result res;
    
    // 1. 备份当前FAT条目
    res = backup_fat_entry(entry);
    if (res != TEE_SUCCESS)
        return res;
    
    // 2. 写入新的FAT条目
    res = write_fat_entry(entry);
    if (res != TEE_SUCCESS) {
        // 失败时恢复备份
        restore_fat_entry(entry);
        return res;
    }
    
    // 3. 确认提交
    res = commit_fat_update();
    return res;
}

// 配置选项
#define CFG_RPMB_FS_CACHE_ENTRIES   128  // 缓存条目数
#define CFG_RPMB_FS_RD_ENTRIES      8    // 批量读取条目数

// 缓存命中优化
static struct rpmb_fat_entry *find_cached_entry(const char *filename)
{
    for (int i = 0; i < fat_entry_dir->num_buffered; i++) {
        if (strcmp(fat_entry_dir->rpmb_fat_entry_buf[i].filename, 
                  filename) == 0) {
            return &fat_entry_dir->rpmb_fat_entry_buf[i];
        }
    }
    return NULL;
}

// 批量读取多个FAT条目
static TEE_Result read_fat_entries_batch(uint32_t start_addr, 
                                         uint16_t count)
{
    // 单次RPMB操作读取多个FAT条目
    return rpmb_read_data(rpmb_ctx->dev_id, 
                         start_addr / RPMB_DATA_SIZE,
                         (uint8_t *)fat_entry_dir->rpmb_fat_entry_buf,
                         count);
}

static struct mutex rpmb_mutex = MUTEX_INITIALIZER;

static TEE_Result rpmb_operation_with_lock(rpmb_operation_t operation)
{
    TEE_Result res;
    
    mutex_lock(&rpmb_mutex);
    res = operation();
    mutex_unlock(&rpmb_mutex);
    
    return res;
}

static bool rpmb_dead = false;  // RPMB设备失效标志

static TEE_Result check_rpmb_status(void)
{
    if (rpmb_dead) {
        EMSG("RPMB device is marked as dead");
        return TEE_ERROR_STORAGE_NOT_AVAILABLE;
    }
    
    if (rpmb_ctx->reinit) {
        return rpmb_reinitialize();
    }
    
    return TEE_SUCCESS;
}

static TEE_Result handle_mac_failure(void)
{
    EMSG("RPMB MAC verification failed - possible attack detected");
    
    // 标记设备为不可用
    rpmb_dead = true;
    
    // 清理敏感数据
    memzero_explicit(rpmb_ctx->key, sizeof(rpmb_ctx->key));
    
    return TEE_ERROR_SECURITY;
}

static TEE_Result handle_counter_error(uint32_t expected, uint32_t actual)
{
    if (actual < expected) {
        // 检测到重放攻击
        EMSG("Replay attack detected: counter rollback from %u to %u",
             expected, actual);
        return TEE_ERROR_SECURITY;
    } else if (actual > expected + 1) {
        // 计数器跳跃，可能有其他访问
        WMSG("Counter jump detected: from %u to %u", expected, actual);
        rpmb_ctx->wr_cnt = actual;
        return TEE_ERROR_COMMUNICATION;
    }
    
    return TEE_SUCCESS;
}

static TEE_Result rpmb_reinitialize(void)
{
    TEE_Result res;
    
    // 1. 重新获取设备信息
    res = rpmb_get_dev_info(rpmb_ctx->dev_id);
    if (res != TEE_SUCCESS)
        return res;
    
    // 2. 重新派生密钥
    res = tee_rpmb_key_gen(rpmb_ctx->key, RPMB_KEY_MAC_SIZE);
    if (res != TEE_SUCCESS)
        return res;
    
    // 3. 重新同步写计数器
    res = rpmb_get_write_counter(rpmb_ctx->dev_id);
    if (res != TEE_SUCCESS)
        return res;
    
    rpmb_ctx->reinit = false;
    return TEE_SUCCESS;
}

软件安全存储的根本缺陷：
┌─────────────────────────────────────────────────────────────┐
│ 无法防止物理攻击 -> 存储介质可被直接访问修改                │
│ 重放攻击脆弱性 -> 攻击者可回滚到旧状态                      │
│ 软件实现复杂性 -> 增加攻击面和漏洞风险                      │
│ 性能开销较大 -> 完整性验证需要大量计算                      │
└─────────────────────────────────────────────────────────────┘

RPMB硬件安全特性：
┌─────────────────────────────────────────────────────────────┐
│ 硬件防重放保护  │ 单调递增的写计数器，硬件强制执行         │
├─────────────────────────────────────────────────────────────┤
│ 硬件认证机制    │ HMAC-SHA256计算在安全控制器中执行        │
├─────────────────────────────────────────────────────────────┤
│ 原子操作保证    │ 硬件级事务支持，避免不一致状态           │
├─────────────────────────────────────────────────────────────┤
│ 密钥不可提取    │ 认证密钥硬件保护，永不离开安全区域       │
└─────────────────────────────────────────────────────────────┘

// 安全存储方案比较分析
struct security_storage_comparison {
    // RPMB方案特性
    struct rpmb_characteristics {
        bool hardware_replay_protection;    // 硬件防重放
        bool hardware_integrity_protection; // 硬件完整性保护
        bool atomic_operations;            // 原子操作
        bool limited_capacity;             // 容量限制
        bool eMMC_dependency;              // 依赖eMMC
        uint32_t performance_overhead;     // 性能开销
    } rpmb;
    
    // 安全元件(SE)方案
    struct secure_element_characteristics {
        bool highest_security;             // 最高安全级别
        bool crypto_acceleration;          // 加密加速
        bool very_limited_capacity;        // 极小容量
        bool high_cost;                   // 高成本
        bool specialized_hardware;         // 专用硬件
    } secure_element;
    
    // 加密文件系统方案
    struct encrypted_fs_characteristics {
        bool unlimited_capacity;           // 无限容量
        bool software_implementation;      // 软件实现
        bool no_replay_protection;        // 无防重放
        bool complex_key_management;       // 复杂密钥管理
        bool vulnerability_to_attacks;     // 易受攻击
    } encrypted_fs;
};

// OP-TEE选择RPMB的决策矩阵
static void analyze_rpmb_selection_criteria()
{
    /*
    OP-TEE选择RPMB的关键考量：
    
    1. 安全性优先：
       - 防重放攻击是关键需求（票据、计数器等）
       - 硬件级保护比软件实现更可靠
       - 单调性保证对安全协议至关重要
    
    2. 成本效益平衡：
       - eMMC已广泛部署，无额外硬件成本
       - 相比专用安全芯片成本更低
       - 容量虽小但足够存储关键安全数据
    
    3. 实现复杂度：
       - 硬件提供原子操作，简化软件实现
       - 标准化协议，跨平台兼容性好
       - 与TEE架构天然契合
    
    4. 性能考虑：
       - 虽然有性能开销，但安全关键数据量通常较小
       - 硬件认证比软件验证更高效
       - 与高性能存储后端互补使用
    */
}

// 重放攻击的形式化模型
struct replay_attack_model {
    // 攻击场景定义
    struct attack_scenario {
        uint32_t legitimate_counter;       // 合法计数器值
        uint32_t replayed_counter;        // 重放的计数器值
        bool physical_access;             // 物理访问能力
        bool storage_modification;        // 存储修改能力
    } scenario;
    
    // 防护机制
    struct protection_mechanism {
        bool monotonic_property;          // 单调性属性
        bool hardware_enforcement;        // 硬件强制执行
        bool tamper_resistance;          // 防篡改性
        bool non_volatile_storage;       // 非易失性存储
    } protection;
};

// 单调性的数学性质
static void formal_monotonicity_analysis()
{
    /*
    单调写计数器的形式化性质：
    
    1. 严格单调递增：
       ∀ t1, t2: t1 < t2 → counter(t1) < counter(t2)
       
    2. 不可回退性：
       ∀ c1, c2: write(c1) after write(c2) → c1 > c2
       
    3. 全序关系：
       计数器值在所有操作间建立全序关系
       
    4. 重放检测：
       任何 c' ≤ c_current 的写操作都被拒绝
       
    这些性质确保了即使攻击者可以：
    - 完全控制存储介质
    - 回滚文件系统状态
    - 重放任意历史数据
    
    也无法破坏系统的安全性，因为计数器的硬件单调性
    会检测并拒绝任何重放攻击。
    */
}

// 计数器生命周期管理
struct counter_lifecycle_management {
    // 计数器容量分析
    struct capacity_analysis {
        uint32_t max_value;               // 最大值 (2^32 - 1)
        uint32_t operations_per_day;      // 每日操作数估算
        uint32_t years_until_overflow;    // 溢出前年数
        bool overflow_risk_acceptable;    // 溢出风险可接受性
    } capacity;
    
    // 溢出处理策略
    struct overflow_handling {
        bool graceful_degradation;        // 优雅降级
        bool migration_to_new_device;     // 迁移到新设备
        bool service_lifecycle_alignment; // 与服务生命周期对齐
        bool early_warning_system;       // 早期预警系统
    } handling;
};

// 实际部署中的计数器使用分析
static void real_world_counter_usage_analysis()
{
    /*
    RPMB计数器在实际部署中的使用模式：
    
    1. 使用频率分析：
       - 安全关键操作：每天 < 100次
       - TA安装/更新：每月 < 10次  
       - 密钥轮换：每年 < 10次
       - 总计：约 50,000次/年
    
    2. 生命周期计算：
       - 32位计数器容量：4,294,967,296
       - 按年化50,000次计算：约85,000年
       - 实际设备生命周期：5-10年
       - 结论：计数器溢出在实践中不是问题
    
    3. 设计余量：
       - 即使操作频率增加100倍仍有充足余量
       - 为意外的高频使用场景提供缓冲
       - 支持未来功能扩展的需求
    */
}

// 认证方案比较分析
enum authentication_method {
    HMAC_SHA256,        // 当前选择
    DIGITAL_SIGNATURE,  // 数字签名
    AES_CMAC,          // AES-CMAC
    POLY1305_MAC       // Poly1305 MAC
};

struct authentication_analysis {
    enum authentication_method method;
    
    // 安全属性
    struct security_properties {
        uint32_t security_level;          // 安全级别（位）
        bool quantum_resistance;          // 量子抗性
        bool forgery_resistance;          // 抗伪造性
        bool length_extension_resistance; // 抗长度扩展
    } security;
    
    // 性能属性
    struct performance_properties {
        uint32_t computation_cost;        // 计算成本
        uint32_t key_size;               // 密钥大小
        uint32_t tag_size;               // 标签大小
        bool hardware_acceleration;      // 硬件加速支持
    } performance;
    
    // 实现属性
    struct implementation_properties {
        bool standardized;               // 标准化程度
        uint32_t code_complexity;       // 代码复杂度
        bool side_channel_resistance;    // 侧信道抗性
        bool constant_time_implementation; // 常数时间实现
    } implementation;
};

// HMAC-SHA256选择原理
static void analyze_hmac_sha256_choice()
{
    /*
    OP-TEE选择HMAC-SHA256的设计理由：
    
    1. 安全性充分：
       - 128位安全级别，满足长期安全需求
       - 抗碰撞、抗原像、抗第二原像攻击
       - 基于广泛验证的SHA-256哈希函数
       - 已通过大量密码学分析验证
    
    2. 性能优势：
       - ARM处理器通常有SHA-256硬件加速
       - 相比RSA/ECDSA数字签名性能更好
       - 固定的计算时间，避免侧信道攻击
       - 内存占用小，适合嵌入式环境
    
    3. 实现简单：
       - 对称密钥操作，无需复杂的公钥基础设施
       - 标准化算法，有成熟的实现库
       - 常数时间实现相对容易
       - 调试和验证相对简单
    
    4. 兼容性考虑：
       - 广泛的硬件平台支持
       - 与eMMC RPMB规范完全兼容
       - 未来升级路径清晰（SHA-3等）
    */
}

// HMAC安全性的理论基础
struct hmac_security_foundation {
    // 基于PRF的安全模型
    struct prf_security_model {
        bool indistinguishability;       // 不可区分性
        bool unpredictability;          // 不可预测性
        bool key_recovery_resistance;    // 抗密钥恢复
        bool related_key_resistance;     // 抗相关密钥攻击
    } prf_model;
    
    // 基于哈希函数的安全归约
    struct hash_based_reduction {
        bool collision_resistance_dependency; // 依赖抗碰撞性
        bool preimage_resistance_dependency;  // 依赖抗原像性
        bool compression_function_security;   // 压缩函数安全性
        bool merkle_damgard_construction;     // Merkle-Damgård构造
    } reduction;
};

// HMAC在RPMB中的具体安全分析
static void rpmb_hmac_security_analysis()
{
    /*
    HMAC-SHA256在RPMB场景中的安全性分析：
    
    1. 威胁模型：
       - 攻击者可以观察所有RPMB通信
       - 攻击者可以尝试伪造认证标签
       - 攻击者无法获取RPMB认证密钥
       - 攻击者可以重放历史消息
    
    2. 安全目标：
       - 消息认证：确保消息来源的真实性
       - 完整性保护：检测任何数据篡改
       - 防重放：结合计数器防止重放攻击
    
    3. 安全分析：
       - HMAC伪造概率：2^-128（在随机预言机模型下）
       - 密钥恢复攻击：需要2^128次查询（不现实）
       - 相关密钥攻击：RPMB密钥独立生成，风险极小
       - 侧信道攻击：硬件实现通常具有天然保护
    
    4. 实际攻击向量：
       - 最现实的攻击是暴力破解密钥
       - 2^128的搜索空间在计算上不可行
       - 即使使用专用ASIC，仍需要天文数字的时间
    */
}

// 原子性需求分析
struct atomicity_requirements {
    // 一致性需求
    struct consistency_requirements {
        bool data_integrity_consistency;    // 数据完整性一致性
        bool metadata_consistency;          // 元数据一致性
        bool counter_data_consistency;      // 计数器-数据一致性
        bool fat_data_consistency;         // FAT-数据一致性
    } consistency;
    
    // 故障场景
    struct failure_scenarios {
        bool power_failure_during_write;    // 写操作中断电
        bool communication_interruption;    // 通信中断
        bool hardware_failure;             // 硬件故障
        bool software_crash;               // 软件崩溃
    } failures;
    
    // 恢复需求
    struct recovery_requirements {
        bool deterministic_state;          // 确定性状态
        bool no_data_loss;                // 无数据丢失
        bool automatic_recovery;           // 自动恢复
        bool corruption_detection;         // 损坏检测
    } recovery;
};

// RPMB原子性实现的设计原理
static void rpmb_atomicity_design_principles()
{
    /*
    RPMB硬件原子性的设计原理：
    
    1. 硬件事务支持：
       - eMMC控制器提供事务级别的原子性保证
       - 单个RPMB写操作要么完全成功，要么完全失败
       - 没有部分写入的中间状态
    
    2. 写计数器与数据的原子绑定：
       - 计数器增量和数据写入在同一事务中
       - 防止计数器更新但数据写入失败的不一致状态
       - 确保每个计数器值对应唯一的数据状态
    
    3. 认证与数据的原子验证：
       - HMAC计算包含计数器值
       - 数据、计数器、认证标签必须全部匹配
       - 任何不一致都会被立即检测到
    
    4. 故障恢复的简化：
       - 原子性使得只有两种可能状态：操作前和操作后
       - 不需要复杂的恢复算法
       - 系统状态始终是一致的
    */
}

// 软件事务实现
struct software_transaction_layer {
    // 事务状态管理
    struct transaction_state {
        enum transaction_phase {
            TX_PHASE_PREPARE,       // 准备阶段
            TX_PHASE_COMMIT,        // 提交阶段
            TX_PHASE_COMPLETE,      // 完成阶段
            TX_PHASE_ABORT          // 中止阶段
        } phase;
        
        uint32_t transaction_id;    // 事务ID
        uint32_t expected_counter;  // 期望计数器值
        bool rollback_required;     // 需要回滚
    } state;
    
    // 补偿操作设计
    struct compensation_operations {
        bool backup_before_write;   // 写前备份
        bool verify_after_write;    // 写后验证
        bool automatic_rollback;    // 自动回滚
        bool integrity_checking;    // 完整性检查
    } compensation;
};

// 分布式事务处理原理
static void distributed_transaction_principles()
{
    /*
    RPMB事务与分布式系统的类比：
    
    1. 两阶段提交协议的简化版本：
       - Phase 1: 准备 - 验证操作可行性
       - Phase 2: 提交 - 执行实际的RPMB写操作
       - 简化：由于RPMB的原子性，不需要复杂的协调
    
    2. ACID属性在RPMB中的体现：
       - Atomicity: 硬件保证的操作原子性
       - Consistency: 认证机制保证的数据一致性
       - Isolation: 全局锁保证的操作隔离性
       - Durability: 非易失性存储保证的持久性
    
    3. CAP定理的权衡：
       - Consistency: 强一致性（通过全局锁）
       - Availability: 可用性（在网络分区时降级）
       - Partition tolerance: 分区容错（不适用于单机存储）
       - 选择CP：强一致性优于可用性
    */
}

// 抽象层次设计分析
struct abstraction_layer_design {
    // 原始RPMB接口的局限性
    struct raw_rpmb_limitations {
        bool block_based_access;           // 基于块的访问
        bool no_metadata_management;       // 无元数据管理
        bool manual_space_management;      // 手动空间管理
        bool complex_error_handling;       // 复杂错误处理
    } limitations;
    
    // 文件系统抽象的优势
    struct filesystem_advantages {
        bool name_based_access;            // 基于名称的访问
        bool automatic_space_management;   // 自动空间管理
        bool transparent_encryption;       // 透明加密
        bool unified_interface;           // 统一接口
    } advantages;
};

// RPMB文件系统的设计取舍
static void rpmb_fs_design_tradeoffs()
{
    /*
    RPMB文件系统设计的核心考量：
    
    1. 简化vs功能性：
       - 选择简单的FAT式结构而非复杂的B+树
       - 优势：实现简单，调试容易，攻击面小
       - 劣势：文件数量受限，碎片化问题
    
    2. 性能vs安全：
       - 每次操作都需要RPMB认证，性能开销大
       - 通过缓存机制缓解性能问题
       - 安全性优先于性能考虑
    
    3. 灵活性vs可靠性：
       - 固定的文件结构，缺乏动态调整能力
       - 但提供了可预测的行为和简单的恢复机制
    
    4. 兼容性vs创新：
       - 遵循传统文件系统概念，便于理解和使用
       - 但针对RPMB特性进行了专门优化
    */
}

// FAT表安全性设计
struct fat_table_security {
    // 元数据保护
    struct metadata_protection {
        bool encrypted_fat_entries;        // 加密FAT条目
        bool integrity_verification;       // 完整性验证
        bool atomic_fat_updates;          // 原子FAT更新
        bool redundant_storage;           // 冗余存储
    } protection;
    
    // 隐私保护
    struct privacy_protection {
        bool filename_encryption;         // 文件名加密
        bool size_obfuscation;            // 大小混淆
        bool access_pattern_hiding;       // 访问模式隐藏
        bool timing_attack_resistance;    // 抗时序攻击
    } privacy;
};

// 安全性与可用性的平衡
static void security_usability_balance()
{
    /*
    FAT表设计中的安全性与可用性平衡：
    
    1. 文件名处理：
       - 明文存储：便于调试和管理
       - 但暴露了文件结构信息
       - 权衡：安全要求较高时可加密文件名
    
    2. 元数据大小：
       - 较大的FAT条目（256字节）提供了扩展空间
       - 但增加了存储开销和传输成本
       - 权衡：为未来功能预留空间
    
    3. 缓存策略：
       - 缓存提高了性能但增加了安全风险
       - 内存中的FAT信息可能被攻击者获取
       - 权衡：使用有限的缓存并及时清理敏感信息
    
    4. 错误处理：
       - 详细的错误信息有助于调试
       - 但可能暴露系统内部状态
       - 权衡：在生产环境中限制错误信息的详细程度
    */
}

// 安全缓存设计
struct secure_cache_design {
    // 缓存安全属性
    struct cache_security_properties {
        bool encrypted_cache_content;      // 加密缓存内容
        bool cache_integrity_protection;   // 缓存完整性保护
        bool secure_cache_eviction;       // 安全缓存逐出
        bool timing_attack_resistance;     // 抗时序攻击
    } security;
    
    // 缓存生命周期管理
    struct cache_lifecycle {
        uint32_t max_cache_age;           // 最大缓存时间
        bool automatic_invalidation;       // 自动失效
        bool explicit_cache_flush;        // 显式缓存刷新
        bool power_failure_handling;      // 断电处理
    } lifecycle;
};

// 缓存策略的设计权衡
static void cache_strategy_tradeoffs()
{
    /*
    RPMB缓存策略的设计权衡：
    
    1. 安全性vs性能：
       - 缓存可以显著减少RPMB访问次数
       - 但内存中的数据可能被非法访问
       - 解决方案：限制缓存大小，加密敏感内容
    
    2. 一致性vs效率：
       - 缓存可能与RPMB内容不一致
       - 特别是在系统崩溃或并发访问时
       - 解决方案：版本号机制，写通缓存策略
    
    3. 内存使用vs访问性能：
       - 更大的缓存意味着更好的性能
       - 但在资源受限的TEE环境中需要谨慎
       - 解决方案：自适应缓存大小，LRU替换策略
    
    4. 复杂性vs可靠性：
       - 复杂的缓存机制可能引入新的bug
       - 但简单的策略可能无法满足性能需求
       - 解决方案：逐步演进，充分测试
    */
}

// 故障模型定义
struct failure_model {
    // 硬件故障
    struct hardware_failures {
        bool eMMC_device_failure;          // eMMC设备故障
        bool controller_malfunction;       // 控制器故障
        bool power_supply_interruption;    // 电源中断
        bool signal_integrity_issues;      // 信号完整性问题
    } hardware;
    
    // 软件故障
    struct software_failures {
        bool driver_bugs;                  // 驱动程序错误
        bool protocol_violations;          // 协议违反
        bool memory_corruption;           // 内存损坏
        bool race_conditions;             // 竞争条件
    } software;
    
    // 安全攻击
    struct security_attacks {
        bool replay_attacks;              // 重放攻击
        bool man_in_the_middle;          // 中间人攻击
        bool physical_tampering;          // 物理篡改
        bool side_channel_attacks;        // 侧信道攻击
    } attacks;
};

// 分层错误处理策略
static void layered_error_handling_strategy()
{
    /*
    RPMB错误处理的分层设计：
    
    1. 硬件层错误处理：
       - eMMC控制器提供基本的错误检测
       - 硬件重试机制处理瞬时故障
       - 永久性故障通过错误码上报
    
    2. 协议层错误处理：
       - RPMB协议层验证消息格式和认证
       - 检测并报告协议违反
       - 实现超时和重试机制
    
    3. 文件系统层错误处理：
       - 检测文件系统不一致性
       - 实现自动修复机制
       - 提供用户级错误信息
    
    4. 应用层错误处理：
       - 将底层错误转换为应用可理解的形式
       - 实现重试和降级策略
       - 记录错误日志供调试使用
    */
}

// 设备失效处理哲学
struct device_failure_philosophy {
    // 失效检测策略
    struct failure_detection {
        bool proactive_health_monitoring;  // 主动健康监控
        bool early_warning_system;        // 早期预警系统
        bool statistical_anomaly_detection; // 统计异常检测
        bool threshold_based_alerts;       // 基于阈值的警报
    } detection;
    
    // 失效响应策略
    struct failure_response {
        bool graceful_degradation;         // 优雅降级
        bool automatic_failover;           // 自动故障转移
        bool data_migration;              // 数据迁移
        bool service_continuity;          // 服务连续性
    } response;
};

// 渐进式故障处理
static void progressive_failure_handling()
{
    /*
    RPMB故障处理的渐进式策略：
    
    1. 轻微故障（软错误）：
       - 自动重试机制
       - 临时性网络问题处理
       - 不影响正常服务
    
    2. 中等故障（硬错误）：
       - 服务降级但继续运行
       - 切换到备用存储后端
       - 用户可能感知到性能下降
    
    3. 严重故障（致命错误）：
       - 完全停止RPMB服务
       - 激活安全保护机制
       - 需要人工干预和设备更换
    
    4. 安全威胁（攻击检测）：
       - 立即停止所有操作
       - 清理敏感数据
       - 触发安全事件响应流程
    
    这种渐进式方法确保系统在各种故障条件下
    都能提供适当的响应，既保证安全性又维护可用性。
    */
}