Files
ssw-mpc/docs/COMPARE_SECRETFLOW.md
T
rong c00ec0d0a5 docs: 补上 IR 一层、n 方能力矩阵与轮数口径
影响:文档不再手抄「几次 matmul_trunc」,轮数一律引用 `nax plan` / `nax sql-plan`
的实测输出,读文档的人能自己复现。

- 新增 `docs/IR.md`:算子往返表(mul/matmul=2、trunc/open=1、整数 scale=0)、
  定点尺度为什么挂在值上、阶段与轮数公式、两个消费者(nax-ml / nax-sql)的实测数字
- 新增 `docs/N_PARTY.md`:能力矩阵(每条结论都指得到测试名)、PSI 环协议代价、
  安全边界(`strict` 挡不住什么写清楚)
- `docs/ARCHITECTURE.md`:分层图补 `nax-ir` / `nax-ml` / `nax-sql`
- `docs/COMPARE_SECRETFLOW.md` §2.3 加修正块:原来说「nax 的 IR 就是 nax-sql 的
  AST」—— 前半句对(拒绝 XLA + Bazel + MLIR 那一套),后半句错:AST 回答不了
  「几个往返」,中间要过一层「谓词/聚合 → 协议动作」的降级
- `README.md` / `CLAUDE.md`:用例数 423 → 450、crate 分层与关键设计决策同步

修正一处过期数据:文档里「14 个算子 / 7 轮、`lr=2` 时 5 轮」是早期 demo 图
(线性梯度步、不含 sigmoid 多项式)的数,不是 `nax plan` 的输出。迁移之后
`cmd_plan` 直连 `VerticalLR::build_epoch`,实测是 33 算子 / 17 轮;degree 3/5/9
对应 11/13/19 轮,`--l2` 恰好 +1 轮。
2026-11-01 19:01:27 +08:00

