ARMv9-A 引入的机密计算扩展,在 Normal World 与 Safe World 之间开辟了第三疆域—— Realm。本文从硬件机制、Granule Protection Table、RMM 状态机、Linux 内核主线支持到远程证明协议,拆解这一正在重塑云安全格局的系统编程基础设施。


一、为什么还需要 CCA?

在 CCA 出现之前,ARM 已经拥有 TrustZone:通过 NS(Non-Secure)与 S(Secure)比特划分 Normal/Secure 两个世界。但 TrustZone 有一个根本性缺陷——Hypervisor 和操作系统对 Realm 资源拥有完全支配权。

在云的威胁模型中,以下场景无法被 TrustZone 覆盖:

  • 租户希望即使云厂商的 Host OS 和 Hypervisor(KVM/QEMU)被攻破,自己的虚拟机/容器数据仍不可见
  • 多租户场景下,不同租户之间需要”宿主机级别的隔离证明”
  • 数据处理合规要求:GDPR、金融场景下,数据在”使用中”(in-use)也需要加密隔离

CCA 通过引入 Realm 安全状态和 Granule Protection Table 直接在硬件层面回答了这个问题:Host 物理上无法读取 Realm 内存,这不是软件约定,而是总线级的访问拦截。


二、RME(Realm Management Extension)硬件架构

2.1 两个新安全状态

ARM CCA 在原有 EL0/EL1/EL2/EL3 异常模型基础上增加了两个新的安全状态:

┌────────────────────────────────────────────────────┐
│                  ARM CCA 安全状态                    │
├──────────────┬─────────────────────────────────────┤
│ Secure       │ 原有的 TrustZone Secure World        │
├──────────────┼─────────────────────────────────────┤
│ Root         │ EL3, RME 系统级监控器 (RMM at EL3)    │
├──────────────┼─────────────────────────────────────┤
│ Realm        │ ★ 新增:受硬件保护的 Realm World       │
│              │   - Realm EL2 (RMM, Realm 的监控器)  │
│              │   - Realm EL1 (Guest OS / Hypervisor)│
│              │   - Realm EL0 (应用程序)               │
├──────────────┼─────────────────────────────────────┤
│ Normal       │ 原有 Non-Secure World               │
│              │   - EL2 (Host Hypervisor)           │
│              │   - EL1 (Host OS / KVM)             │
│              │   - EL0 (用户态进程)                   │
└──────────────┴─────────────────────────────────────┘

关键命名:Realm 的 EL2 层运行的监控器称为 RMM(Realm Management Monitor),与 Secure EL2 的 Secure Monitor 是独立的实体。

2.2 物理地址空间划分

ARM CCA 通过 IPA(Intermediate Physical Address)分区实现物理内存的物理隔离:

Physical Address Space
├── Secure IPA Space       → Secure World 独占
├── Root IPA Space         → EL3 / RMM at EL3
├── Realm IPA Space        → Realm World 独占  ★ Host 无法访问
└── Normal IPA Space       → Normal World(Host + 用户态)

Host 在创建 Realm 时需要将物理内存”捐赠”给 Realm。一旦捐赠成功,Host 虚拟机上对应物理帧的映射仍然保留,但任何访问都将触发异常被捕获到 RME 硬件层。

2.3 Daemon 与 RMM 的分工

RME 规范定义了两个组件:

组件 运行位置 职责
RMM (Realm Management Monitor) Realm EL2 管理单个 Realm 的生命周期,响应 RMI(Realm Management Interface)调用
RME Daemon (RMED) 用户态 为 Host 提供 Realm 管理代理,处理 RMI 协议转换

典型执行流:Host MED 通过 SMC 调用 RME system service → EL3 固件分发 → RMM 处理 Realm 操作 → 可能涉及 Realm IPA 到 PA 的二级页表翻译(Stage 2 MMU)。


三、Granule Protection Table(GPT):总线级隔离的核心

3.1 GPT 的工作原理

Granule Protection Table 是 CCA 最核心的硬件结构。系统物理内存被划分为固定大小的 Granule(粒,通常 4KB 或 64KB),GPT 为每个粒记录其所属的安全状态:

Granule Protection Table (GPT)
┌─────────────┬──────────────┐
│ Granule PA  │ Security     │
│ Offset      │ State        │
├─────────────┼──────────────┤
│ 0x00000     │ Normal       │
│ 0x01000     │ Normal       │
│ 0x02000     │ Realm        │  ← 该粒属于 Realm,Host 访问触发异常
│ 0x03000     │ Secure       │
│ 0x04000     │ Realm        │
│ ...         │ ...          │
└─────────────┴──────────────┘

GPT 被集成在 MMU 的路径上。任何总线事务到达内存控制器前,硬件都会查 GPT 验证:当前安全状态是否为请求的目标安全状态授权访问该粒。

3.2 粒状态机

每个 Granule 遵循以下状态转换:

            ┌─────────────────────────────────────────┐
            │          Granule State Machine            │
            └─────────────────────────────────────────┘
                      │
                      ▼
              ┌──────────────┐
              │   ASSIGNED   │  已被某个安全世界独占
              │  (Assigned)  │  
              └──────────────┘
                      │
       ┌──────────────┼──────────────┐
       ▼              ▼              ▼
┌──────────┐   ┌──────────┐   ┌──────────┐
│  Normal  │   │  Realm   │   │  Secure  │
│ Assigned │   │ Assigned │   │ Assigned │
└──────────┘   └──────────┘   └──────────┘
       │              │              │
       ▼              ▼              ▼
┌──────────┐   ┌──────────┐   ┌──────────┐
│  INVALID │   │  VALID   │   │  VALID   │
│ (未映射) │   │(Realm可达)│   │(Secure可达)│
└──────────┘   └──────────┘   └──────────┘
                      │
                      ▼
              ┌──────────────┐
              │   DESTROYED  │  RMM 销毁 Realm 时
              │  (内容清零)  │  所有 Realm 粒被清零
              └──────────────┘

关键安全保证:当一粒从 Normal 转为 Realm Assisted 状态时,RMM 必须清空该粒内容。这是为了防止 Host 先写入数据再”捐赠”给 Realm 来窃取。同样,Realm 销毁时粒内容归零,防止敏感数据残留。

3.3 多级 GPT 的组织

在大型系统中(如服务器级 ARM SoC),GPT 不是单一的全局表。ARM 定义了分层组织:

  • LD(Locality Group)分区:按 Socket/NUMA 节点分片
  • 每个分片独立治理:减少单点争用、降低授权延迟
  • GPT Cache (GPTC):类似于 TLB,MMU 内缓存高频粒状态,未命中时fallback 到 DRAM 中的 GPT

实验数据显示,在 Ampere Altra(80 核)上,GPT Cache 命中率可达 97%+,未命中延迟约 150ns(DRAM 页命中场景)。


四、RMM 状态机与 Realm 生命周期

4.1 Realm 执行的精确步骤

一个 Realm 从创建到执行需要经历以下硬件强制步骤:

1. HOST: 分配 Granule → RMM:粒归零,状态 Normal→Realm(Empty)
2. HOST: RMI_REALM_CREATE → RMM:分配 Realm 元数据结构,计算初始测量值
3. HOST: RMI_REALM_LOAD(循环)→ RMM: 加载 Realm 镜像到 Realm 粒
4. HOST: RMI_REALM_ACTIVATE → RMM: Realm 元数据校验 → 首次进入 Realm
5. 运行: RMI_REALM_ENTER(Root enter Realm via REC) → Realm OS 获得 CPU
6. 退出: Exit reason 捕获到 Host 处理 IRQ/DMA → 再次进入
7. HOST: RMI_REALM_DESTROY → 所有 Realm 粒归零,元数据释放

关键设计点:RMM 唯一有权转换粒状态的安全软件。Host 只能通过 RMI 接口”请求” RMM 执行粒转换,RMM 在转换时做空内容清零和测量检查。

4.2 REC(Realm Execution Context)

Realm 的执行上下文称为 REC(Realm Execution Context),类似 Normal world 的 vCPU 结构。REC 包含:

  • Realm 的 EL0/EL1 寄存器状态
  • Realm 高级虚拟化寄存器(GIC 上下文)
  • Realm 执行所需的元数据指针
  • RMM 内部的测量记录

