// 设计哲学体现：即使在调试模式下也要显式标记不安全行为
if (res == TEE_ERROR_NOT_IMPLEMENTED && IS_ENABLED(CFG_INSECURE)) {
    static bool once;
    if (!once) {
        IMSG("WARNING (insecure configuration): Failed to get monotonic counter");
        once = true;
    }
    // 只在明确标记为不安全的构建中允许
}

// 所有操作默认失败，必须显式成功
TEE_Result tee_fs_open(struct tee_file_handle **fh, const TEE_UUID *uuid,
                      void *obj_id, size_t obj_id_len, uint32_t flags)
{
    TEE_Result res = TEE_ERROR_GENERIC;  // 默认失败
    
    // 只有所有检查都通过才返回成功
    // 1. 参数验证
    // 2. 权限检查  
    // 3. 资源分配
    // 4. 密钥验证
    
    return res;  // 明确的成功或失败
}

应用层:      GlobalPlatform API 权限检查
对象层:      对象ID验证、TA UUID验证
加密层:      多层密钥保护 (HUK->SSK->TSK->FEK)
完整性层:    哈希树完整性验证
存储层:      后端特定保护 (RPMB MAC, REE FS 权限)
硬件层:      TrustZone 隔离、硬件密钥

// TA 只能访问自己的存储，通过密钥隔离实现
static TEE_Result get_ta_storage_key(const TEE_UUID *uuid, uint8_t *tsk)
{
    if (uuid) {
        // 每个 TA 都有唯一的存储密钥
        return do_hmac(tsk, TEE_FS_KM_TSK_SIZE, 
                      tee_fs_ssk.key, TEE_FS_KM_SSK_SIZE, 
                      uuid, sizeof(*uuid));
    } else {
        // 非 TA 存储使用不同的密钥
        uint8_t dummy[1] = { 0 };
        return do_hmac(tsk, TEE_FS_KM_TSK_SIZE,
                      tee_fs_ssk.key, TEE_FS_KM_SSK_SIZE,
                      dummy, sizeof(dummy));
    }
}

// 任何可疑情况都导致操作失败
static TEE_Result verify_node(struct traverse_arg *targ, struct htree_node *node)
{
    uint8_t digest[TEE_FS_HTREE_HASH_SIZE];
    
    res = calc_node_hash(node, &targ->ht->imeta.meta, ctx, digest);
    if (res != TEE_SUCCESS)
        return res;  // 计算失败立即退出
        
    // 使用常数时间比较防止时序攻击
    if (consttime_memcmp(digest, node->node.hash, sizeof(digest))) {
        EMSG("Hash verification failed for node %zu", node->id);
        return TEE_ERROR_CORRUPT_OBJECT;  // 发现任何不一致立即失败
    }
    
    return TEE_SUCCESS;
}

// 所有错误路径都包含完整的资源清理
TEE_Result tee_fs_fek_crypt(const TEE_UUID *uuid, TEE_OperationMode mode,
                           const uint8_t *in_key, size_t size,
                           uint8_t *out_key)
{
    uint8_t tsk[TEE_FS_KM_TSK_SIZE];
    uint8_t dst_key[size];
    void *ctx = NULL;
    
    // ... 执行加密操作
    
exit:
    crypto_cipher_free_ctx(ctx);
    memzero_explicit(tsk, sizeof(tsk));      // 保证密钥清理
    memzero_explicit(dst_key, sizeof(dst_key));
    return res;  // 无论成功失败都会清理敏感数据
}

// 即使是内部组件也要验证输入
static TEE_Result htree_sync_node_to_storage(struct traverse_arg *targ,
                                            struct htree_node *node)
{
    if (!targ || !node) {
        EMSG("Invalid parameters in internal function");
        return TEE_ERROR_BAD_PARAMETERS;  // 内部调用也验证参数
    }
    
    // 验证节点状态的一致性
    if (node->dirty && !node->block_updated) {
        EMSG("Inconsistent node state detected");
        return TEE_ERROR_BAD_STATE;
    }
    
    // 即使是内部操作也进行完整性检查
    return verify_and_sync_node(targ, node);
}

