┌─────────────┐       信令平面        ┌─────────────┐
│  发送端 A   │◄─────────────────────►│  信令服务器 │
│ (Encoder)   │   Key Exchange /      │  (Key Mgmt) │
└──────┬──────┘   Rotation Signal     └──────┬──────┘
       │                                     │
       │         媒体平面 (RTP/SFrame)        │
       ▼                                     ▼
┌─────────────────────────────────────────────────────┐
│                    SFU 集群                          │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐              │
│  │ Worker1 │  │ Worker2 │  │ WorkerN │  (仅转发)    │
│  └────┬────┘  └────┬────┘  └────┬────┘              │
└───────┼────────────┼────────────┼───────────────────┘
        │            │            │
        ▼            ▼            ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│  接收端 B   │ │  接收端 C   │ │  接收端 D   │
│ (Decoder)   │ │ (Decoder)   │ │ (Decoder)   │
└─────────────┘ └─────────────┘ └─────────────┘

Master Key (MK) ──HKDF──► Epoch Key (EK) ──HKDF──► Frame Key (FK)
   │                         │                      │
   │  会话级，定期轮换        │  纪元级，按时间/成员变动轮换  │  帧级，每帧派生
   ▼                         ▼                      ▼
  32 字节                   32 字节                 16 字节 (AES-GCM)

Bit 分配 (共 62 位可用空间):
┌────────────┬────────────┬────────────────────┐
│ Epoch (16) │ Layer (6)  │ Participant ID (40)│
└────────────┴────────────┴────────────────────┘

// 1. 创建 PeerConnection 并启用 Insertable Streams
const pc = new RTCPeerConnection({
  encodedInsertableStreams: true
});

// 2. 获取视频轨道的可读/可写流
const sender = pc.getSenders().find(s => s.track.kind === 'video');
const { readable, writable } = sender.createEncodedStreams();

// 3. 构建 SFrame 变换器
const transformer = new SFrameTransform({
  getKey: (keyId) => keyStore.getFrameKey(keyId),
  keyIdGenerator: (layerId) => encodeKeyId(currentEpoch, layerId, localParticipantId)
});

// 4. 管道连接：Encoder → SFrame 加密 → 网络发送
readable.pipeThrough(transformer).pipeTo(writable);

// Go 伪代码：SFU Worker 转发逻辑
func (w *Worker) handlePLI(pli *rtcp.PictureLossIndication) {
    // 1. 向源端转发 PLI，触发关键帧生成
    w.forwardToSource(pli)
    
    // 2. 同步通知所有下游：预期将收到新 Key ID 的关键帧
    w.broadcastKeyFrameExpected(pli.SenderSSRC, pli.MediaSSRC)
}

const receiver = pc.getReceivers().find(r => r.track.kind === 'video');
const { readable, writable } = receiver.createEncodedStreams();

const decryptor = new SFrameTransform({
  getKey: (keyId) => keyStore.getFrameKey(keyId),
  // 解密模式：验证完整性 + 解密载荷
  mode: 'decrypt'
});

readable.pipeThrough(decryptor).pipeTo(writable);

时序图：
Client A          信令服务器          Client B/C/D
   │                  │                  │
   ├─ 新 Epoch Key ──►│                  │
   │                  ├─ 新 Epoch Key ──►│
   │                  │                  │
   ▼                  ▼                  ▼
本地派生新 FK      更新分发表         缓存新 FK
   │                  │                  │
   ├─ 带新 Key ID 的关键帧 ──────────────►│
   │                  │                  │
   ▼                  ▼                  ▼
完成平滑切换，旧 Key 标记过期

// 统一信令信封
interface SignalEnvelope<T> {
  jsonrpc: "2.0";
  method: string;           // 方法名
  params: T;                // 业务载荷
  id?: string | number;     // 请求 ID，通知类可省略
  room_id: string;          // 房间维度隔离
  sender_id: string;        // 发送方身份（服务端下发时为 "server"）
  timestamp: number;        // 服务端单调递增时间戳，用于去重与排序
}

// 1. 会话建立阶段：分发 Master Key
interface MasterKeyDistributeParams {
  epoch: number;                    // 当前纪元号
  master_key_b64: string;           // Base64(Master Key)，仅此次下发
  key_derivation_algo: "HKDF-SHA256"; // 固定算法标识
  cipher_suite: "AES_GCM_128";      // SFrame 密码套件
  key_lifetime_sec: number;         // 建议轮换周期（如 86400）
  participants: ParticipantInfo[];  // 当前成员列表，含 participant_id 与权限位掩码
}

