acceptodds
Under review as a conference paper at ICLR 2027

Duplex: Actively Secure, Dealer-Free Two-Party Function Secret Sharing for Private LLM Inference

Abstract

Private LLM inference lets a client and a model provider evaluate a model while neither reveals its secret, and function secret sharing (FSS) is the most communication-efficient tool for its nonlinear layers—yet every deployed FSS inference system assumes a trusted dealer and semi-honest evaluators. A recent two-party FSS construction removes both assumptions with dealer-free key generation and a dynamic cross-phase verification chain, but stops short of an inference system. We present DUPLEX, which turns that verification core into an end-to-end dealer-free, actively secure two-party framework: (i) a secure runtime whose session state machine makes consuming an uncertified key or releasing an unauthenticated output structurally impossible; (ii) a cost-aware compiler that unifies lookup tables and low-degree splines for GELU, Softmax, SiLU and LayerNorm, solving for the segmentation that prices active-verification overhead under an accuracy budget ; and (iii) a PCG/VOLE producer-consumer scheduler with Half-Tree key compression and bit-exact CUDA/CUTLASS kernels. Across six open LLM checkpoints including BERT-Base, GPT-2 and Llama-3.2-1B, the full stack executes end to end with per-token fidelity up to 0.9998 and next-token top-1 agreement up to 100.0%; a naive spline-only plan costs up to more, and the device-resident exact ring GEMM runs faster than the CPU. The paper completes the design with a simulation-based security proof of the full DUPLEX scheme against one statically corrupted, malicious party.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
private LLM inference, secure two-party computation, privacy-preserving machine learning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_Y7KfOpenReview ↗
Rating
2
Confidence
3(+1)
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This work proposes a method DUPLEX, two-party framework aims to improve the security of FFS-based private LLM inference. Existed FFS-based inference systems rely on a trusted dealer for key generation and distribution. Based on existed two-party FFS construction, DUPLEX builds a dealer-free private pipeline for LLM inference by proposing Secure Runtime, Cost-aware Compiler and PCG/VOLE Scheduler.

Critical strengths

DUPLEX extends existed two-party FFS construction into a complete Transformer inference pipeline and also introduce two optimizations (cost-aware compiler and preprocessing scheduler) to reduce the computational overhead.

Critical weaknesses
  1. DUPLEX’s security guarantees are mainly inherited from the verification core of previous work [1]. There are limited security analysis of the introduced public plan and the scheduler.

  2. The paper claims DUPLEX is an end-to-end secure LLM framework. However, deviation detection experiment (Table 5) are mainly conducted on three-layer MLP models rather than LLM models. Authors should provide empirical evaluations on different attacks to justify the security of DUPLEX.

  3. The readiness and the structure of this paper still have large space for improvement.

[1] Xue, Yujie, et al. "Actively Secure Two-Party Function Secret Sharing with Dynamic Cross-Phase Verification." Cryptology ePrint Archive (2026).

Questions for authors

What other non-trivial security issues are resolved by DUPLEX except the guarantees already provided by the verification core of [1]?

5 comments
AuthorsOpenReview ↗

Response to Reviewer Y7Kf: added guarantees and attack evidence (1/3)

We thank the reviewer for the constructive assessment. All additions described below are marked in blue in the revised manuscript and enhanced artifacts, which will be posted at a later time; page numbers refer to the revised PDF. The original section order, Figures 1-8 and Tables 1-12 are preserved, and new material is placed in the appendices unless otherwise noted. Below are the relevant details for this response.

1. Reviewer comment: DUPLEX’s security guarantees mostly inherit from the prior-work verification core [1], with limited security analysis for its newly introduced public plan and scheduler.

Response. We agree, and we have made the division of labour explicit: what is inherited, what is added, and why the additions cannot weaken the inherited guarantee. Concretely:

(1) Session-level composition. The core certifies individual gates; DUPLEX binds generation, certification, evaluation and release into one session object through the one-way state machine OPEN→PLANNED→PRODUCING→CERTIFIED→ONLINE→RELEASED, and the digest chain ht=H(ht−1∥mt)h_t = H(h_{t-1} \| m_t) binds the plan, per-bundle verdicts, the certification barrier, the release event and queue entries to sid. Consuming an uncertified key, releasing an unauthenticated output and substituting material across phases are therefore structurally impossible. See §5 (p. 6) and Appendix F.

(2) The public plan (C2) leaks nothing extra. The cost-aware plan is a deterministic function of the public architecture and budget δ\delta; it is fixed in the PLANNED state before any key request is issued, so the plan reflects only information that is already public. See Appendix H, “The approximation plan is public (C2)” (p. 25).