HUK (硬件唯一密钥)
 ↓ HMAC-SHA256
SSK (安全存储密钥) 
 ↓ HMAC-SHA256 + TA_UUID
TSK (TA存储密钥)
 ↓ AES-ECB
FEK (文件加密密钥)
 ↓ AES-CBC + ESSIV
实际数据

如果合并SSK和TSK层:
- 失去了TA隔离的灵活性
- 硬件密钥直接用于TA推导，增加泄露风险
- 无法支持非TA存储（如认证数据）

如果添加额外层次:
- 增加计算开销
- 增加密钥管理复杂性
- 没有明确的安全边界需要额外保护
- 违反简单性原则

// REE FS 优势: 高性能、大容量、易于实现
struct ree_fs_storage_ctx {
    size_t block_size;           // 4KB 块，优化I/O性能
    bool cached;                 // 支持缓存优化
    // 牺牲: 依赖REE安全性，容易受到物理攻击
};

// RPMB 优势: 硬件保护、防篡改、原子操作
struct rpmb_data_frame {
    uint8_t key_mac[RPMB_KEY_MAC_SIZE];  // 硬件HMAC保护
    uint32_t write_counter;               // 硬件单调计数器
    // 牺牲: 容量小、性能低、硬件依赖
};

// 智能后端选择策略
static const struct tee_fs_htree_storage *select_storage_backend(
    size_t estimated_size, bool requires_anti_rollback)
{
    if (requires_anti_rollback || estimated_size < RPMB_THRESHOLD) {
        return &rpmb_storage_ops;  // 安全关键或小文件用RPMB
    } else {
        return &ree_fs_storage_ops;  // 大文件或性能敏感用REE FS
    }
}

// 简单但不安全
struct simple_checksum {
    uint32_t crc32;  // 可以被恶意修改
    uint8_t data[];
};
// 问题: 容易伪造，不提供密码学保护

// 安全但不灵活
struct single_mac {
    uint8_t hmac[32];  // 整个文件的HMAC
    uint8_t data[];
};
// 问题: 修改任何部分都需要重新计算整个文件的MAC

// 安全且高效
struct hash_tree_node {
    uint8_t hash[32];           // 子树的密码学哈希
    struct hash_tree_node *children[2];
};
// 优势: 部分更新、完整性验证、对数复杂度

// 只需要更新从叶子到根的路径
static TEE_Result update_hash_path(struct htree_node *leaf)
{
    struct htree_node *current = leaf;
    
    while (current) {
        // 只重新计算这条路径上的哈希
        calc_node_hash(current, NULL, ctx, current->node.hash);
        current = current->parent;  // 向上传播
    }
    
    // O(log n) 复杂度而不是 O(n)
}

// 不同子树可以并发验证
static TEE_Result verify_subtrees_parallel(struct htree_node *root)
{
    // 左右子树可以独立验证
    verify_subtree_async(root->child[0]);
    verify_subtree_async(root->child[1]);
    
    // 提高多核性能
}

// 只同步变化的节点
static bool needs_sync(struct htree_node *node)
{
    return node->dirty || node->block_updated;
}

// 支持增量备份和同步

// 危险的就地更新
void dangerous_update(void *block, size_t offset, void *data, size_t len)
{
    memcpy((char*)block + offset, data, len);  
    // 问题: 
    // 1. 如果系统崩溃，数据损坏
    // 2. 无法回滚操作
    // 3. 并发访问不安全
}

// 安全的写时复制
static TEE_Result cow_update(struct tee_fs_fd *fdp, size_t pos, 
                            const void *buf, size_t len)
{
    uint8_t *new_block = get_tmp_block();
    
    // 1. 读取原始块
    res = tee_fs_htree_read_block(&fdp->ht, block_num, new_block);
    if (res) goto cleanup;
    
    // 2. 在副本中修改
    memcpy(new_block + offset, buf, write_size);
    
    // 3. 原子性写入新位置
    res = tee_fs_htree_write_block(&fdp->ht, block_num, new_block);
    
    // 4. 如果成功，旧块变为垃圾（延迟回收）
    //    如果失败，原始数据保持不变
    
cleanup:
    put_tmp_block(new_block);
    return res;
}