// 2. 纪元轮换通知（服务端主动推送）
interface EpochRotateParams {
  new_epoch: number;
  new_master_key_b64: string;
  grace_period_sec: number;         // 双纪元并存宽限期，建议 30~60s
  revoked_participants?: string[];  // 本次轮换中被剔除的成员 ID
}

// 3. 客户端主动请求密钥刷新（检测到解密持续失败时）
interface KeyRefreshRequestParams {
  current_epoch: number;
  failed_key_ids: number[];         // 连续失败的 Key ID 样本
  reason: "DECRYPT_FAILURE" | "EPOCH_MISMATCH" | "FORWARD_SECRECY";
}

// 4. 关键帧同步提示（SFU/发送端协同）
interface KeyFrameSyncParams {
  target_participant_id: string;    // 需要关键帧的下游
  expected_key_id: number;          // 期望携带的 Key ID
  layer_hint?: number;              // 建议层级，配合 Simulcast
}

┌──────────────┐     1. 加入房间（不可见）      ┌──────────────────┐
│  发送端 A    │──────────────────────────────►│                  │
│  (加密)      │                               │  可信录制/转推代理 │
└──────────────┘                               │  (Trusted Proxy)  │
        │                                      │                  │
        │ 2. SFrame 加密 RTP                   │  - 持有 Master Key │
        ▼                                      │  - 运行于 TEE/隔离环境│
┌──────────────┐                               │  - 输出明文/再加密流 │
│    SFU       │──────────────────────────────►│                  │
│  (盲转发)    │     3. 转发加密包              └────────┬─────────┘
└──────────────┘                                       │
        │                                              │ 4. 明文/标准 SRTP
        ▼                                              ▼
┌──────────────┐                               ┌──────────────────┐
│  接收端 B    │                               │  下游业务系统     │
│  (解密)      │                               │  - 录制存储       │
└──────────────┘                               │  - CDN 转推       │
                                               │  - ASR/NLP 服务   │
                                               └──────────────────┘

# pytest 示例：验证跨平台密钥派生一致性
def test_key_derivation_interop():
    # 输入：Master Key, Epoch, Participant ID, Layer
    vectors = load_rfc_vectors("sframe_test_vectors.json")
    for v in vectors:
        ek = hkdf_sha256(v.master_key, f"epoch{v.epoch}".encode(), 32)
        fk = hkdf_sha256(ek, v.participant_id.to_bytes(5, 'big') + bytes([v.layer]), 16)
        assert fk == v.expected_frame_key
        # 验证加密往返
        ct = sframe_encrypt(fk, v.key_id, v.plaintext, v.aad)
        pt = sframe_decrypt(fk, v.key_id, ct, v.aad)
        assert pt == v.plaintext

# .github/workflows/e2e-sframe.yml
jobs:
  sframe-e2e:
    runs-on: ubuntu-latest
    services:
      sfu: { image: my-sfu:latest }
      signaling: { image: my-signal:latest }
    steps:
      - uses: actions/checkout@v4
      - name: Launch 3-browser topology
        run: |
          node test/launch_topology.js 
            --sender=1 --receivers=2 --proxy=1 
            --duration=60 --simulcast --sframe
      - name: Verify decryption success rate
        run: |
          node test/verify_metrics.js 
            --expect-decrypt-ok-rate=1.0 
            --expect-key-rotation-latency-ms<500
      - name: Inject network chaos
        run: |
          tc qdisc add dev eth0 root netem loss 5% delay 100ms
          sleep 30
          node test/verify_recovery.js

# 1. 解密健康度（核心 SLI）
sframe_decrypt_success_total{room=~".*"} 
/ 
sframe_decrypt_attempt_total{room=~".*"} 
> 0.9999

# 2. 密钥同步延迟（从服务端下发到客户端 ACK）
histogram_quantile(0.99, 
  rate(sframe_key_sync_latency_seconds_bucket[5m])
) < 0.5

# 3. 双纪元共存比例（过高说明轮换卡顿）
sum(sframe_active_epochs_per_room{epoch_count>2}) 
/ 
sum(sframe_active_rooms) 
< 0.01

# 4. 信令通道背压
rate(signal_channel_send_queue_depth[1m]) > 1000
→ 告警：信令服务器扩容或客户端处理过慢

# 5. 旁路代理解密吞吐
rate(sframe_proxy_decrypt_bytes_total[5m]) 
/ 
sframe_proxy_decrypt_capacity_bytes 
< 0.7

# Alertmanager 路由规则示例
- match:
    alertname: SFrameDecryptFailureStorm
    severity: critical
  receiver: "pagerduty-oncall"
  continue: true
- match:
    alertname: SFrameKeySyncStuck
  receiver: "auto-remediation-webhook"
  # 触发自愈：强制下发全量 Key Sync + 触发全员 KeyFrame Request