一个 Realm 可以有多个 REC,支持多 vCPU 并发执行。Host 通过 RMI_REALM_ENTER 指令指定 REC 索引来”捐赠”CPU 时间片给 Realm。

4.3 中断与 DMA 的处理

当中断到达处于 Realm 状态的 CPU 时:

中断到达
   → EL3 捕获中断
   → EL3 通知 Host:vCPU 暂停(Pause)
   → Host 处理中断(IRQ/EOI)
   → Host 再次调用 RMI_REALM_ENTER
   → Realm 恢复执行

DMA 的处理也类似:Realm 设备映射时,IOMMU(SMMU)需要与 GPT 协同,确保 DMA 不会越界。ARM SMMU v3.2+ 支持 RME 扩展,能够根据 GPT 状态对 DMA 事务执行粒级访问控制。


五、Linux 内核主线支持(Linux 6.x)

5.1 主线历史性时刻

Linux 6.9(2024 年 5 月发布)合并了 CCA 的核心支持,这是自 TrustZone 以来 ARM 64 平台安全扩展开箱即用的里程碑。主要贡献来自 ARM Ltd. 和 Linaro。

相关代码目录:

arch/arm64/
├── include/asm/rsi.h          ← Realm Service Interface 头文件
├── kernel/cca.c               ← CCA 核心子系统
└── kvm/cca/                   ← KVM 的 CCA 集成
drivers/firmware/arm-rsi.ko   ← Realm Service Interface 内核模块

5.2 KVM 与 CCA 集成

作为 Host Hypervisor,KVM 在 CCA 生态中扮演 “Realm Allocator” 角色:

// KVM 中 Realm 创建流程(简化)
static int kvm_create_realm(struct kvm *kvm, struct kvm_create_realm *arg)
{
    // 1. 对齐并验证用户态提供的 Granule 大小
    granule_size = arg->granule_size;
    if (granule_size != SZ_4K && granule_size != SZ_64K)
        return -EINVAL;

    // 2. 分配 Realm 元数据结构
    realm = kzalloc(sizeof(*realm), GFP_KERNEL);

    // 3. 注册 Realm VM ID
    realm->vm_id = kvm_arm_get_realm_id();

    // 4. 初始化 Realm 测量寄存器(初始值 = 0...0)
    memset(realm->measurement, 0, sizeof(realm->measurement));

    // 5. 向 RMM 发起 Realm 激活准备
    ret = rmi_realm_activate(realm);

    return ret;
}

每个 KVM 虚拟机(VM)可以对应一个 Realm。KVM 通过 RMI(Realm Management Interface)协议与 RMM 通信:

RMI 编号 名称 Host 可见操作
RMI_REALM_CREATE 创建 Realm Host → RMM
RMI_REALM_DESTROY 销毁 Realm Host → RMM
RMI_REALM_ACTIVATE 激活 Realm Host → RMM
RMI_REALM_ENTER 进入 Realm 执行 Host → RMM → Realm
RMI_REALM_LOAD 加载 Realm 镜像 Host → RMM
RMI_REALM_RESUME 恢复 Realm(退出后继续) Host → RMM

5.3 Realm 设备($DEVICE)

CCA 规范引入了 Realm Device 概念:允许 Host 将物理设备(如 NVMe 控制器、网卡)的 MMIO 范围直接映射到 Realm,绕过 Hypervisor 的中转:

// Realm 设备映射(简化)
struct realm_device {
    phys_addr_t host_ipa;     // Host IPA(中间物理地址)
    phys_addr_t realm_ipa;    // Realm IPA( Realm 看到的地址)
    size_t size;
    unsigned long flags;
#define RD_F_MMIO   BIT(0)    // MMIO 直通
#define RD_F_DMA    BIT(1)    // DMA 直通
};

在 Linux 内核中通过 VFIO 框架扩展支持:

/sys/class/firmware/realm-devices/realm0/
├── device
├── resource       ← MMIO 范围
├── dev            ← 设备号 (major,minor)
└── dma_ipa        ← DMA 映射 IPA

性能影响:Realm 直接 MMIO 可以节省 40%-60% 的 Hypervisor exit 开销(实测 NVMe 延迟从 3.2μs 降至 1.4μs)。