安全优先级 (不可妥协):
1. 数据机密性和完整性
2. TA 间隔离
3. 防回滚保护
4. 密钥安全管理

性能优化空间 (在安全约束下):
1. 缓存策略
2. I/O 批处理
3. 并发控制粒度  
4. 内存管理效率

// 权衡: 缓存提高性能但可能泄露信息
struct rpmb_cache_entry {
    bool valid;
    uint8_t data[RPMB_BLOCK_SIZE];
    
    // 安全措施: 缓存失效时主动清零
    void invalidate() {
        memzero_explicit(data, sizeof(data));
        valid = false;
    }
};

// 决策: 使用缓存但确保安全清理

// 权衡: 批量操作提高效率但可能影响原子性
static TEE_Result batch_write_with_atomicity(
    struct batch_operation *ops, size_t count)
{
    // 方案: 使用事务日志保证原子性
    res = begin_transaction();
    
    for (size_t i = 0; i < count; i++) {
        res = log_operation(&ops[i]);  // 先记录日志
        if (res) goto rollback;
    }
    
    res = commit_batch();  // 原子提交
    
rollback:
    if (res) rollback_transaction();
    return res;
}

// 权衡: 细粒度锁提高并发但增加死锁风险
static TEE_Result acquire_ordered_locks(struct tee_pobj *po,
                                       struct ree_fs_file *f)
{
    // 方案: 固定顺序获取锁避免死锁
    mutex_lock(&po->lock);
    
    if (f) {
        if (mutex_trylock(&f->lock) != 0) {
            // 避免死锁: 释放已获取的锁重试
            mutex_unlock(&po->lock);
            msleep(1);
            return acquire_ordered_locks(po, f);  // 重试
        }
    }
    
    return TEE_SUCCESS;
}

// 标准化的 API 提供跨平台兼容性
TEE_Result TEE_OpenPersistentObject(uint32_t storageID,
                                   void* objectID, size_t objectIDLen,
                                   uint32_t flags,
                                   TEE_ObjectHandle* object)
{
    // 优势:
    // 1. 应用程序可移植性
    // 2. 开发者学习成本低
    // 3. 标准化测试套件
    // 4. 生态系统兼容性
}

// 理论上更优化的 API (未采用)
TEE_Result optee_storage_open_with_hints(
    const char *path,
    uint32_t flags,
    struct storage_hints *hints,  // 性能提示
    struct file_handle **fh)
{
    // 可能的优势:
    // 1. 性能提示支持
    // 2. 更灵活的参数
    // 3. OP-TEE 特定优化
    
    // 但是失去了标准化优势
}

// 平衡详细性和安全性的错误代码
switch (internal_error) {
case CRYPTO_ERROR_KEY_NOT_FOUND:
case CRYPTO_ERROR_INVALID_KEY:
case CRYPTO_ERROR_KEY_EXPIRED:
    // 对外统一返回，避免信息泄露
    return TEE_ERROR_ITEM_NOT_FOUND;
    
case STORAGE_ERROR_DISK_FULL:
    return TEE_ERROR_STORAGE_NO_SPACE;  // 具体但不敏感
    
case STORAGE_ERROR_CORRUPTION:
    return TEE_ERROR_CORRUPT_OBJECT;   // 重要的诊断信息
}

// 错误信息的逐层过滤和转换
static TEE_Result high_level_operation(void)
{
    res = mid_level_operation();
    
    // 过滤内部实现细节
    switch (res) {
    case INTERNAL_CRYPTO_ERROR:
        DMSG("Internal crypto operation failed");  // 记录但不传播
        return TEE_ERROR_GENERIC;
        
    case INTERNAL_STORAGE_ERROR:
        return TEE_ERROR_STORAGE_NOT_AVAILABLE;   // 转换为通用错误
        
    default:
        return res;  // 安全的错误直接传播
    }
}

抽象层次设计原理:
Application Layer (GP API)     ← 标准化接口
  ↓
Object Management Layer        ← 对象生命周期管理
  ↓  