(3) The scheduler (C3) introduces no secret-dependent behaviour. The six queue invariants (Proposition 1) make refill, dispatch and release points functions of public counters; Half-Tree replaces only the offline key representation under one stated assumption; and the CUDA/CUTLASS kernels are deterministic and bit-exact against the CPU reference. Hence C2/C3 neither change the secret-dependent distribution of transcripts nor add adversarial capability. See Appendix H, “Scheduling adds no secret-dependent behaviour (C3)” and the blue paragraph “Compiler and scheduler add nothing (C2/C3)” (p. 26), and Proposition 1 (queue invariants, Appendix G, p. 23).

(4) End-to-end composition. We define the ideal inference functionality Finf(M,δ)F_{inf}(M,\delta) and prove, in the (Fprep,Fcoin)(F_{prep}, F_{coin})-hybrid model, that the full runtime securely realizes it with abort against one statically corrupted, rushing, malicious party, with distinguishing advantage ≤m⋅ϵgen+ϵrep+negl(λ)\le m\cdot\epsilon_{gen} + \epsilon_{rep} + negl(\lambda) (ϵgen≈2n/∣E∣\epsilon_{gen} \approx 2n/|E|, ϵrep≤2/∣E∣\epsilon_{rep} \le 2/|E|), and we add a three-step proof sketch (offline simulation, online masked openings, two bad events). See §7, Theorem 1 (p. 7); Appendix H.1 (FinfF_{inf} definition and sketch, p. 26); Appendix I (full proof).

(5) A genuine system-level leak, found and fixed during this revision, shows that the analysis is not vacuous: the early batch design shared one scalar key mask per layer, which permits a cell-difference leak of plaintext activations. It is replaced by per-coordinate vector-offset batch keys with a batched coordinate audit (6m6m residuals, one challenge), which covers exactly the reuse surface that batching introduces. See §5 and Appendix F (p. 22); inherited assumptions and trust boundaries are stated explicitly in Appendix H, “Additional assumptions and trust boundaries” (p. 25).

AuthorsOpenReview ↗

Response to Reviewer Y7Kf: added guarantees and attack evidence (2/3)

2. Reviewer comment: Although DUPLEX is presented as an end-to-end secure LLM framework, its deviation-detection experiments (Table 5) primarily use a three-layer MLP instead of LLMs; empirical evaluations against diverse attacks are required to validate its security.

Response. We agree that the earlier attack evidence was too small in scale. We have consolidated it into a coverage table that states, for every scenario, where the deviation is injected, which layer detects it and what was measured, and we have strengthened the LLM-scale evidence to the extent the protocol allows:

(1) The gate-level injection campaign is expanded to 36 injections: six deviation classes (keys/payloads/masked opening/audit residual/commitment/transcript) × DPF/DCF × three trials. All 36 are detected (36/36), and 5/5 honest runs are accepted with the correct output. See Table 5 (p. 27) and its caption.

(2) Four end-to-end two-process scenarios run over a loopback TCP connection: the honest run returns RELEASED with the correct output; tampering with a released share (+7) yields ABORT; use-before-certify is refused at the certification barrier; and tampering with the certification transcript yields ABORT. See Table 5 (p. 27) and Table 8 (C1), p. 31.

(3) At LLM scale, every row we report is a two-process execution (two independent processes over TCP, GenTrace/GenCheck messages, fresh per-call certified keys, aggregated Λ\Lambda-MAC release), and the cross-process invariants are checked row by row (transcripts equal; byte/round/triple/key symmetry; both parties RELEASED). See §8 (pp. 8–9), Table 1 (p. 8) and the reproducibility claims of Table 9 (p. 33). The reuse surface of the batched path is covered by the per-coordinate batch keys and batched audit (p. 22).

(4) Formal counterpart: the abort predicate has exactly two exits — survive GenCheck (probability ≤m⋅ϵgen\le m\cdot\epsilon_{gen}) or survive the aggregated Λ\Lambda-MAC (≤ϵrep\le \epsilon_{rep}); opened values are MAC-covered, so there is no third, silent exit. See the three-step proof sketch in Appendix H (p. 27).

Boundary, stated explicitly. We did not re-run the 36 injections for every LLM model. The injection campaign targets the same C++ gate/audit implementation and the same wire protocol that the LLM rows execute, and the LLM rows supply the scale-side evidence (cross-process invariants and the aggregated release check). This coverage relation is stated in the Table 5 caption and in Appendix H; we make no stronger claim.

3. Reviewer comment: Readability and structure can still be improved substantially.