437 lines
27 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# nax-rs 与 SecretFlow / Kuscia / SPU 的对照
> 目的:看清「成熟隐私计算平台」把复杂度花在哪,判断 nax 哪些缺口是**产品化阻塞**、
> 哪些只是**别人的解法**、哪些**我们不该学**。
>
> 材料来源:内网 Gitea 服务端镜像(未落本地磁盘),secretflow 组织下 **5 个仓全部可用**:
>
> | 仓 | HEAD | 体积 | 语言 | 是什么 |
> |---|---|---|---|---|
> | `secretflow/secretflow` | `11425fa5` | 480 MB | Python 96% | 主框架:device / data / ml / security / ic |
> | `secretflow/spu` | `826537d9` | 24.5 MB | C++ 82% | 密态计算引擎:compiler + device + kernel + mpc |
> | `secretflow/kuscia` | `c04279ae` | 52.2 MB | Go 85% | 编排:18 个 CRD + DataMesh |
> | `secretflow/secretpad` | `8fb060e1` | 146.7 MB | Java 92% | Web 平台:建节点 / 注册数据 / 建项目 / 建授权 |
> | `secretflow/spec` | `cf2b6c4` | 0.6 MB | Python + proto | 规范:DATA / COMPONENT / EVALUATION / REPORT |
>
> 上游还有三个**没有镜像**但对 nax 直接相关**的仓:`secretflow/scql`(密态 SQL,对标 `nax-sql`)、
> `secretflow/yacl`(C++ 密码学原语库,SPU 的地基)、`secretflow/heu`(同态加密库,对标 `nax-he`)。
> 缺口分析里凡涉及这三块,本文只按 spec/SPU 的间接材料推断,未读其源码。
---
## 0. 一句话结论
**SecretFlow 把复杂度花在「让算法不碰密码学」上,nax 把复杂度花在「让密码学能进 TEE」上。**
两边的缺口不重叠:
| | SecretFlow 栈 | nax-rs |
|---|---|---|
| 加一个新算法 | 写组件描述 + 打成镜像,平台不认识代码 | 写 Rust,调 `nax-vault` 算子,重编译 |
| 换一个 MPC 协议 | 改一行 `protocol=cheetah` | 不支持,算子核只有一种表示 |
| 跨域怎么连 | 声明 `DomainRoute`,自动 mTLS + 端口复用 | 手填 `--connect 127.0.0.1:9551`,明文 TCP |
| 数据从哪来 | 注册 `DomainData`,DataMesh over Arrow Flight 流式 | `--data` 手输 / CSV / PG 查完进内存 |
| 算法在哪跑 | K3s Pod,带资源与带宽限额 | 单二进制进程,可编进 TEE/TA |
所以**真正的 gap 不在密码学,在「信任边界之外的那一圈」**:认证、授权登记、
作业状态机、组件契约。这四样缺一样,演示都过不了安全评审。
---
## 1. 两边各分几层
### SecretFlow 四件套
```
secretflow(Python 算法层)
device/ ← PYU(明文) / SPU(MPC) / HEU(同态) / TEEU(TEE) 四种设备,同一个抽象
data/ ← Horizontal / Vertical / Mixed DataFrame 与 Ndarray(像 pandas)
ml/ security/ preprocessing/ stats/ tune/
↕ NodeEvalParam / NodeEvalResult ← spec 定义的求值接口
SPU(C++ 密态计算引擎)
compiler: XLA IR → pphlo(MPC IR)
device : Runtime(infeed/outfeed + 符号表 + IR 执行器)
kernel : hlo(高层算子) / hal(定点等与密码学无关的核心逻辑)
mpc : 协议接口 api.h + aby3 / cheetah / semi2k / ref2k
↕ Arrow Flight(DoGet/DoPut,RecordBatch 流)
Kuscia(Go,K3s 之上的编排)
18 个 CRD:Domain / DomainRoute / DomainData / DomainDataSource /
DomainDataGrant / DomainAppImage / AppImage / KusciaJob /
KusciaTask / TaskResource / Gateway / InteropConfig …
spec(protobuf):DATA / COMPONENT / EVALUATION / REPORT
SecretPad(Java + Vue):Web 层,建节点 / 注册数据 / 建项目 / 建授权
```
### nax-rs 18 个 crate
```
nax-cli 子命令入口(单二进制)
nax-node 一方一进程,连接 + 会话
nax-vault 协议编排:Beaver 乘 / truncate / open / compare
nax-core 算子核:u64 环算术、分享、PRG、SHA-256(no_std)
nax-sql / nax-ml / nax-fl 受限 SQL、纵向 LR、横向 FedAvg+DP
nax-psi / nax-he / nax-zkp PSI、Paillier-OLE、ZKP
nax-data CSV + PostgreSQL(本轮新加)
nax-ir 算子图 + 可见性 + 轮次规划(编译期,不碰密码学)
nax-proto / nax-orch 手写帧、PLAN/RESULT/BYE 行协议
nax-policy / nax-tee / nax-runtime / nax-ray
```
**结构差异一句话**:SecretFlow 的算法**不知道自己在明文还是密文域**
(`x.to(spu)` 就换设备,同一份代码),nax 的算法**自己判断**
(`if is_dry_run() { …明文… } else { …MPC… }`,两条路径写在同一个函数里)。
这是最大的一个 gap,见 2.0。
---
## 2. 逐层对照(带证据)
### 2.0 设备抽象(读完主仓之后,这条要排在第一位)
SecretFlow 把「算在哪」做成了一等公民,接口只有三个东西
(`secretflow/device/device/base.py`):
```python
class Device(ABC):
def __call__(self, fn, **kwargs): ... # 把函数调度到本设备
class DeviceObject(ABC):
device: Device
def to(self, device, *a, **kw): # 跨设备搬运,dispatch 到 to_<type>
return dispatch(f"to_{device.device_type.name}", self, device, *a, **kw)
```
`register_to(from, to)` 注册跨设备转换内核,所以 M 种设备只需 M² 条转换;
已有的四种设备是 **PYU(明文)/ SPU(MPC)/ HEU(同态)/ TEEU(TEE)**。
于是算法长这样,**它不知道自己在明文还是密文域**:
```python
x = x.to(spu) # 换成密文
y = ops.add(x, y) # 同一行代码
```
nax 的对应物是 `nax-runtime`(`crates/nax-runtime/src/mode.rs`):
一个线程局部的 `bool` 开关 + `dry_run()` RAII guard,算法里靠
`if is_dry_run() { … } else { … }` 自己分叉。
| | SecretFlow | nax |
|---|---|---|
| 抽象单位 | Device + DeviceObject | 全局布尔开关 |
| 换域怎么写 | `x.to(spu)` | 算法里 `if` 分支两套代码 |
| 新增一种域 | 加一个 Device + 注册转换 | 改所有算法 |
| 组合(同态 + MPC 混用) | 对象来回 `to()` | 表达不了 |
**这是最大的一条 gap,也是最便宜的一条。** nax 不需要 Python 但完全可以在 Rust 里
定义 `trait Device { fn eval(&self, op, args) -> … }`:`nax-runtime` 的
「试跑 = 明文快路」其实就是隐式的 PYU,把它显式化成 device 就完成了对齐。
### 2.1 数据契约
| | SecretFlow | nax |
|---|---|---|
| 表描述 | `TableSchema` / `VerticalTable`(**列级记录归属方**)/ `IndividualTable`(横向) | `Frame`:列名 + `Vec<f64>`,没有类型、没有归属 |
| 归属怎么表达 | 结构里 `VerticalTable.parties` 指定 | CLI 参数 `--schema balance,spend` 按位置对齐 |
| 引用方式 | `DistData` + `DataRef`(位置 + 偏移 + 长度) | 无,整表进内存 |
| 空值 | Arrow 的 null | `NaN`(`pg::ResultSet::to_frame` 里映射) |
> 证据:`secretflow/spec` `docs/spec.md` 的 DATA 段;nax `crates/nax-data/src/frame.rs`。
**差距实质**:nax 的列级归属是「靠两方命令行参数写对」保证的。写错不报错,
只会把结果算错(本轮就踩过——两方 `--pred` 不一致,报的是「open 长度不一致」)。
`VerticalTable` 把这件事变成**结构约束**,这是值得抄的一个点,且不需要引 protobuf。
### 2.2 数据接入(这一圈差距最大)
| | SecretFlow / Kuscia | nax |
|---|---|---|
| 支持的数据源 | localfs / OSS / MySQL / PostgreSQL + `external` 外部插件 | CSV / PostgreSQL |
| 传输方式 | **Arrow Flight**,`GetFlightInfo` 发 ticket → `DoGet` 拉 RecordBatch 流 | 查完 `to_frame()` 全量进内存 |
| 扩展方式 | 实现三方法接口即可接新源 | 改 `nax-data` 源码 |
| 空值/类型 | Arrow schema 从 DomainData 的 columns 生成 | 非数值列直接丢弃 |
> 证据:`kuscia/pkg/datamesh/dataserver/io/builtin/builtin.go`
> `IOServer.ioChannels` 按 `DataSourceType` 分派四种 channel;
> `dataio.go` 的 `DataMeshDataIOInterface` 只有三个方法:
> `Read(ctx, reqCtx, RecordWriter)` / `Write(ctx, reqCtx, *flight.Reader)` / `GetEndpointURI()`。
这是 **nax 最该学的抽象**:把「数据源」收敛成一个三方法接口,中间表示是**批量流**
而不是「一张表」。nax 现在的 `pg_source::load()` 是全量加载,百万行就顶不住;
而 Kuscia 用 1C2G 能跑百万行 PSI,靠的就是流式 + 分批。
### 2.3 算子与协议抽象(SPU 的核心,也是最不该照搬的)
SPU 在 `src/libspu/mpc/api.h` 里定义了协议必须实现的统一接口,关键设计有三条:
1. **类型三态**:`p`(公开)/ `s`(秘密)/ `v`(私有,归某一方)。
每个算子按输入组合出重载:`equal_pp` / `equal_sp` / `equal_ss`。
2. **`OptionalAPI<T>`**:协议可以声明「这个组合我不实现」,框架运行时降级——
所以 `ref2k`(明文参考实现)能只实现最少几个算子就跑起来。
3. **`import_s` / `export_s` + `common_type_s` / `cast_type_s`**:
秘密值的存储格式(AShare / BShare)不唯一,跨协议要显式转换。
这两组函数是「同一份程序换协议后端」的关键。
配套的分层(`REPO_LAYOUT.md`):`compiler`(XLA IR → pphlo)、`device`(Runtime)、
`kernel/hlo`(高层算子)、`kernel/hal`(定点等与密码学无关的逻辑)、`mpc`(协议实现)。
| nax 现状 | 影响 |
|---|---|
| `nax-core` 只有一种分片表示,算子签名固定 | 无法换协议后端:2PC 高性能(Cheetah 类)与 3PC 容错(ABY3 类)不能共存 |
| 没有「公开/私有/秘密」三态的类型系统 | 公开值在分片重建里出现两次这类 bug 只能靠人眼(已栽两次) |
| 没有 IR | 算法写死成 Rust 调用,无法做算子融合/常数折叠等图优化 |
> **修正(2026-11-01,`nax-ir` 落地之后)**:上表后两行已过时一半,而且本文
> §3.3「不该补」里那句「nax 的 IR 就是 `nax-sql` 的 AST」是错的。
>
> AST 是**语法树**,它回答「用户要算什么」,回答不了「这次要几个往返」——
> 后者需要把可达性(谁依赖谁)和代价(哪个算子过网络、几轮)都放到同一张图上。
> 这就是 `crates/nax-ir`(~600 行,零新增外部依赖):
>
> * **三态标注落成 `Vis { Public, Secret }`**,挂在**值**上而不是环境上。
> 公开值进入密态表达式时**强制插一个显式 `Lift` 节点**(只有 0 号携带明文),
> 于是「公开值出现 n 次」从"靠 review"变成"图里看得见";
> * **轮次规划**:每个算子标了真实往返数(`mul`/`matmul` 2 轮、`trunc`/`open` 1 轮、
> 整数系数的 `scale` 0 轮),按 `base = max(end(前驱))` 分阶段,同阶段的 `open`
> 合成一次往返;
> * **不改协议、不改 `nax-core`**:执行仍走 `nax-vault`,`no_std` 守线不受影响。
>
> 数据点(`nax plan`,`nax-ml` 迁移之后):纵向 LR 的**一整次迭代**在图里是
> 33 个算子,其中 **23 个纯本地**(含 `transpose`、偏置列的两次 `lift`),
> **17 轮**;`--sigmoid-degree` 3/5/7/9 分别是 11/13/17/19 轮,`--l2` 恰好 +1 轮。
> 早前这里记的是「14 个算子 / 9 个本地 / 7 轮,`lr=2` 时 5 轮」—— 那是最小
> demo 图(线性梯度步、不含 sigmoid 多项式)的数,不是 `nax plan` 的输出。
> 整数系数 `scale` 零往返(`Op::ScaleInt`)这条结论仍然成立,只是真迭代的步长
> 是 `lr/n`,碰不到整数那条分支。见 `docs/IR.md` §3 / §4。
>
> **§3.3 的拒绝仍然成立**:拒绝的是 XLA + Bazel + MLIR 那一整套(1156 个文件、
> 47.9% C++),它确实与「单二进制 / no_std / 能进 TA」互斥。落地的是
> 「三态标注 + 一个线性调度器」,不是把 XLA 搬进来。
>
> **追加(2026-11-02,`nax-sql::secure` 迁移之后)**:「AST 回答不了几个往返」
> 这句话现在有了直接的例子。`nax-sql` 的密态路径迁移前后都**没有**把 SQL AST
> 接到 IR 上 —— 接的是 `secure.rs` 里那份手写的**协议调用序列**:掩码 WHERE
> 展开成 `bit_lt`/`bit_eq` 的位运算,聚合展开成「掩码后列 + 归约 + open」。
> 图是从这套协议序列建出来的(`crates/nax-sql/src/secure_graph.rs`),
> 所以 `nax sql-plan --rows 6 --where "0<400" --aggs count,sum,avg,min,max`
> 能在**没有数据、不联网**的情况下报出 115 轮(掩码段 11 + 聚合段 104)。
>
> 反过来说也清楚:真要把 AST 接进来,中间还必须经过一层「谓词/聚合 → 协议动作」
> 的降级,而那一层才是回答「几轮」的地方。AST 本身只回答「用户要算什么」。
**但不要照搬。** XLA + Bazel + 1156 个文件 + 47.9% C++ 的编译栈,
和「单二进制 / no_std / 能进 TA」是互斥的。nax 的 `nax-sql` 受限 DSL 才是
对的那条路(SCQL 本身就是「用 SQL 当 IR」)。**要抄的是三态类型标注,不是编译器。**
### 2.4 编排
| | Kuscia | nax |
|---|---|---|
| 形态 | CRD 声明式 + controller reconcile(KusciaJob → 拆 KusciaTask → Pod) | `nax-orch` 行协议:`HELLO` 上报、`PLAN` 下发 peers、`RESULT` 回收、`BYE` |
| 任务图 | `kusciajobs.spec.tasks[].dependencies`,**DAG**,依赖全 Succeeded 才调度 | 单一 plan,无依赖关系 |
| 资源约束 | `parties[].resources`(K8s ResourceRequirements)+ `bandwidthLimits`(到指定域的 KiB/s 上限) | 无 |
| 状态 | `KusciaJobSummary` / `TaskSummary` / conditions / phase | 无持久化,进程退出即丢 |
| 幂等/重试 | controller 循环 | 无 |
> 证据:`kuscia/crds/v1alpha1/kuscia.secretflow_kusciajobs.yaml`(`dependencies`、`parties`、
> `bandwidthLimits`);nax `crates/nax-orch/src/lib.rs`。
**判断**:nax 的 orch 是 660 行的服务发现,够跑 demo,不够跑运维。
但也不需要 K8s——需要的是**把 plan 变成有状态、可查询、可重放的作业对象**。
### 2.5 跨域通信(这里是安全缺口,不是功能缺口)
Kuscia 用 CRD 把「怎么连」声明化,`domainroutes` 的 spec 里有:
- `authenticationType` —— 目的域如何认证来源
- `endpoint.host` / `endpoint.ports[].isTLS` —— 端口与是否 TLS
- `bodyEncryption.algorithm`:**`AES` / `SM4` 二选一**(国密要能选)
- `sourceClientCert` / `destinationPublicKey` —— 双方自签 CA 互发证书,走 mTLS
- 注释里写明「requests from source to destination need to be transferred through…」
—— 支持经中转,因此**多个任务并发只需一个公网端口**(端口复用)
nax 现状:`nax-proto::Op::Hello` 只带一个 `site` 字符串,
`--connect 127.0.0.1:9551` 手填,会话密钥 `--seed` 双方命令行传同一个值。
**这是本轮对比里唯一一条「必须马上补」的**:
- 没有认证 = 任何人都能连上来充当一方,并拿到 `open` 出的中间量;
- seed 走 argv = 进程列表可见,共享密钥等于没有密钥。
### 2.6 授权与出域
| | Kuscia / SecretFlow | nax |
|---|---|---|
| 数据授权 | `DomainDataGrant`(把某 DomainData 授给某域/某任务) | 无登记制 |
| 列级约束 | CCL(在 SCQL 引擎配置里) | 有:`nax-sql` 的 CCL 投影约束 |
| 出域守卫 | 两条路:K8s `networkPolicy`(弱)+ **TEEU 的密钥级管控(强,见下)** | `nax-policy::Guard`,按数据标签放行「执行/传输/取回」+ 审计 |
| 信任根 | 无硬件信任根(TEEU 依赖单点 TEE + auth server) | `nax-tee` 的 `TrustPlan` 四级 + enclave 内判定并签名 |
#### TEEU 那条路值得单独说(`secretflow/device/device/teeu.py`)
它是「**策略不是检查代码,而是控制密钥**」,四个要素:
```python
@dataclass
class TEEUData:
data: Any # 明文,或 AES256-GCM 密文
data_uuid: str # 给 authority manager 的凭据
nonce: bytes # AES-GCM nonce
aad: bytes # AES-GCM 关联数据
```
进 TEE 时不是先跑策略再跑代码,而是**先拿密钥**:
```python
func_bytes = code_position_independent_dumps(func, protocol=4) # 代码的字节
data_keys = self.auth_frame.get_data_keys(func_bytes, data_uuid_list=[…])
aesgcm = AESGCM(data_keys[idx]); new_value = aesgcm.decrypt(nonce, data, aad)
```
申请密钥的参数是 `(func_bytes, data_uuid)` —— **「哪一段代码」×「哪一份数据」**。
授权服务不认就不给密钥,数据在 TEE 里也只是一堆解不开的字节。
这比「运行时 `if` 检查放行」硬一个量级:绕过检查的收益是零,因为拿不到密钥。
**这对 nax 的启示(直接改 G3 的形态)**:
- 现在 `nax-policy::Guard` 是运行时判定 + 签名审计,属于「事后可查、事前可绕」;
- 改成:**分片落盘加密(每方自己的分片用独立密钥),密钥由授权服务按
`(算法哈希, 数据 id, 用途, 有效期)` 发放**;
- 授权服务本身放在 enclave 里(`nax-tee` 已有 attest / sign / device_key),
于是「谁批的、批给哪段代码」天然带硬件签名,比 TEEU 的 auth server 更可信。
这条改动同时解决两件事:G3(授权登记)落地成「密钥发放清单」;
「代码被换掉」这件事也被覆盖(代码哈希进密钥申请)。
### 2.7 组件与交付
| | Kuscia | nax |
|---|---|---|
| 算法形态 | `AppImage`:镜像 `name/tag` + **`ID`(sha256,启动前校验本地镜像是否被换)** + `sign` + `configTemplates`(Go template 渲染任务配置)+ `DeployTemplates`(Pod 模板、replicas、role、网络策略) | `nax-cli` 子命令,编译进二进制 |
| 契约 | `ComponentDef` + `IoDef` + `AttributeDef`(类型/枚举/联合,自描述) | 无,靠 `--help` |
| 结果呈现 | `REPORT`:`Report` / `Tab` / `Table` / `Div` | CLI `println!` |
| 互操作 | `pkg/interconn/bfia`(信通院 BFIA 标准适配器)+ `InteropConfig` CRD | 无 |
**判断**:`AppImage.ID` 那条注释值得单独记下来——
「如果 ID 非空,域在启动容器前会校验本地镜像 ID 是否匹配」。
这是**供应链完整性**的最小实现,nax 的单二进制可以用同一个思路:
发布时给出 `sha256` + 签名,节点启动时自检。
---
## 3. 缺口清单(按「该不该补」分档)
### 3.1 阻塞产品化(补,且优先)
> **进展(2026-10-31)**:G0(设备抽象)、G1(传输认证)、G2(参数对表)、
> G4(作业 DAG + 落盘状态)、G7(报告结构 + 产物指纹)**已完成**;
> G5(数据接入分批流接口)CSV 与 PG 两条都已接(PG 客户端的三层验证见 `docs/PG.md`)。
> G7 的结果比原设想更接近 spec 的 `REPORT`:`--report json` 出 `kind:"table"` +
> `header/rows`,就是 `spec` 里 `Table` 的最小等价物(没有 `Div` 那种排版嵌套,
> 因为 nax 的消费方是看板和 `jq`,不是 notebook)。
>
> G0 的落法与 SecretFlow 不同,这是**有意**的:SecretFlow 的 `Device.eval(op)` 是
> 算子分发,前提是它有四个设备、且算法层用 Python 动态类型写成;nax 只有明文/密态
> 两个域,而线性算子在两域本来就是同一行代码(分片对加法同态),非线性算子在密态域
> 必须换协议而不是换指针。所以落地的是「域边界 + 非线性算子显式拒绝」,
> 不是 trait 分发。详见 `docs/OPT_PLAN.md` §O3 实施。
> 执行记录见 `docs/OPT_PLAN.md`。
>
> **补记(2026-11-01)**:G1 原来只做了「认证」,链路本身仍是明文 ——
> 认证解决「谁能连」,不解决「谁看得见」。现在握手会派生双向会话密钥,
> 每帧走 AEAD。实测同一条 `sql-join` 会话:无 PSK 时抓包里有 **176 个明文帧头**
> 和 2 处 `balance` 字样;有 PSK 时 55981 字节里 **0 个帧头、0 处明文字段**。
| # | 缺口 | 具体形态(贴合 nax 约束) | 代价 |
|---|---|---|---|
| G0 | **没有设备抽象**(2.0) | ~~把 `is_dry_run()` 显式化为 `trait Device::eval(op)` 分发~~ **已落地,但形态不同**:`Value` 自带 `kind`(域是数据属性),`Value::to()` 做跨域搬迁,非线性算子在密态域**显式拒绝**并指向 `nax-sql::secure`。不做 `eval` 分发——线性算子两域同码,非线性算子要换算法而非换指针 | 已完成 |
| G1 | **传输层无认证、密钥走 argv** | ~~加 PSK 挑战-应答~~ **已完成,并顺带补了机密性**:握手(`nax-node::auth`,REQ/ACK/OK + 双 nonce + 双 label)产出双向会话密钥,之后每帧走 `nax-node::secure` 的 ChaCha20-Poly1305(自写,见 `nax-core::aead`),计数器兼做防重放。不引 TLS:`rustls` 拉不进 no_std,也塞不进 TA | 已完成 |
| G2 | **列归属靠命令行对齐** | 把 `--schema` 位置对齐改成**带归属的自描述清单**(JSON:列名/类型/归属方/分片序),会话开始先交换哈希比对,不一致立刻报「谁的 schema 不一致」而不是「open 长度不一致」 | 小,本轮已做了一半(计划对表) |
| G3 | **无数据授权登记** | 不是「加载一份清单然后 `if` 判断」,而是**密钥级管控**(照 TEEU 的 `(func_bytes, data_uuid) → key`):分片落盘加密,授权服务放 enclave 内,按 `(算法哈希, 数据 id, 用途, 有效期)` 发密钥;批不批本身就是一个带硬件签名的凭证 | 中 |
| G4 | **作业对象无状态** | `nax-orch` 的 plan 升级为带 `dependencies` 的 DAG + 落盘状态(append-only 日志即可),支持「谁失败了、从哪重来」 | 中 |
### 3.2 生态必需(补,但可以晚)
| # | 缺口 | 说明 |
|---|---|---|
| G5 | **数据接入只有全量加载** | 学 `DataMeshDataIOInterface`:三方法(读/写/端点),中间表示改为**分批**而不是整表。数据源加 S3/OSS 与 Parquet 前,先把接口收出来 |
| G6 | **无组件契约** | 不引 protobuf。用 `nax-proto` 的一帧承载「组件名 + 输入列 + 参数 + 输出列」的 JSON 描述,让算法可以只写 SQL/配置而不重编译 |
| G7 | **无报告结构** | CLI 加 `--report json`,输出固定的 `Tab/Table` 结构,与 G6 共用一套 schema |
| G8 | **无互操作** | 只有在要对接 FATE/其他平台时才做;BFIA 适配是一个 Go 包,nax 对应物是一个帧编解码层 |
| G9 | **无镜像校验** | 发布产物附 `sha256` + 签名,`nax-node` 启动自检(照抄 `AppImage.ID` 的思路) |
### 3.3 不该补(明确拒绝,写进决策记录)
| 东西 | 为什么不补 |
|---|---|
| **XLA 级编译栈 + pphlo IR** | 与 no_std / 单二进制 / TEE 互斥。~~nax 的 IR 就是 `nax-sql` 的 AST,这条路已经对了~~ **部分修正(2026-11-01)**:AST 是语法树,回答不了「几个往返」。已落地 `nax-ir`(~600 行、零依赖)只做「三态标注 + 轮次规划」,不碰 XLA/Bazel/MLIR。详见 §2.3 的修正块与 `docs/IR.md` |
| **Arrow / Flight** | 依赖重、要分配器。用「分批 u64 数组 + 列描述」达到同样效果 |
| **K8s / CRD / controller** | 定位冲突。nax 的卖点是「1 个二进制」,编排用 orch + 落盘状态即可 |
| **协议后端可插拔(aby3/cheetah/semi2k)** | 只有当确实要上 2PC 高性能协议时才需要。现在引入会让 `nax-core` 铁律失效。**但 G2 的类型三态标注可以先做,成本低** |
| **Python 算法层** | 反向:nax 的价值就是不让算法带 Python 运行时进 TEE |
### 3.4 nax 该守住的优势
1. **可编入 TEE**:SPU 要求 AVX2/CUDA,Kuscia 要求 K3s 全家桶;nax 能进 TA。
2. **体积**:单二进制 vs Kuscia 镜像 + K3s(数百 MB)。
3. **供应链**:Paillier bigint、SHA-256、HMAC/PBKDF2/SCRAM 全部手写零依赖,
SecretFlow 栈是 Bazel + protobuf + Arrow + brpc 的长依赖链。
4. **可验证性**:与 Python 参考逐位一致 + golden 向量。SPU 有单测但没有「双实现互证」。
5. **信任根分级**:`TrustPlan` 四级(L0 纯 MPC → L3 双 TEE 互不信任)是退让模型,
SecretFlow 只有「用哪个 device」没有「降到哪一级」的概念——TEEU 与 SPU 是并列选项,
不是同一个方案里的信任降级。
> 注意 §2.6 的修正:SecretFlow 的 TEEU **有**授权管控(密钥级),
> 所以「出域管控」不算是 nax 单方面领先,两边是**不同路线**:
> TEEU 要求「数据在 TEE 内解密」→ 必须信任单点;nax 要求「分片在谁手里都不成明文」→ 不信任任何单点。
> nax 真正独有的是**不要求任何单点可信**这一条。
---
## 4. 如果只做一件事
**做 G1(传输认证)。** 理由:
- 它是唯一一条「不做就不能给客户看」的缺口——现在任何一方只要知道端口就能冒充参与者;
- 代价最小,`nax-proto` + `nax-node` 两个文件,复用已实现的 HMAC/PBKDF2;
- 它顺手解决 `--seed` 走 argv 的问题(PSK 派生会话密钥,seed 退化成一个 label);
- 做完之后,G3(授权登记)才有落点——签名的授权凭证需要一个可信的对端身份来验。
**但 G0(设备抽象)是另一种意义上的第一优先**:它不是「缺功能」,是「缺分水岭」——
现在每加一种域(明文 / MPC / HE / TEE)就要在算法里写一遍 `if`,
等算法长到 5 个以上,这个成本会指数上涨。它比 G1 贵,但**只贵一次**;
G1 贵在每次接入新客户都要解释「为什么没有认证」。
**不做的一点理由**:如果近期目标是性能基准和 TEE 验证,G1 可以延后,
但必须写进文档说清「当前只有链路完整性、没有身份认证」,不能让使用者误以为有。
---
## 附录 A:镜像仓库状态(2026-10-31 核对)
内网 Gitea(`192.168.1.26:30960`)里 secretflow 相关共 **7 个条目,实为 5 个仓 + 2 份冗余**:
| 条目 | 状态 | 说明 |
|---|---|---|
| `secretflow/secretflow` | 480 MB · `11425fa5` | 主仓,**保留** |
| `secretflow/spu` | 24.5 MB · `826537d9` | 保留 |
| `secretflow/kuscia` | 52.2 MB · `c04279ae` | 保留 |
| `secretflow/spec` | 0.6 MB · `cf2b6c4` | 保留 |
| `secretflow/secretpad` | 146.7 MB · `8fb060e1` | 保留(Web 平台,Java) |
| `mirrors/secretflow` | 480 MB · `11425fa5` | **冗余**,与主仓同 head,可删 |
| `upstream/secretflow-src` | 480 MB · `11425fa5` | **冗余**,与主仓同 head,可删 |
后两条是首次克隆失败留下的空目录被后续同步"补熟"的结果,三份 pack 完全相同,
合计 **1.4 GB 里有 960 MB 是浪费**。
**建议补的仓**(都对 nax 有直接对标价值,当前未镜像):
| 仓 | 对标 | 为什么值得看 |
|---|---|---|
| `secretflow/scql` | `nax-sql` | 密态 SQL 的完整实现:查询编译、算子切分、CCL 配置的工程形态 |
| `secretflow/yacl` | `nax-core` 的密码学原语 | C++ 原语库(OT / ECC / 对称),SPU 的地基;我们的手写实现可对拍 |
| `secretflow/heu` | `nax-he` | 同态加密库,Paillier 的接口设计与性能工程 |
| `secretflow/secretpad-frontend` | 无可对标 | 只在要做 Web 控制台时才需要 |
> 工具坑:`search_code` 的 `query` 不支持 `a|b`(返回空,必须拆单关键词);
> `add_mirror` 失败会留空目录且之后同名调用永远报 `already exists`(无删除接口),
> 需要先去 Gitea 网页端删掉。