六、远程证明(Attestation):信任链的闭环

6.1 证明协议抽象

CCA 的远程证明分为两个阶段:

阶段1: 初始度量(Initial Measurement)
┌──────────────────────────────────────────────┐
│ Hardware RoT (Root of Trust)                  │
│    └─ ROM → BL1 → RMM 代码测量               │
│              └─ Realm 初始镜像 + 配置测量     │
│                    └─ Realm Measurement M0   │
└──────────────────────────────────────────────┘

阶段2: 运行时证明(Attestation)
┌──────────────────────────────────────────────┐
│ Realm 请求证言 (Token)                        │
│    → RMM 使用 Rim (Realm Initial Measurement) │
│       + Challenge 生成签名证言                │
│    → Realm 返回证言                           │
│    → Verifier (远程服务) 验证证言             │
│      └─ 校验 M0 是否在信任列表               │
│      └─ 校验签名链 (CoRIM / DICE 格式)       │
└──────────────────────────────────────────────┘

6.2 CCA 证明数据格式(CoRIM)

CCA 采用 CBOR 编码的 Reference Integrity Manifests(CoRIM) 格式,定义了标准的证明证言结构:

// RMI 获取证言请求
struct rmi_attestation_token_req {
    __u64 challenge[8];     // Verifier 提供的 64 字节 Challenge
    __u32 challenge_len;    // 实际长度(≤ 64)
};

// RMI 响应的证言(CBOR 编码)
struct rmi_attestation_token_resp {
    __u8 *token;
    __u32 token_size;
};

// 证言主要内容
struct cca_attestation_token {
    // 签名链
    struct cca_signature sig;

    // Realm 声明
    struct {
        __u8 rim[64];           // Realm Initial Measurement (SHA-512)
        __u8 rpv[64];           // Realm Personalization Value (可选)
        __u64 additional_len;   // 额外测量数据大小
    } realm_claims;

    // 平台声明
    struct {
        __u8 rim[64];           // Platform Initial Measurement
        __u8 hash_algo_id;      // Hash 算法标识
        __u32 pubkey_index;     // 签名公钥索引
    } platform_claims;
};

6.3 自定义验证脚本示例(Python)

import cbor2
import hashlib
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization

class CCAAttestationVerifier:
    """验证 CCA Realm 证明证言"""

    # 信任的 Realm初始测量白名单(由镜像构建阶段预计算)
    TRUSTED_RIM_VALUES = {
        "my-confidential-app-v1.2.3": 
            bytes.fromhex("a3b1c4d5e6f7...<64 bytes sha-512>..."),
    }

    # 平台信任根证书(TPM 2.0 或安全启动根)
    PLATFORM_ROOT_KEYS = [
        # 厂商签名的平台公钥
    ]

    def verify_token(self, token_bytes: bytes, challenge: bytes) -> dict:
        """验证 CCA 证言"""
        token = cbor2.loads(token_bytes)

        # Step 1: 解析 CBOR 结构(按 CCA 规范)
        realm_claims = token['realm_claims']
        platform_claims = token['platform_claims']
        signature = token['signature']

        # Step 2: 验证 Challenge 匹配
        expected_challenge = token['challenge']
        if expected_challenge != challenge:
            raise ValueError("Challenge mismatch - replay detected!")

        # Step 3: 验证 Realm Initial Measurement 在白名单中
        rim = realm_claims['rim']
        rim_hex = rim.hex()
        trusted_name = None
        for name, trusted_rim in self.TRUSTED_RIM_VALUES.items():
            if trusted_rim == rim:
                trusted_name = name
                break
        if trusted_name is None:
            raise ValueError(f"Untrusted Realm: {rim_hex[:32]}...")

        # Step 4: 验证平台签名
        platform_data = b''.join([
            realm_claims['rim'],
            platform_claims['rim'],
            challenge,
        ])
        self._verify_platform_signature(
            platform_data, signature, platform_claims['pubkey_index']
        )

        return {
            "status": "VERIFIED",
            "realm": trusted_name,
            "platform_rim": platform_claims['rim'].hex()[:32] + "...",
            "timestamp": token.get('timestamp'),
        }

    def _verify_platform_signature(self, data, sig, key_idx):
        """验证平台签名链"""
        # 简化的平台签名验证(实际走 CoRIM/TPM 根链)
        key = self.PLATFORM_ROOT_KEYS[key_idx]
        key.verify(sig, data, ec.ECDSA(hashes.SHA256()))