Response. Without changing the section order or removing any of the original Figures 1–8 and Tables 1–12, we improved readability by adding pointers in the main text, moving detail to the appendix, and consolidating numbers into tables:

(1) A notation table (Table 3, p. 16, Appendix C) fixes the symbols (nn, mm, EE, Λ\Lambda, Δ\Delta, ϵgen\epsilon_{gen}, ϵrep\epsilon_{rep}) and prevents drift between the main text and the appendix.

(2) An appendix-overview paragraph (p. 14) maps Appendices A–L to the main-text sections and states that Appendices C–H and K reproduce deferred passages verbatim, so the main text can be read on its own.

(3) The main text adds pointers rather than moving content: §7 (p. 7) enumerates where FinfF_{inf}, the MAC algebra, opened-value coverage, reduction-stage security, C2/C3 and the three-step sketch are formalized; §8 (pp. 8–9) states precisely what the two-process runs do and do not cover.

(4) Numbers that were scattered in prose are consolidated into tables: Table 4 (gate-domain stage costs, p. 21), Table 5 (attack coverage, p. 27) and Table 16 (downstream utility, p. 40, with column meanings in the caption); units are unified to minutes, GB, ×106\times 10^6 and ×109\times 10^9 in the captions of Tables 1, 12, 13 and 14 (pp. 8, 35–36, 38).

(5) Proof readability: a three-step proof sketch in Appendix H (p. 27) separates the offline simulation, the online masked openings and the two bad events; the full proof remains in Appendix I.

(6) The downstream evidence now has its own reading entry: Appendix L.5 “Downstream utility” (p. 37, 40) and one summarizing sentence in the abstract (p. 1).

AuthorsOpenReview ↗

Response to Reviewer Y7Kf: added guarantees and attack evidence (3/3)

4. Reviewer question: Beyond the guarantees already provided by the verification core [1], which other non-trivial security problems does DUPLEX solve?

Response. DUPLEX adds and formalizes six non-trivial guarantees beyond the core. All are marked in blue in the revised manuscript and are backed by executed evidence:

  1. Session-level composition and state machine. The one-way state machine OPEN→PLANNED→PRODUCING→CERTIFIED→ONLINE→RELEASED binds generation, certification, evaluation and release into one session object, so that consuming an uncertified key or releasing an unauthenticated output becomes structurally impossible; use-before-certify is refused at the barrier (one of the executed scenarios). §5 (p. 6); Appendix F; Table 5 (p. 27).

  2. Transcript binding. The digest chain ht=H(ht−1∥mt)h_t = H(h_{t-1} \| m_t) binds the plan, per-bundle verdicts, the certification barrier, the release event and queue entries to sid; cross-phase substitution (certifying one set and consuming another) aborts on a digest mismatch. §5 (p. 6); Appendix F.

  3. Plan and scheduler secret-independence. The cost-aware plan is a deterministic function of the public architecture and budget δ\delta, fixed in the PLANNED state; the six queue invariants make refill, dispatch and release points depend only on public counters; and the GPU kernels are bit-exact against the CPU. §7 (p. 7); Appendix H (p. 26); Proposition 1 (Appendix G, p. 23).

  4. Session isolation and crash recovery. Nonces are namespaced by sid and cannot be observed or consumed across sessions; after a crash, log replay discards uncertified in-flight bundles and does not revive consumed correlations. §6; Appendix G.

  5. End-to-end composition theorem. With the new ideal functionality Finf(M,δ)F_{inf}(M,\delta) as the reference, DUPLEX securely realizes it in the (Fprep,Fcoin)(F_{prep}, F_{coin})-hybrid model against one statically corrupted, rushing, malicious party with abort, with advantage ≤m⋅ϵgen+ϵrep+negl(λ)\le m\cdot\epsilon_{gen} + \epsilon_{rep} + negl(\lambda). Multi-query composition uses a fresh session per query, leaks only correctly released outputs, and has independent error across queries. §7, Theorem 1 (p. 7); Appendix H (p. 26); Appendix I.

  6. Newly formalized arguments. (a) The definition of FinfF_{inf} (Appendix H, p. 26). (b) Opened values (the masked opening x^\hat{x} and the Beaver differences) are authenticated and enter the aggregated release MAC check, which is made explicit both at the release barrier and in the proof steps. (c) The two-plane MAC algebra and its detection probability: Z264Z_{2^{64}} ring MACs (2−642^{-64} per opening) and Fp2F_{p^2} Λ\Lambda-tags (ϵrep≤2/∣E∣\epsilon_{rep} \le 2/|E|) joined by Aggregate. (d) Security of the reduction stages: clamp comparisons, MSB scans and wrap-bit comparisons are authenticated affine gates of the lifting catalogue; the stage sequence depends only on public grid widths and the uniform masked value, and the stage costs are measured (the BERT erf-GELU plan is a 12-bit plan served by an authenticated affine identity tail). §7 (p. 7); §4 (p. 6); Table 4 (p. 21); Appendices H and I.