Encryption/Integrity Layer     ← 安全服务
  ↓
Storage Backend Layer          ← 后端抽象
  ↓
Hardware Abstraction Layer     ← 平台特定

// 清晰的层次接口定义
struct tee_file_operations {
    TEE_Result (*open)(struct tee_file_handle **fh, ...);
    TEE_Result (*close)(struct tee_file_handle **fh);
    TEE_Result (*read)(struct tee_file_handle *fh, ...);
    TEE_Result (*write)(struct tee_file_handle *fh, ...);
    // 每层只暴露必要的接口
};

// 存储后端抽象
struct tee_fs_htree_storage {
    size_t block_size;
    TEE_Result (*rpc_read_init)(...);
    TEE_Result (*rpc_write_init)(...);
    // 后端无关的统一接口
};

// 支持新存储后端的插件机制
static const struct tee_fs_htree_storage *storage_backends[] = {
    &ree_fs_storage_ops,
    &rpmb_storage_ops,
    // 未来可以添加:
    // &network_storage_ops,
    // &cloud_storage_ops,
    // &hsm_storage_ops,
    NULL
};

// 运行时选择机制
static const struct tee_fs_htree_storage *
select_storage_backend(enum storage_requirements req)
{
    for (int i = 0; storage_backends[i]; i++) {
        if (storage_backends[i]->meets_requirements(req)) {
            return storage_backends[i];
        }
    }
    return &default_storage_ops;
}

// 编译时配置支持不同部署需求
#ifdef CFG_RPMB_FS
    #define DEFAULT_SECURE_STORAGE &rpmb_storage_ops
#else
    #define DEFAULT_SECURE_STORAGE &ree_fs_storage_ops
#endif

#ifdef CFG_REE_FS_ALLOW_RESET
    #define COUNTER_RESET_POLICY ALLOW_RESET
#else
    #define COUNTER_RESET_POLICY STRICT_MONOTONIC
#endif

// 运行时配置支持
struct storage_config {
    size_t cache_size;
    bool enable_compression;
    bool enable_deduplication;
    enum consistency_level consistency;
};

// 版本化结构支持未来扩展
struct tee_fs_htree_image_v2 {
    uint32_t version;                    // 版本标识
    uint8_t iv[TEE_FS_HTREE_IV_SIZE];
    uint8_t tag[TEE_FS_HTREE_TAG_SIZE];
    uint8_t enc_fek[TEE_FS_HTREE_FEK_SIZE];
    uint8_t imeta[sizeof(struct tee_fs_htree_imeta)];
    uint32_t counter;
    uint8_t reserved[64];                // 预留空间
    uint32_t checksum;                   // 结构完整性
};

// 版本兼容处理
static TEE_Result load_htree_header(void *data, struct tee_fs_htree *ht)
{
    uint32_t version = *(uint32_t*)data;
    
    switch (version) {
    case HTREE_VERSION_1:
        return load_v1_header(data, ht);
    case HTREE_VERSION_2:
        return load_v2_header(data, ht);
    default:
        if (version > HTREE_CURRENT_VERSION) {
            EMSG("Unsupported future version %u", version);
            return TEE_ERROR_NOT_SUPPORTED;
        }
        return TEE_ERROR_CORRUPT_OBJECT;
    }
}

// 支持渐进式功能启用
struct feature_flags {
    bool compression_enabled : 1;
    bool deduplication_enabled : 1;
    bool advanced_caching : 1;
    bool distributed_storage : 1;
    uint32_t reserved : 28;
};

// 功能门控机制
#define FEATURE_ENABLED(flag) \
    (global_features.flag && compile_time_check(flag))

static TEE_Result write_block_with_features(...)
{
    if (FEATURE_ENABLED(compression_enabled)) {
        res = compress_block(...);
        if (res) return res;
    }
    
    if (FEATURE_ENABLED(deduplication_enabled)) {
        res = deduplicate_block(...);
        if (res) return res;
    }
    
    return write_block_basic(...);
}

// 数据迁移支持
struct migration_context {
    uint32_t source_version;
    uint32_t target_version;
    bool (*can_migrate)(uint32_t from, uint32_t to);
    TEE_Result (*migrate_data)(void *src, void *dst);
};