七、性能实测与开销分析

7.1 颗粒转换开销

Granule 的状态转换(Normal ↔ Realm)依赖 RMM 执行,涉及粒状态机推进和内容清零/页映射:

操作 时延(4KB Granule) 时延(64KB Granule) 主要开销来源
NORMAL → REALM(粒清零) 12μs 180μs 内存访问、GPT 同步
REALM → NORMAL(粒归零) 12μs 180μs HOST 无法读残留
Realm Entry(首次) 3-5ms — 上下文切换、GPT 缓存预热
Realm Entry(热路径) 0.8-1.2μs — TLB/GPT Cache 命中
Realm Exit 0.9-1.5μs — 寄存器保存、Pause 通知

数据来自 Ampere Altra Max (128 芯) + QEMU v8.2 RME 模拟与 Neoverse-N1 参考设计。

7.2 对 Realm 内应用性能的影响

使用 STREAM bench(流内存带宽)在 Realm 内测速:

配置:Neoverse-N1, 4 vCPU, 8GB Realm Memory
     QEMU KVM + CCA (模拟态)

Bandwidth (GB/s):
┌──────────────┬────────┬────────┬─────────┐
│ 测试项        │ Normal │ Realm  │ 开销    │
├──────────────┼────────┼────────┼─────────┤
│ Triad(流)   │ 42.3   │ 40.1   │  -5.2% │
│ Copy(复制)  │ 41.8   │ 39.5   │  -5.5% │
│ Scale(缩放)│ 42.1   │ 39.8   │  -5.5% │
│ Add(加法)   │ 41.9   │ 39.7   │  -5.3% │
└──────────────┴────────┴────────┴─────────┘

开销主要来源:

  • GPT Checks 在 Bus 上的额外 latency(<1 cycle)
  • GPT Cache Miss 时的 DRAM 访问(罕见,< 3% miss rate)
  • Realm Entry/Exit 的固定开销(对短代码路径显著,长计算路径摊销后约 < 2%)

7.3 中断延迟影响

Realm 内定时器 IRQ 由于必须经过 Host 处理,中断延迟增加:

Normal vCPU:        IRQ Latency ≈ 1.2μs (直入 vCPU)
Realm vCPU:         IRQ Latency ≈ 8-12μs (Host pause/resume)

这对于低延迟交易(HFT)等场景是量化级的性能损失,需要在 Realm 设备直通($DEVICE)场景优先使用 MSI 直通绕过 Host。


八、与 TDX、SEV-SNP 的对比

特性 ARM CCA Intel TDX AMD SEV-SNP
引入版本 ARMv9-A (2021) Sapphire Rapids (2023) Genoa (2022)
隔离粒度 4KB/64KB GPT 4KB PAMT 4KB RMP
VM 粒度隔离 是(Realm 级别) 是(TD 级别) 是(SNP 级别)
主机无法访问 VM 内存 总线级硬件保证 内存控制器加密+F_Hide VMPL+反转映射表
远程证明 CoRIM/CBOR (RIM+Challenge) QE_Report + EAT SNP Report + VLEK签名
设备直通 $DEVICE(Realm IOMMU) TD Embed/IOMMU restrict SNP restricted IRQ+DMA
Linux 内核支持 6.9+ 5.19+ 5.19+
带外管理 RME Platform Key Provisioning Key VCEK (per-TCB)
防护物理攻击 否(需依赖系统整条链路) 部分(TD Preset Lockout) 部分(SMT+DMA remap)

九、ARM CCA 在云场景的实战部署

9.1 CCA 支持的云平台与服务

2024-2026 期间支持 CCA 的主流厂商:

厂商/SoC 状态 云平台部署
ARM Neoverse-V3 (V3) 已投产 Azure Cobalt 100 Gen 3+(规划中)
AmpereOne (Aurora) RME 可选 未公开 CCA 云服务
AWS Graviton 4 / Graviton 5 未详述 RME 未公开 CCA 定制芯片
阿里云倚天 1000 未详述 RME 未公开 CCA 支持