Empirical support. The 36-injection campaign (six classes × DPF/DCF × three trials; 36/36 rejected, 5/5 honest accepted) and the four two-process scenarios (honest RELEASED; tamper ABORT; use-before-certify refused; cert-tamper ABORT) are summarized in the attack–detection coverage table (Table 5, p. 27, Appendix H.1).

Readability revisions. A notation table in Appendix C (p. 16); the two-process execution boundary in §8 (p. 9); and a three-step proof overview in Appendix H.1 (p. 27).

All items above can be located at the cited pages. We are pleased to provide the corresponding source code, attack-injection logs, and raw JSON data from the two-process runs within the artifacts to be posted at a later time. Further discussions are welcome.

References:

[1] Xue, Yujie, et al. "Actively Secure Two-Party Function Secret Sharing with Dynamic Cross-Phase Verification." Cryptology ePrint Archive (2026).

Reviewer_JtcROpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents DUPLEX, a two-party private LLM inference framework. It tries to drop both usual assumptions in FSS-based inference: the trusted dealer and semi-honest evaluators. It uses a recent dealer-free, actively secure FSS construction (Xue et al., 2026, the “verification core”) as a black box and builds a full system around it. The validation includes a two-role run on a tiny 3-layer MLP: the honest run releases, the tampered run aborts, and use-before-certify is refused. It also includes a 36-injection deviation campaign, compiler sweeps (up to 3.2× cheaper than spline-only), a median 1.46× overlap speedup, and LAN/MAN/WAN latency projections against SIGMA, BumbleBee and a composed SPDZ-style baseline.

Critical strengths

(1) A really important setting, with a careful architecture. Dealer-free, actively secure two-party inference is exactly the threat model you’d want for a real client and provider. I fully agree that a trusted dealer is hard to justify here. I liked how the certification barrier, the one-way state machine, transcript binding and one-time nonces turn a per-gate guarantee into a session-level one. The six queue invariants (Prop. 1) are stated concretely and tested by injecting violations. This matters a lot to me: if the evaluation held up, this would honestly be the first end-to-end system in this regime, a real step forward.

(2) Solid engineering. The limb-decomposed int8 CUTLASS GEMM that stays bit-exact mod 2^64 is a neat, reusable trick. The Half-Tree adaptation and the artifact appendix with explicit tolerances are well done.

Critical weaknesses

The end-to-end evaluation doesn’t seem to run the protocol the security theorem is about. This is my biggest worry.

  • Key counts don’t scale with model size. In Table 9, every model uses exactly 16 certified FSS instances, 8.9 KB of key material and 119.0 KB of FSS traffic. Offline time stays flat at 18–22 s. That holds from GPT-2 (about 2.4M activation elements per forward, Table 8) up to Qwen2.5-1.5B (about 16M activation plus 1.4M Softmax elements).
  • That conflicts with the proof. The privacy argument (proof step 5, Prop. 1(ii)) needs every r_in to be fresh and used exactly once. That means one certified key per scalar nonlinear call, so millions per forward pass.
  • It also conflicts with the paper’s own per-call cost. Table 12 says preprocessing for one DUPLEX GELU is 39.8 KB over 230 rounds. Multiplied by about 16M calls, that is hundreds of GB, not 119 KB. So either keys or masks are reused (which breaks the privacy argument), or the models never go through dealer-free key generation per call.
  • Gate domain vs. accuracy claims. The LLM runs use 12-bit gate domains (Tables 5, 9), yet the plans claim ≤1 ULP at Q21.16. The paper doesn’t explain how a 38-bit value is reduced into a 12-bit domain obliviously, or what that step costs.
  • Much of the evidence is projected, not executed. Communication and WAN latency are “accounted” or “modelled” (Table 5 says no delay was injected). The model-scale active baseline is composed, not run. The only real two-role release/abort run is a 384-weight MLP with 2 FSS instances.