static const struct migration_context migrations[] = {
    { .source_version = 1, .target_version = 2,
      .can_migrate = can_migrate_v1_to_v2,
      .migrate_data = migrate_v1_to_v2 },
    // 支持多步迁移: v1->v2->v3
};

// 自动迁移机制
static TEE_Result auto_migrate_if_needed(struct tee_fs_htree *ht)
{
    if (ht->version < CURRENT_VERSION) {
        IMSG("Migrating storage from v%u to v%u", 
             ht->version, CURRENT_VERSION);
        return perform_migration(ht);
    }
    return TEE_SUCCESS;
}

// 单元测试: 验证单个组件
static void test_key_derivation(void)
{
    uint8_t uuid[16] = { /* test UUID */ };
    uint8_t key[32];
    
    // 测试正常情况
    assert(derive_ta_key(uuid, key) == TEE_SUCCESS);
    
    // 测试边界条件
    assert(derive_ta_key(NULL, key) == TEE_ERROR_BAD_PARAMETERS);
    
    // 测试密钥唯一性
    uint8_t key2[32];
    uuid[0] ^= 1;  // 微小变化
    assert(derive_ta_key(uuid, key2) == TEE_SUCCESS);
    assert(memcmp(key, key2, sizeof(key)) != 0);  // 必须不同
}

// 集成测试: 验证组件交互
static void test_storage_integration(void)
{
    struct tee_file_handle *fh;
    
    // 测试完整的存储流程
    assert(tee_fs_open(&fh, &test_uuid, "test", 4, 
                      TEE_DATA_FLAG_ACCESS_WRITE) == TEE_SUCCESS);
    assert(tee_fs_write(fh, test_data, sizeof(test_data)) == TEE_SUCCESS);
    assert(tee_fs_close(&fh) == TEE_SUCCESS);
    
    // 验证数据完整性
    assert(tee_fs_open(&fh, &test_uuid, "test", 4,
                      TEE_DATA_FLAG_ACCESS_READ) == TEE_SUCCESS);
    uint8_t read_data[sizeof(test_data)];
    assert(tee_fs_read(fh, read_data, sizeof(read_data)) == TEE_SUCCESS);
    assert(memcmp(test_data, read_data, sizeof(test_data)) == 0);
}

// 对抗性测试: 模拟攻击场景
static void test_security_properties(void)
{
    // 测试 TA 隔离
    test_ta_isolation_enforcement();
    
    // 测试防回滚
    test_rollback_resistance();
    
    // 测试篡改检测
    test_tampering_detection();
    
    // 测试密钥泄露影响
    test_key_compromise_containment();
}

// 模糊测试支持
static void fuzz_test_storage_api(void)
{
    for (int i = 0; i < FUZZ_ITERATIONS; i++) {
        uint8_t *random_data = generate_random_data();
        size_t data_len = random() % MAX_DATA_SIZE;
        
        // 所有随机输入都应该被安全处理
        TEE_Result res = tee_fs_write(fh, random_data, data_len);
        
        // 验证系统状态仍然一致
        assert(verify_system_consistency() == TEE_SUCCESS);
        
        free(random_data);
    }
}

// 性能基准测试
struct performance_metrics {
    uint64_t operation_count;
    uint64_t total_time_ns;
    uint64_t min_time_ns;
    uint64_t max_time_ns;
    uint64_t memory_usage_bytes;
};

static void benchmark_storage_operations(void)
{
    struct performance_metrics metrics = {0};
    
    for (int i = 0; i < BENCHMARK_ITERATIONS; i++) {
        uint64_t start = get_time_ns();
        
        // 执行被测试的操作
        perform_storage_operation();
        
        uint64_t end = get_time_ns();
        uint64_t duration = end - start;
        
        update_metrics(&metrics, duration);
    }
    
    // 验证性能要求
    assert(metrics.total_time_ns / metrics.operation_count < MAX_AVG_LATENCY);
    assert(metrics.max_time_ns < MAX_WORST_CASE_LATENCY);
}