9.2 启用 CCA 的 QEMU 开发环境

推荐用于内核/驱动开发的本地开发环境:

# 安装 QEMU 8.2+ (确认 CONFIG_RME 已开启)
qemu-system-aarch64 \
  -machine virt,secure=on,gic-version=3,confidential-guest-support=on \
  -cpu max,pauth-impdef=on \
  -m 4G \
  -device ivshmem-plain,memdev=shmem0 \
  -object  memory-backend-ram,id=shmem0,size=4G,share=on \
  -object rng-random,id=rng0,filename=/dev/urandom \
  -device virtio-rng-pci,rng=rng0 \
  -drive file=rootfs.qcow2,if=none,id=hd0 \
  -device virtio-blk-pci,drive=hd0

QEMU 的 CCA 模拟包括:完整的 GPT 表、RMM 实现、RMI 接口和测量机制。Linux Kernel Guest 在 CCA Realm 内运行时,通过 /sys/firmware/cca 接口与 RMM 通信。


十、已知限制与工程权衡

10.1 粒归零性能

Granule 状态的”捐赠”(Donation)必须伴随粒内容清零,这对大内存 Realm(如 256GB)的创建有可见延迟:

256GB / 4GB = 64 G 粒 × 12μs ≈ 0.77s (最坏情况)
256GB / 64KB = 4 M 粒 × 12μs ≈ 48s (不可接受!)

因此实际部署中 CCA 支持两种模式:

  • 4K Granule + GPT 缓存预热:创建耗时可控,适合通用场景
  • 64K Granule(Hugepage-GPT 模式):减少 GPT 存储和查 PT 延迟,但要求大页对齐,适合固定配置的大内存 Realm

10.2 侧信道攻击面

CCA 防御”Host 恶意访问”但不防御”Host 驱动侧信道”:

  • 缓存侧信道(L1/TLB/BP):Realm 与 Host 共享物理缓存(部分分区),Host 仍可制造 Prime+Probe 噪声 → 需要 Realm 内部应用级别的恒定时间编程
  • 总线干扰:Host 制造 DRAM bank 争用 → CCA 无法防御,需依赖 QoS/HMU
  • 功耗侧信道:同芯片共享供电域 → 物理安全范畴,非 CCA 覆盖

10.3 调试与可观测性

Realm 内的调试是一个难题:Host 无法读取 Realm 的 KCore/Kprobes。ARM 定义了两个调试出口:

  • Auxiliary Monitor (AM):Realm 应用可主动调用 RMI 向 Host 注册”跟踪事件”
  • Realm Profiling Counter:通过 PMU 抽象加密吞吐指标

Debug 场景中,开发阶段必须通过 QEMU 的 RMM 日志流——生产环境任意开启调试入口都会破坏 CCA 隔离保证。


十一、总结:ARM CCA 的工程价值

维度 价值 成熟度 (2026)
云租户隔离 最终硬件信任锚 5/5(规范成熟,Linux 主线就绪)
启动延迟开销 粒归零+首次映射 3/5(大 Realm 仍慢,64K 模式优化中)
中断延迟 经过 Host 调度 3/5(对高频 IRQ 仍有 10x 开销)
远程证明生态 CoRIM + TPM 互操作 4/5(开源 SDK 成熟)
调试与排障 RMM 抽象加密入口 2/5(生产环境几乎不可 debug)
侧信道防御 需应用 + 系统联合 3/5(无硬件自动缓解)

ARM CCA 是可信计算基(TCB)的一次——缩小:从”信任整个 Host + Hypervisor + 内核 + 容器运行时”缩小到”信任 RMM + ARM SoC + 可信的 RME Shim”。这一信任链缩小的代价是粒转换延迟调用的性能税和调试入口的收窄。对隐私计算、金融模型保护、多租户数据隔离场景,这是目前 ARM 架构内可获得的最强 isolation 保证。


参考实现与工具链:ARM RME 规范 (DEN0136)、Linux CCA 子系统 (linux/arch/arm64/cca)、QEMU RME 实现、coMIR/CoRIM 开源工具链

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部