Questions for authors
  • How many certified keys are consumed per forward pass, and are any keys or masks reused across invocations? Please reconcile Table 9 (16 instances, 119 KB, flat offline time) with Table 12 (39.8 KB and 230 rounds per GELU).
  • Were the LLM runs real two-process executions exchanging the actual GenTrace/GenCheck messages, MAC-plane values and the final Release check? Or were they single-process runs with accounted bytes? Was the Λ-MAC check actually computed for any LLM run?
  • Are the opened x̂ values and Beaver differences included in the aggregated MAC check? If not, how is an additive error injected during an opening detected?
  • What exactly can the abort predicate be? Can the adversary choose it adaptively in each session, and how much leaks over many queries or generated tokens? A formal statement of F_inf would really help.
  • Which algebra authenticates the mod-2^64 linear-layer values? Is the MAC plane also computed on the GPU?
5 comments
AuthorsOpenReview ↗

Response to Reviewer JtcR: actual executions and corrected key accounting (1/4)

We thank the reviewer for the constructive assessment. We confirm that all experimental results below come from executions we ran on our servers in this revision (C++ two-process TCP protocol runs and downstream-task runs) and are marked in blue in the revised manuscript. Page numbers refer to the revised PDF; the original section order, Figures 1–8 and Tables 1–12 are preserved.

1. Reviewer comment: The end-to-end evaluation does not appear to run the protocol targeted by the security theorem.

Response. We accept this criticism. This revision replaces “single-process forward plus byte accounting” with a real execution of the protocol the theorem targets. (§8, pp. 8–9; Appendix F, p. 22)

(1) The runtime is a genuine C++ two-process protocol: two independent processes on the evaluation host over a loopback TCP socket, real GenTrace/GenCheck messages, freshly generated certified keys and masks per call, authenticated ring GEMMs carrying the MAC plane for the linear layers, authenticated reductions/truncations, and release decided by the aggregated Λ\Lambda-MAC check. All three network profiles inject per-flight one-way delays on the socket (0.025 / 3 / 25 ms). (§8 (blue execution-boundary paragraph, p. 9))

(2) At LLM scale, every row we report (BERT-Base S=128S=128 in three profiles, GPT-2 S=64S=64 in three profiles, OPT-125M in three profiles, and the GPT-2 S=32S=32/S=128S=128 sweep; ten rows in total) is an execution of that protocol, and the cross-process invariants are checked row by row (equal transcripts; byte/round/triple/key symmetry; both parties RELEASED). (Table 1 (p. 8))

(3) Four end-to-end scenarios (honest RELEASED; tamper on a released share (+7) ABORT; use-before-certify refused at the barrier; certification-transcript tamper ABORT) together with the 36-injection campaign form the attack–detection coverage table, where every scenario names its injection point and detecting layer. (Table 8 (p. 31); Table 5 (p. 27); Appendix H)

2. Reviewer comment: The number of keys does not grow with model size, which conflicts with the proof's “fresh per call” requirement.

Reviewer's point. “In Table 9 every model uses exactly 16 certified FSS instances, 8.9 KB of key material and 119.0 KB of FSS traffic, with offline time flat at 18–22 s … This conflicts with the proof, whose privacy argument requires each rinr_{in} to be fresh and used exactly once, and with the paper's own per-call cost (39.8 KB and 230 rounds per GELU, which over ~16 M calls is hundreds of GB).”

Response. The reviewer is right: the old “16 instances / 119 KB / flat 18–22 s” line was a fixed template shared by all models, which contradicts the fresh-per-call requirement of the proof. That was our error; the template row is deleted and everything is now reported from per-call measurements (Table 1, p. 8; Tables 12 and 13, p. 36; Appendix L, p. 37). Below are the revised results.

(1) The new accounting grows with model size: GPT-2 S=64S=64 consumes 1.80×1091.80\times 10^{9} certified key coordinates per forward, 9.64 GB of offline material and 4,469 rounds; BERT-Base S=128S=128 consumes 4.22×1094.22\times 10^{9}, 22.67 GB and 4,469 rounds; online bytes and rounds are GPT-2 21.84 GB / 7,684 rounds; BERT 40.59 GB / 8,338 rounds. The sweep rows show the key count growing with context length. (Table 1, p. 8; Tables 12 and 13, p. 36)

(2) Keys and masks are fresh per call and never reused: every nonlinear call generates and certifies a new DPF/DCF instance, and masks are fresh per element. To amortise certification we use per-coordinate vector-offset batch keys with a batched coordinate audit (6m6m residuals under one challenge), so a batch shares one challenge while preserving per-coordinate freshness and detectability. This also fixes a real leak in the earlier design, where one scalar key mask was shared by a whole layer and permitted a cell-difference leak of plaintext activations. (§5 and Appendix F, p. 22)

