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

27 KiB
Raw Blame History

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):

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)。

于是算法长这样,它不知道自己在明文还是密文域:

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)

它是「策略不是检查代码,而是控制密钥」,四个要素:

@dataclass
class TEEUData:
    data: Any          # 明文,或 AES256-GCM 密文
    data_uuid: str     # 给 authority manager 的凭据
    nonce: bytes       # AES-GCM nonce
    aad: bytes         # AES-GCM 关联数据

进 TEE 时不是先跑策略再跑代码,而是先拿密钥:

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 网页端删掉。