(3) Table 15's 3,552 B / 37 rounds and the per-forward totals of Table 1 do not conflict because they count different objects: the former is one scalar gate call, the latter is the measured total over 173 batched instances (each covering S⋅dS\cdot d elements). (Table 15, p. 39; Table 4, p. 21)

AuthorsOpenReview ↗

Response to Reviewer JtcR: actual executions and corrected key accounting (2/4)

3. Reviewer comment: The 12-bit gate domain is not reconciled with the Q21.16 accuracy claim (reduction and its cost are missing).

Reviewer's point. “The LLM runs use a 12-bit gate domain, yet the scheme claims ≤1\le 1 ULP error under Q21.16. The paper does not explain how a 38-bit value is obliviously reduced to a 12-bit domain, nor what that step costs.”

Response. We do not truncate a 38-bit Q21.16 value to 12 bits. The reduction is an explicit, staged, oblivious computation whose cost and error are now measured and tabulated separately. (§4, p. 6; Table 4, p. 21)

(1) The reduction pipeline is clamp (authenticated comparison) → fold (wrap) → MSB scan → table lookup → rescale. Every stage is an authenticated affine gate of the lifting catalogue (authenticated comparison, shift, bit decomposition); the stage sequence depends only on public grid widths and the uniform masked value, and no branch reads a secret in the clear. (§4 gate-domain paragraph, p. 6; Table 3, p. 16)

(2) Measured per-call costs: GELU 3,552 B / 37 rounds; EXP 1,984 B / 22 rounds; RECIP 2,208 B / 24 rounds; RSQRT4 1,312 B / 14 rounds (gate-domain reduction table). (Table 4, p. 21)

(3) The accuracy statement is now split: the 1-ULP claim is the kernel's approximation error on the grid; mapping a Q21.16 input onto the reduced grid adds about one table ULP of quantization error, and the two columns are listed separately. BERT's erf-GELU uses a 12-bit plan plus an authenticated affine identity tail (exactly the identity for x≥127.9375x \ge 127.9375), which leaves the plan, the offline material and the peak memory unchanged. (Table 4, p. 21)

4. Reviewer comment: Much of the evidence is projected/accounted rather than executed.

Reviewer's point. “Communication and WAN latency are ‘accounted’ or ‘modelled’ (Table 5 says no delay is injected); the model-scale active baselines are composed rather than run; the only real two-role release/abort run is a 384-weight, 2-FSS-instance MLP.”

Response. There are no projected/accounted numbers left: every network profile is a socket execution with real injected delays, every per-call baseline is executed. (§8, pp. 8–9; Table 14, p. 38)

(1) Every profile injects real per-flight one-way delays on the socket (LAN 0.025 / MAN 3 / WAN 25 ms); the old caption “no delay injected (latency projections…)” is deleted. (§8, pp. 8–9; Table 14, p. 38)

(2) Per-call baselines are all executed: SPDZ-style 160 B / 3 rounds, BGI DPF, and the Duplex certified gate at 3,552 B / 37 rounds. (Table 15, p. 39)

(3) The model-scale active-baseline row is composed from measured per-call costs and is explicitly labelled as such in the caption; what is executed is the four C1 scenarios and the ten LLM rows. (Table 15, p. 39, caption)

(4) “The only real two-role run is a 384-weight MLP” no longer holds: the full C++ two-process protocol now covers C1 and LLM scale (including runs with 173 gate instances and billions of key coordinates). (Table 1, p. 8; Table 8, p. 31; Table 5, p. 27)

5. Reviewer question: How many certified keys are consumed per forward? Is any key or mask reused across calls? Please reconcile Table 9 (16 instances, 119 KB, flat offline time) with Table 12 (39.8 KB, 230 rounds per GELU).

Answer. In the new runtime every scalar nonlinear call consumes a freshly generated and certified DPF/DCF instance, and neither keys nor masks are ever reused across calls (one-time nonce, single consumption; queue invariants, Proposition 1). Measured per forward: BERT-Base 4.223×1094.223\times 10^{9} certified key coordinates, 22.674 GB offline material, 40.595 GB / 8,338 rounds online, and 26379.4 s in WAN; GPT-2, S=64S=64, 1.800×1091.800\times 10^{9}, 9.638 GB, 21.838 GB / 7,684 rounds, 97.3 min offline and 20.7 min online. The old “16 instances / 119 KB / flat 18–22 s” line was a single template shared by all models, which is exactly the reviewer's point; it is deleted and replaced by per-call measured totals in Tables 1/12/13 (pp. 8 and 36), with the old-versus-new accounting recorded in the Appendix L implementation note. For reconciliation: Table 15's 3,552 B / 37 rounds is one scalar gate call, whereas the per-forward totals count 173 batched instances, each covering S⋅dS\cdot d elements. (§8, pp. 8–9; Tables 1, 12 and 13, pp. 8 and 36; Table 15, p. 39; Appendix L, p. 37)

AuthorsOpenReview ↗

Response to Reviewer JtcR: actual executions and corrected key accounting (3/4)

6. Reviewer question: Are the LLM runs real two-process executions exchanging GenTrace/GenCheck messages, MAC-plane values and a final Release check, or single-process runs with accounted bytes? Is the Λ\Lambda-MAC check actually computed in any LLM run?

Answer. They are real two-process executions. The C++ protocol runs two independent processes on the evaluation host over real loopback TCP; the parties exchange GenTrace/GenCheck messages (fresh per-call masks and certified keys, covered by one aggregated certification) and MAC-plane values (the authenticated ring GEMMs of the linear layers carry the MAC plane); the final Release computes the aggregated Λ\Lambda-MAC check. The honest run returns RELEASED; tampering with a released share yields ABORT with no output; use-before-certify is refused at the barrier; and a tampered certification transcript yields ABORT at the barrier (Table 8, p. 31; all four scenarios executed). C1 MLP: 15,072 B / 92 rounds offline and 25,088 B / 11 rounds online. The ten LLM rows run on the same protocol (§8, pp. 8–9; Tables 1/12/13 are per-call measurements). The old “no delay injected (latency projections…)” caption is deleted; every profile injects real per-flight delays (LAN 0.025 / MAN 3 / WAN 25 ms) on the socket. (§8, pp. 8–9; Table 8, p. 31; Table 5, p. 27; Table 9, p. 34; Appendix L, experiment E1)

7. Reviewer question: Are the opened x^\hat{x} values and the Beaver differences covered by the aggregated MAC check? If not, how are additive errors injected during opening detected?

Answer. Yes, they are covered. No value is opened bare: the masked opening x^=x+rin\hat{x} = x + r_{in} carries the Λ\Lambda-MAC plane of its certified key, and the linear-layer Beaver difference carries the Δ\Delta-MAC; both enter the session's aggregated release MAC check. An additive error injected during opening is therefore equivalent to tampering with the released share and is caught by Release with ϵrep≤2/∣E∣\epsilon_{rep} \le 2/|E|; this is precisely why the bad-event bound has only two exits. The statement is explicit in the release barrier paragraph (§5 and Appendix F, VERI-11), in the MAC-algebra/opened-values paragraph of §7, in step (3) of the three-step proof sketch, and in steps (5)/(7) of the full proof (Appendix I), and it is covered empirically by the tamper row of Table 5. (§5, p. 6; Appendix F, p. 22; §7 and Appendix H, p. 26; Appendix I, pp. 27–30; Table 5, p. 27)

8. Reviewer question: What can the abort predicate be? Can the adversary choose it adaptively per session? How much leaks across multiple queries or generated tokens? A formal statement of FinfF_{inf} would help.

Answer. The abort predicate follows the verification core's prescribed predicate-based abort convention: a single, narrow, verification-triggered condition fixed with the sid at session start, so the adversary cannot choose a different one per session; the state machine leaves exactly two exits (survive GenCheck, or survive the aggregated Λ\Lambda-MAC), and each exit is covered by the stated detection probabilities. Multi-query and multi-token leakage is pinned down by the new definition of the ideal inference functionality Finf(M,δ)F_{inf}(M,\delta) (§7, Appendix H): each query is a fresh session; leakage across queries is limited to correctly released outputs (inherent, not a protocol flaw); the soundness error accumulates as m⋅ϵgen+ϵrepm\cdot\epsilon_{gen} + \epsilon_{rep} and is independent across queries; and the adversary's view contains only the public transcript (sid, MM, δ\delta, π\pi and message lengths/timing) plus released outputs or abort, with no state shared across sessions beyond released outputs. Multi-token generation runs inside one query under the public plan and adds no extra leakage channel. (§7, pp. 7 and 26; §5, p. 6; Appendix I, pp. 27–30)

Reviewer_3e6pOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

The paper presents Duplex, an end to end two party private inference system for transformers based on function secret sharing. Compared to prior function sharing system mechanisms like ORCA which rely on a trusted dealer, Duplex is dealer free and actively secure against malicious parties. The core idea builds on Xue etal, 2026 (VeriFSS) by adding a session state machine, a cost aware approximation compiler, and producer-consumer preprocessing. The authors show results on six huggingface checkpoints and show that the top-1 accuracy and cosine similarilty between plaintext and ciphertext is high. They also compare with various baselines and discuss the limitations and advantages of Duplex.

Critical strengths
  1. Duplex builds a working system around Xue et al., to create a dealer free FSS inference system. As per my understanding, it is the first of its kind to show these properties on real-world models like BERT-base and GPT 2.5.

  2. The cost-aware compiler is well-motivated and the pricing table vs spline per region looks to be the right model rather than the previously published semi-honest ones.

  3. Overall, the paper motivates the problem and solution pretty well. I also appreciate that the authors discuss limitations clearly.

Critical weaknesses
  1. The paper only measures fidelity and not the actual task performance. While the paper clearly states this limitation, it would be much stronger evaluation. Tiny perturbations in the token predictions often lead to significant regressions in downstream tasks.
Questions for authors

none

1 comment
AuthorsOpenReview ↗

Response to Reviewer 3e6p: Added downstream task evaluation results

Thank you for the constructive review.

We agree that task-level evidence was missing and have now added it. On the evaluation server we ran the exact certified fixed-point stack behind the paper's fidelity numbers (Q21.16 linear layers + certified 12-bit nonlinear gates) on downstream benchmarks, with the task head applied to both the plaintext and the secure encoder outputs so the comparison isolates the encoder stack. The new experimental results are presented below.

Table 16: Downstream utility of our secure stack on various benchmarks. Δ=Secure−Plain\Delta = \text{Secure} - \text{Plain}. “---” indicates that MosFormer (Cheng et al., 2025) only reports relative perplexity change, and the three metrics for multi-token decoding are consistency relative to plaintext with no corresponding plaintext values.

ModelTaskMetricSchemePlainSecureΔ\Delta
BERT-baseSST-2Accuracy (%)Ours (secure stack)92.660692.6606+0.00
SHAFT (Kei and Chow, 2025)92.6692.20−0.46-0.46
SIGMA (Gupta et al., 2024)92.5592.55+0.00
QNLIAccuracy (%)Ours (secure stack)91.543191.6163+0.07
SHAFT (Kei and Chow, 2025)90.7790.38−0.39-0.39
SIGMA (Gupta et al., 2024)91.6091.63+0.03
CoLAMatthews corr.Ours (secure stack)0.53390.5392+0.0053
SHAFT (Kei and Chow, 2025)0.57780.5685−0.0093-0.0093
Accuracy (%)Ours (secure stack)81.208181.3998+0.19
MRPCAccuracy (%)Ours (secure stack)87.745187.7451+0.00
SIGMA (Gupta et al., 2024)84.3187.25+2.94
F1 (%)Ours (secure stack)91.349591.3495+0.00
GPT-2LambadaAccuracy (%)Ours (secure stack)46.671847.6033+0.93
SIGMA (Gupta et al., 2024)32.4633.28+0.82
WikiText-2PerplexityOurs (secure stack)87.593188.1623+0.65%
WikiText-103PerplexityMosFormer (Cheng et al., 2025)------+0.3%
Multi-token decodingPer-step top-1 agr. (%)Ours (secure stack)---93.41---
Exact full-seq. match (%)Ours (secure stack)---17.19---
Mean first divergence (of 32)Ours (secure stack)---11.77---

Across all tasks, the secure stack stays within the error budget of the plaintext floating-point model. Its performance gap between the secure and plaintext versions is on par with (or better than) the published results of SIGMA (Gupta et al., 2024), SHAFT (Kei and Chow, 2025) and MosFormer (Cheng et al., 2025). Therefore, the small token-level perturbations raised by the reviewer do not degrade downstream utility in practice. The new Section 8.3 and Table 16 present the experimental results obtained under the task-head isolation protocol; corpus and window settings are disclosed in the new Section L.5 and the table footnotes. In addition, we have briefly summarized this finding in the abstract.

We will update the revised manuscript on OpenReview with these additions and associated artifacts at a later time.

References:

  • K. Gupta, N. Jawalkar, A. Mukherjee, N. Chandran, D. Gupta, A. Panwar, and R. Sharma. SIGMA: Secure GPT Inference with Function Secret Sharing. PoPETs 2024(4):61-79, 2024.
  • A. Y. L. Kei and S. S. M. Chow. SHAFT: Secure, Handy, Accurate, and Fast Transformer Inference. NDSS 2025 (ePrint 2025/2324).
  • K. Cheng, Y. Xia, A. Song, J. Fu, W. Qu, Y. Shen, and J. Zhang. MosFormer: Maliciously Secure Three-Party Inference Framework for Large Transformers. ACM CCS 2025.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.