acceptodds
Under review as a conference paper at ICLR 2027

SilentWood: Efficient Private Inference Over Gradient Boosting Decision Forests

Abstract

Gradient boosting decision forests, used by XGBoost or AdaBoost, offer higher accuracy and lower training times than decision trees on large datasets. Private inference protocols for decision trees can preserve both input and tree privacy. However, naively extending them to decision forests by replication leads to impractical running times. In this paper, we propose an efficient private decision inference protocol using homomorphic encryption. We present several optimizations that identify and remove (approximate) duplication between trees, significantly reducing communication and computation costs over the naive approach. We present the private inference protocol for highly scalable gradient boosting decision forests. Our protocol (SilentWood) is faster than parallel RCC-PDTE by up to 42.5x, Zama's Concrete ML XGBoost by up to 27.8x, and SoK-GGG's two-party garbled circuit protocol by 2.94x.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Privacy-preserving Machine Learning

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_AXnQOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents SilentWood, a BFV-based protocol for private inference over gradient-boosted decision forests that aims to protect client inputs and the server’s model. It combines node clustering to reuse comparisons, client-assisted Blind Code Conversion (BCC) for efficient SumPath-based score aggregation, and input encoding compression with homomorphic decompression. Evaluated on XGBoost models across 13 UCI datasets, SilentWood reduces average latency from 193.43 to 5.41 seconds relative to an RCC-PDTE-derived baseline under the CPU, 32-bit, 50 ms RTT setting, reporting a 35.7× speedup. The incremental ablation attributes the largest gain to BCC.

Critical strengths
  1. SilentWood addresses meaningful bottlenecks in private ensemble inference: redundant comparisons across trees, expensive score aggregation, and communication overhead from repeated SIMD encodings. Its three complementary techniques form a coherent system for extending private single-tree evaluation to boosted ensembles.

  2. BCC trades one additional round trip relative to noninteractive evaluation for reduced homomorphic computation, converting SumPath outputs into indicators for weighted score aggregation and avoiding MultiplyPath’s path multiplication overhead. Table 3 shows that adding BCC reduces average latency from 193.43 to 10.03 seconds, making it the largest contributor in the incremental ablation. Under the stated prime-field, depth, and masking assumptions, the plaintext-level argument that false-path costs remain nonzero is sound.

  3. The evaluation examines latency, communication, memory consumption, CPU/GPU execution, network conditions, model size, and validation-set size. Component ablations help explain the sources of improvement. For example, Table 10 reports that compression reduces average communication from 85.75 MB to 15.20 MB in the 32-bit setting, while Table 11 reports approximately 241 ms of average decompression overhead.

Critical weaknesses
  1. The security assumptions are not clearly connected to the evaluated implementation. Appendix D requires ciphertext sanitization for model privacy and an applicable funcCPA-secure instantiation or sanitization-based construction for input privacy against malicious servers. However, the implementation does not specify how these requirements are satisfied or whether their overhead is included. The authors should establish that the benchmarked system provides the claimed guarantees.

  2. Dataset preprocessing is insufficiently documented. Table 13 lists Steel with 33 features and two classes, whereas the original UCI dataset has 27 features and seven fault types; PenDigits is also listed as binary without explaining the transformation from ten classes. Steel’s feature count warrants checking whether other fault-indicator columns were retained as inputs. Exact feature lists and label mappings are needed; the manuscript alone does not establish label leakage.

  3. Accuracy-preservation claims exceed the evidence. Validation-based acceptance does not guarantee unchanged test accuracy. Relative to s=0s=0, Table 4 shows Breast decreasing from 0.67 to 0.59 at higher clustering intensities and Defect decreasing from 0.82 to 0.80 at the default setting. The authors should distinguish correct evaluation of the modified model from preservation of predictive quality and report paired per-dataset results across multiple random splits.

  4. Stronger, controlled comparisons are needed. The paper does not report measured SoK-GGG results on the same clustered models, leaving model-optimization and protocol benefits entangled. Section 5 also mischaracterizes BPDTE-CW, which introduces adapted SumPath rather than simply relying on MultiplyPath. Same-model comparisons and a matched adapted-SumPath or bounded-domain zero-testing baseline would better establish BCC’s advantage.

Questions for authors
  1. Does the evaluated implementation sanitize the intermediate and final ciphertexts as required for model privacy in Appendix D? Which algorithm and security parameters are used, and is the overhead included in the reported latency? Separately, how does the concrete BFV instantiation satisfy the conditions for input privacy against malicious servers?

  2. What are Steel’s 33 input columns, and how are the binary tasks for Steel, PenDigits, and Satellite constructed? Please confirm that fault-indicator target columns are excluded from Steel’s inputs and that all methods use identical preprocessing, label definitions, and actual train/validation/test partitions.

  3. Given the accuracy decreases in Table 4, can you report paired test accuracy, variability, and latency for the original and modified models, isolating the effects of approximate clustering and leaf-value reoptimization? How much of SilentWood’s advantage remains when SoK-GGG evaluates the same modified model under comparable precision and security settings?

1 comment

We appreciate your exceptionally careful review of a technically challenging topic. Our focus had been on the security side, and your scrutiny of the data and evaluation (down to the column level) strengthened a part of the paper we had paid less attention to. The issues raised were real, and addressing them has made the paper stronger.


Q1. Is ciphertext sanitization implemented and evaluated? Explain how to handle a malicious server, and report the used security parameters.

Yes, it is. We provide an answer to this question in Q1 of the global comment section (Common Questions from Reviewers).


Q2. Dataset preprocessing (Steel, PenDigits, Satellite).

All 13 datasets were downloaded from OpenML and used exactly as distributed, with no manual feature selection. The differences from the UCI descriptions you pointed out arise because the three files in question are OpenML variants, not the UCI originals: PenDigits (OpenML 1019) and Satellite (40900) are binarized and anomaly detection versions, and Steel (1504, v1) is a binarized version that keeps the six fault indicators as input features rather than output classes (OpenML's later version 40982 removes them). We will add the OpenML IDs, feature lists and label mappings to Table 13.

Steel. OpenML 1504 contains the 27 UCI features (V1–V27) plus the six fault type indicators V28–V33 (Pastry, Z_Scratch, K_Scatch, Stains, Dirtiness, Bumps) as features, and uses the seventh fault type, Other_Faults, as the binary label. Since every plate has exactly one fault type, Other_Faults = 1 exactly when V28–V33 are all zero, so the label is a deterministic function of the inputs, which explains the 1.00 accuracy. You are right that the submitted Steel results used these indicators as inputs. We have removed V28–V33 and rerun Steel:

Steel, original (OpenML)Steel, corrected (V28–V33 removed)
Features3327
Classes22
Nodes, before → after clustering184 → 41 (−77.7%)1,055 → 446 (−57.7%)
Accuracy, before → after clustering1.00 → 1.000.80 → 0.80
SilentWood latency (RTT 50 ms, 1 Gb/s)1.758 s1.862 s
Communication2.49 MB2.49 MB

The corrected model has normal size and accuracy while latency and communication are essentially unchanged, so our conclusions stand. We will update every Steel entry in the paper accordingly.

PenDigits. OpenML 1019: the majority digit is labeled "P" (positive, 1,144) and the other nine digits "N" (9,848). The 16 pen trajectory features are unchanged.

Satellite. OpenML 40900 (Goldstein & Uchida, 2016): the four soil classes of Statlog Landsat are labeled Normal (5,025) and 75 samples from the two crop classes Anomaly. The 36 spectral features are unchanged.

Identical pipeline. One script makes the stratified 60/20/20 split and trains, quantizes and exports the XGBoost forest. Baseline, SoK-GGG and SilentWood evaluate this forest on the same test rows. Zama's Concrete ML trains on the same training rows and hyperparameters. The splits were unseeded. We now fix the seed and will release the split indices.


Q3-A. Further analyze node clustering’s effect on accuracy and explain how to better-preserve accuracy.

Due to space limit, please read our answer to Q2 of reviewer PbPj, who asked the same question.


Q3-B. Compare SilentWood's runtime performance (inference latency) with and without using node clustering. Also, compare SilentWood's runtime performance against SoK-GGG without using node clustering.

(a) Inference latency of the original vs. node-clustered model. This is already illustrated in Table 3 (ablation): the Base+B column evaluates the original forest and Base+B+K the clustered one, with everything else identical, so their difference (10.03s → 6.33s on average) is the latency effect of the model change alone (threshold clustering with leaf re-optimization, always applied jointly).

(b) Protocol-only comparison with SoK-GGG. We remove node clustering from SilentWood so both systems evaluate the identical original forest (32-bit).

Benchmark50ms100ms200ms
Spam5.25.97.6
Steel2.53.35.1
Breast2.12.64.3
Heart4.45.06.6
Defect8.28.810.3
Bank12.012.414.0
PenDigits2.93.45.0
Ailerons10.611.212.8
Credit1.82.53.9
Satellite2.12.84.3
Elevators11.311.513.1
Telescope1.62.23.8
MFeat12.212.514.6
AVG.5.96.58.1
SoK-GGG (Table 5)9.8813.7922.43
Our Speedup1.67×2.13×2.77×

On the original (non-clustered) model, SilentWood stays 1.67–2.77× faster than SoK-GGG (50–200 ms RTT) with malicious-server privacy vs. SoK-GGG's semi-honest model. Of the 1.83× speedup in Table 5 (50 ms), 1.67× is the protocol and 1.10× node clustering, whose gain is smaller than in Table 3 because compression already batches RR thresholds per operation.

p.s. BPDTE-CW uses adapted SumPath (not MultiplyPath). We'll fix §5.

Reviewer_mzmBOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents SilentWood, a framework for private inference over gradient-boosted decision forests using packed homomorphic encryption. Its main components are node clustering to reduce redundant comparisons, Blind Code Conversion (BCC) to replace expensive homomorphic path multiplication with client-assisted conversion of masked path costs into encrypted selection indicators, and ciphertext compression to reduce the size of ciphertext. It reports substantial efficiency improvements in the evaluated settings.

Critical strengths

The framework addresses several important bottlenecks in private forest inference, including repeated comparisons, expensive homomorphic path evaluation, and ciphertext communication. The ablations provide useful evidence that the individual optimizations contribute to the reported gains.

Critical weaknesses

The novelty of BCC requires clearer justification. Its core ingredients path-cost summation, random masking, permutation, and client-side zero testing — already appear in earlier private decision-tree protocols. For example, Tai et al. ("Privacy-Preserving Decision Trees Evaluation via Linear Functions," ESORICS 2017) let the client decrypt randomly masked and permuted path costs and test them for zero in the clear. Please explicitly distinguish BCC from these constructions and articulate what is technically new, particularly the re-encryption of the zero-test indicators and the mechanism enabling private forest aggregation.

BCC trades reduced homomorphic computation for additional communication and client-side processing, introducing an extra round trip into an otherwise non-interactive HE evaluation. This makes comparisons with recent interactive HE–secret-sharing protocols particularly relevant—for example, Kangaroo (NDSS 2026), which is discussed in the related work but not evaluated experimentally. Please include representative baselines from this class under matched network conditions, characterize the trade-off across different RTTs and bandwidths.

The privacy implications of ciphertext compression require clarification. Does the client need to know the repetition factor for the compression to work? If the repetition factor reflects the maximum number of comparisons involving a feature, revealing it would leak model-dependent structural information. Please clarify whether this factor is determined by public parameters, or whether it constitutes additional leakage that should be explicitly captured in the security definition.

Some typos: “speeedup” → “speedup” (L422), “By contract” → “By contrast” (L1332–1333), and “et. al.” → “et al.” (L357). The citation “(fip (2025)” at L470 is malformed, and the two sentences about independent rotations and balanced reduction are repeated at L970–973.

Some omitted related-work:

[1]Tai et al., “Privacy-Preserving Decision Trees Evaluation via Linear Functions” (ESORICS 2017).

[2]Malik et al., “Vectorized Secure Evaluation of Decision Forests” (PLDI, 2021).

[3]Wu et al., “Privately Evaluating Decision Trees and Random Forests” (PoPETs 2016).

[4]Bost et al., “Machine Learning Classification over Encrypted Data” (NDSS 2015).

Questions for authors

What precisely distinguishes BCC from prior protocols that reveal randomly masked and permuted path costs to the client for zero testing? Which additional technical challenges are resolved by re-encrypting the resulting indicators and aggregating forest outputs?

Can you provide a comparison with Kangaroo (or other SS-HE hybrid scheme) under matched model, precision, hardware, and network settings?

Does compression require the client to know the repetition factor or other model-dependent packing metadata?

How is the ciphertext-sanitization assumption in the security analysis implemented, and is its computational and communication overhead included in the reported results?

3 comments

We appreciate your detailed feedback that sharpened our own account of what BCC contributes.


Q1. What is BCC's technical novelty over prior protocols that use masked path values such as Tai et al.?

We don't claim that using masked path values is our contribution. Masking a tree's path cost by a random non-zero scalar and letting the client test for zero is a generic primitive: Tai et al. use it over ElGamal, and RCC-PDTE uses it as a building block, and so do we. Our true contribution is what sits around this primitive once the path values live in SIMD-packed FHE ciphertexts: making the slot-allocated values information-theoretically uniform and cost-free.

In Tai et al., this problem does not arise because they don't use SIMD-packed FHE. ElGamal holds one value per ciphertext, so hiding the path order is a matter of reordering a list of ciphertexts, and hiding nothing else is possible: the client necessarily sees one ciphertext per leaf, exactly one of which decrypts to zero. In contrast, in BFV, the path values of an entire forest are packed into the slots of one ciphertext, and the client decrypts the whole vector at once. Thus, hiding the tree structure requires a uniformly random permutation of slots, which is expensive in FHE, because a permutation network costs O(N log N) rotations after packing. BCC removes this cost entirely: merging ℓ SumPaths into one ciphertext already requires rotating each path value into its own slot. Thus, we simply choose those target slots at random, so the permutation is absorbed into the merge that must happen anyway. Dummy 0s and non-0s then pad the ciphertext to a fixed public distribution (fzerof_{zero} zeros and N−fzeroN-f_{zero} non-zero random values), so the decrypted vector is independent of the model (Lemma D.1). Hence, neither the number of trees nor the number of paths is revealed, which no unpacked scheme (like Tai et al.) can efficiently achieve.

The second phase of BCC is what the client does with the masked SumPath values. Rather than reading off a leaf value as in Tai et al., the BCC client re-encrypts the remapped 0/1 indicator array and returns it to the server. Then, the server multiplies it by the slot-aligned leaf scores and sums them homomorphically. This resolves two critical problems that Tai et al. cannot solve: (a) model confidentiality and (b) reducing client computation.

(a) Model confidentiality. A Tai-style zero test over a forest shows the client one message per node and leaf and one zero per tree, so node and leaf counts and every tree's score leak. The SoK (App. B.2) hides these with dummy comparisons and affine aggregation, but each dummy is a real client-assisted comparison, so hiding size inflates client work and traffic by the padding ratio. In BCC, the padding fills SIMD slots that are otherwise empty, so hiding T and ℓ costs nothing, and the aggregation runs on the server with no extra round. The node count stays hidden because all comparisons run on the server.

(b) Reducing client computation. In Tai et al., the client takes part in every comparison involving heavy computation. It performs one decryption per bit of every decision node, so its work grows with the node count and bit size. In contrast, the BCC client only needs to decrypt one or two packed ciphertexts holding the SumPaths of the whole forest, map each slot to 0/1, and re-encrypt them. In our tests, Tai's client takes 1.9 s on our 100-tree Spam model, whereas SilentWood's client takes under 0.1 s regardless of model size. This low client-side cost makes SilentWood suitable for resource-constrained clients such as smartphones.


Q2. Evaluate SilentWood’s performance against Kangaroo.

Our evaluation results are provided in Q2 of the global official comment (Common Questions from Reviewers).


Q3. In compression, does the repetition factor leak model information?

No. The repetition factor R is determined by three quantities only: the number of features n, the feature bit length b, and the number of ciphertext slots N. All three are public and carry no information about the XGBoost model. Concretely, each CW encoded comparison occupies 2b+1 slots in one of the two N/2 slot rows, so R = ⌊(N/2)/((2b+1)n)⌋ (e.g., R = 4 for 32-bit Breast, and R = 2 for 32-bit Spam at N = 2142^{14}). The number of compressed ciphertexts the client sends, ⌈⌈m/2⌉/R⌉ with m the CW code length (64 at 32 bits), is likewise fixed by (n, b, N). Hence, the client's message is identical for every model with the same n and b. If a feature has q > R thresholds, the server runs ⌈q/R⌉ comparison batches on the same decompressed ciphertexts, so the number of comparisons per feature is unbounded and costs the client nothing.


Q4. Is ciphertext sanitization implemented & evaluated?

Yes. We provide an answer to this question in Q1 of the global comment section (Common Questions from Reviewers).

p.s. We'll fix the typos and add the related works you mentioned.

Reviewer_mzmBOpenReview ↗

response to rebuttal

Thank you for the clarifications. However, I remain unconvinced that the rebuttal sufficiently addresses the following concerns. I acknowledge the SIMD-specific efficiency benefits described in the rebuttal. However, absorbing slot randomization into packing, padding the resulting vector, and re-encrypting zero-test indicators appear primarily to adapt and combine existing techniques. The response does not sufficiently establish the technical novelty of BCC beyond the masked-path zero-testing primitive already used in prior work. This remains a substantive concern about the paper’s contribution.

L1165–1167 describe repetition in terms of the model’s maximum number of comparisons per feature, whereas the rebuttal specifies a factor determined solely by public parameters. These descriptions should be reconciled and the manuscript revised accordingly. Moreover, under the rebuttal’s formula, Bank appears to require fewer uploaded ciphertexts than Defect, yet Table 10 reports higher communication for Bank at 32 bits (17.5 MB versus 10.0 MB). Please provide a communication breakdown explaining this discrepancy and confirm which repetition-factor setting was actually evaluated.

With (s=30) and flooding performed after modulus switching to the last RNS level, it remains unclear whether the remaining ciphertext modulus can accommodate the flooding noise while preserving correct decryption. Please clarify whether bootstrapping is required before flooding and whether any resulting overhead is included in the evaluation.

We appreciate your follow-up questions. We answer the three points as follows.


Q1. What is BCC's novelty beyond masked-path zero-testing?

BCC's novelty is making zero-testing on a SIMD-packed forest model-private, at the cost of one plaintext addition.

We agree each ingredient exists in prior work and claim no new primitive. But Tai's zero-test, applied to a SIMD-packed forest, leaks the model four ways: (1) The client gets one value per leaf, so it learns the number of paths. (2) It finds one zero per tree, so it learns the number of trees. (3) It reads the leaf value at each zero, so it learns every tree's score, which can help reconstruct each tree. (4) SIMD slots cannot be reordered for free the way Tai reorders its ciphertexts, so the positions of 0 expose the selected leaves.

BCC removes all four leaks. The server puts each path in a random slot while merging (without extra rotation) and pads with dummies to a fixed public distribution by a single plaintext addition into the same ciphertext (unlike SoK, where each dummy adds a client-assisted comparison), so the decrypted vector looks the same for every model (Lemma D.1). The client reads no leaf value and returns only encrypted 0/1 indicators. The server multiplies them by a score array in the same permutation, 0 at dummy slots, so only the total score is revealed.

We will clarify the contribution statement of BCC as this composition and its analysis, not as a new zero-testing technique. Such protocol-level composition is also the contribution type of recent private-inference work, which introduces no new cryptographic primitive but arranges known ones for a specific workload and validates the design end-to-end, e.g., Nimbus [1] (outer-product matrix multiplication and low-degree polynomial approximation on existing 2PC), Encryption-Friendly LLM Architecture [2] (LoRA and Gaussian-kernel attention adapted to an existing HE scheme), and Kangaroo [3] (SIMD tree packing with masked comparison and client-aided path evaluation on BFV).

[1] Li et al. Nimbus: Secure and Efficient Two-Party Inference for Transformers. NeurIPS 2024.

[2] Rho et al. Encryption-Friendly LLM Architecture. ICLR 2025.

[3] Xu et al. Kangaroo: A Private and Amortized Inference Framework over WAN for Large-Scale Decision Tree Evaluation. NDSS 2026.


Q2. Is the compression's repetition factor model-dependent? Why does Bank cost more than Defect in Table 10?

(a) Reconciliation on the repetition factor R. The client never uses a model-dependent number to determine RR. With compression, R=⌊(N/2)/((2b+1)n)⌋R=\lfloor(N/2)/((2b+1)n)\rfloor from the public parameters (N,b,n)(N, b, n), where NN is the polynomial degree, bb is the feature bit size, and nn is the number of features. Meanwhile, the server-side model's maximum number of comparisons per feature, ww, only determines the number of batches that the server evaluates locally. L1161–1167 are a toy example with w=3w=3 that illustrates why repetition is needed, not how RR is computed. We will clarify this in L1161–1178.

(b) Bank vs. Defect. The discrepancy comes from an error in Table 13 (dataset description), where the Defect and Bank columns are swapped. Defect has 21 features and Bank has 32 features. Thus, with the correct nn, Bank uploads more ciphertexts than Defect, not fewer:

32-bitnRUploaded ciphertexts C=⌈32/R⌉C=\lceil32/R\rceilQuery, client→server (MB)BCC, server→client (MB)BCC, client→server (MB)Response, server→client (MB)Total (MB)
Defect21667.90.521.310.2610.0
Bank3231114.40.521.310.2616.5

Table 10 lists 17.5 MB for Bank, which is a typo for 16.5 MB. This typo overstated our communication cost and we'll correct it.

(c) Evaluated setting. The public-parameter RR is what we evaluated. Every row of Table 10 follows total ≈ 1.31·C + 1.83 MB (+0.26 MB per extra BCC ciphertext), e.g., Telescope (n=11,R=11,C=3)(n=11, R=11, C=3) 5.8 MB, Heart (n=13,R=9,C=4)(n=13, R=9, C=4) 7.1 MB, Spam (n=57,R=2,C=16)(n=57, R=2, C=16) 22.8 MB and MFeat (n=64,R=1,C=32)(n=64, R=1, C=32) 43.8 MB. We will correct Table 13 and add this breakdown to §F.2.


Q3. Does flooding at s=30s=30 fit in the last RNS level without bootstrapping?

Yes, bootstrapping is not needed, and flooding at s=30s=30 fits in the last 60-bit prime. With the 22-bit plaintext modulus pp, the headroom is log⁡2(qlast/2p)≈37.2\log_2(q_{\mathsf{last}}/2p) ≈ 37.2 bits. After modulus switching, the noise of the returned ciphertext plus the fresh Enc(0) sits at the rounding floor (at most 27.82^{7.8} per coefficient, i.e., 30 bits of noise budget). With the noise bound B=28B=2^8 and up to D=3D=3 ciphertexts decrypted by the client per inference, the formula gives σ=2s/2B24ND=233.1σ=2^{s/2}B\sqrt{24ND}=2^{33.1}, which is below the 237.22^{37.2} headroom. All our evaluated results preserve correctness (i.e., same prediction scores as plaintext models). Sanitization takes under 1 ms per ciphertext online, with no extra round or change in ciphertext size, and this overhead is included in our evaluation.

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

This paper presents SilentWood, an efficient privacy-preserving inference protocol for gradient-boosted decision forests based on fully homomorphic encryption. It introduces three techniques: (1) node clustering, which consolidates similar feature-threshold comparisons across trees while recalibrating leaf values; (2) Blind Code Conversion (BCC), which enables efficient encrypted score aggregation by converting masked SumPath values into path indicators with client assistance; and (3) ciphertext compression, which reduces redundant feature encoding and communication overhead.

The authors evaluate SilentWood on 13 UCI datasets against RCC-PDTE-based inference, Concrete ML, and SoK-GGG. The experiments cover inference latency, communication costs, model accuracy, network conditions, and CPU/GPU execution. The results report substantial efficiency improvements, with an average 35.7× speedup over the FHE baseline in the default 32-bit CPU setting.

Critical strengths
  1. A technically meaningful approach to efficient encrypted score aggregation.

  2. Substantial efficiency gains supported by multiple experimental settings.

Critical weaknesses
  1. The claimed security guarantees are not clearly established for the evaluated implementation.

The paper adopts a threat model involving a semi-honest client and a malicious server. However, Appendix D makes the security argument conditional on additional cryptographic properties, including funcCPA security or ciphertext sanitization. The proof for the corrupted-client case also assumes sanitized ciphertexts.

  1. The evaluation does not fully establish the accuracy-efficiency tradeoff or the comparative advantage over recent forest-specific protocols.

Node clustering modifies the underlying model, and the proposed accuracy-preserving procedure accepts modifications based on validation accuracy. However, this does not guarantee preservation of test accuracy. For example, Table 4 reports that Breast accuracy decreases from 0.67 at s=0 to 0.59 at s=1. The unchanged rounded average accuracy obscures such dataset-specific degradation.

Questions for authors

Q1. Security assumptions and implementation. Does the evaluated implementation satisfy the funcCPA or ciphertext-sanitization conditions required by Appendix D? If sanitization is used, is its computational and communication overhead included in the reported results? Please also specify the concrete FHE parameters and their estimated security levels. This clarification is important for assessing whether the reported efficiency is achieved under the advertised threat model.

Q2. Accuracy preservation. Could the authors clarify the scope of the accuracy-preserving guarantee and reconcile it with the dataset-specific decreases in Table 4, particularly the Breast dataset? Reporting per-dataset accuracy differences and prediction disagreement rates between the original and clustered models would help establish the actual utility cost of clustering.

Q3. Comparison with Kangaroo(NDSS26). Given that Kangaroo directly addresses scalable private decision tree ensemble inference, could the authors provide a matched experimental comparison, if feasible, or a quantitative explanation of the differences in latency, communication, security assumptions, and applicable settings? This would help assess SilentWood's advantage over the most relevant recent alternatives.

1 comment

Thank you for engaging so carefully with a narrow and technically demanding topic. Each of your three questions (the gap between Appendix D and our implementation, the Breast row of Table 4, and the comparison with Kangaroo) led to a concrete improvement.


Q1. Does your design and evaluation satisfy funcCPA and ciphertext sanitization?

Yes. We provide an answer to this question in Q1 of the global comment section (Common Questions from Reviewers).


Q2. Further analyze node clustering’s effect on accuracy and explain how to better-preserve accuracy.

(a) Clustering is validation-gated at a fixed intensity s. A merge within the range set by s is kept only if validation accuracy (20% split) does not decrease; s is never tuned on test. Two things should be kept apart. (1) The protocol is exact: encrypted inference returns the same prediction as running the clustered forest in the clear. (2) The clustered forest itself may predict differently from the original forest: validation gating rules out any loss on the validation split, and the remaining difference on the test split (the generalization gap) is what we measure in (c) below.

(b) The "Breast" row in Table 4. This row is incorrect, and we thank the reviewer for flagging it. Owing to a dataset-naming error (Breast vs Breast cancer), it was computed on a 50-sample subset of the original Breast dataset instead of the full 569-sample dataset listed in Table 13. That is, the forest trained on only ~37 rows has only 11 distinct thresholds, so one merge moves many predictions. This explains why the baseline accuracy is only 0.67 (close to the 0.5 random prediction chance) and why the accuracy unstably shifts across s. On the full 569-sample dataset, the correct measurement becomes

s=00.010.050.10.20.40.61
Breast0.950.950.950.950.950.950.950.95

with distinct comparisons reduced from 97 to 56 at s = 0.2. We will update the row in Table 4 (and every other Breast entry) with these results.

(c) Utility cost at s = 0.2. Since s = 0.2 is our default (§4, Figure 9), we measured for all 13 datasets, over five random 60/20/20 splits, the paired test-accuracy change (i.e., clustered accuracy subtracted by original accuracy on each same row; mean ± s.d.) and the disagreement rate between both models:

DatasetΔ AccuracyDisagreement
Spam−0.3±0.4%2.9±0.5%
Steel−1.7±0.9%8.7±1.4%
Breast−0.7±1.7%2.5±1.9%
Heart−1.7±3.2%20.7±3.3%
Defect−0.4±0.5%1.3±1.0%
Bank−1.3±0.9%8.4±1.7%
PenDigits−0.2±0.2%0.4±0.1%
Ailerons−0.7±0.4%3.9±2.1%
Credit−0.0±0.0%0.0±0.0%
Satellite−0.1±0.1%0.1±0.1%
Elevators+3.8±0.8%14.4±1.2%
Telescope+0.0±0.0%0.1±0.1%
MFeat−2.3±2.0%6.7±1.0%
AVG.−0.4%5.4%

Across 65 paired comparisons (13 datasets × 5 splits), clustering removes 50% of distinct comparisons for a mean accuracy change of −0.4%; eight datasets move by less than 1% and Elevators gains 3.8% from leaf re-optimization. Defect's −0.02 in Table 4 was a single split; over five it is −0.4 ± 0.5%. Steel (−1.7%), Bank (−1.3%) and MFeat (−2.3%) lose accuracy on nearly every split: merges harmless on validation hurt on test, which the gate cannot see. Users who cannot afford a 1% accuracy drop can lower s.

Disagreement (5.4%) is much larger than |Δ accuracy| (0.4%) because most changed predictions cancel out: clustering only moves test rows whose score lies near the decision boundary, and those rows are the ones either forest gets wrong about half the time, so flipping them swaps errors rather than adding them. This is why disagreement peaks on the low-margin datasets Heart (59 test rows, five classes) and Elevators, whose labels are a thresholded continuous target so many samples sit near the boundary.


Q3. Evaluate SilentWood’s performance against Kangaroo.

Our evaluation results are provided in Q2 of the global comment section (Common Questions from Reviewers).

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

This paper proposes SilentWood, an efficient privacy-preserving inference framework for gradient boosting decision forests. The framework combines three techniques: node clustering to reduce redundant comparisons across trees, Blind Code Conversion (BCC) to enable efficient score aggregation without expensive ciphertext-ciphertext multiplications, and ciphertext compression to reduce communication overhead. Experiments on 13 UCI datasets demonstrate substantial inference speedups over existing FHE- and MPC-based approaches.

Critical strengths
  1. Effective and well-motivated optimization techniques. The paper identifies clear computational and communication bottlenecks in private inference over gradient boosting forests. In particular, BCC provides an interesting solution to the trade-off between SumPath's low multiplicative depth and MultiplyPath's compatibility with score aggregation.

  2. Substantial performance improvements and comprehensive evaluation. SilentWood demonstrates significant inference speedups across 13 datasets. The ablation study (Table 3) shows that BCC alone provides a 19.3x speedup over the baseline, while node clustering and ciphertext compression further improve efficiency. The paper also evaluates different tree counts, depths, network conditions, and hardware configurations.

Critical weaknesses

W1. Unclear correspondence between the security proof and the actual implementation.

The paper claims privacy against a malicious server and a semi-honest client. However, the security analysis in Appendix D requires additional properties beyond standard CPA-secure BFV, such as funcCPA-security or ciphertext sanitization.

Although the implementation uses Microsoft SEAL and PhantomFHE, it is unclear whether the required security properties are satisfied by the implemented configuration. In particular, the paper does not explicitly describe whether ciphertext sanitization or other necessary modifications are implemented, or whether their computational overhead is included in the evaluation.

Since privacy preservation is a central requirement, the authors should clarify how the implemented protocol satisfies the assumptions of the security proof.

W2. Limited validation of the accuracy-preserving node clustering.

Node clustering modifies the original decision thresholds and re-optimizes leaf values. The proposed validation-based merge criterion prevents decreases in validation accuracy, but does not guarantee that the original model's predictions or test accuracy are preserved.

Indeed, Table 4 shows that test accuracy decreases for some datasets as clustering intensity increases. For example, accuracy on the Breast dataset decreases from 0.67 to 0.59 at higher clustering intensities.

The paper would benefit from a more explicit distinction between preserving validation accuracy and preserving the original model's inference behavior. An analysis of prediction-level agreement with the original forest and the accuracy-efficiency trade-off would strengthen this contribution.

W3. Insufficient evaluation of BCC scalability under larger forest configurations.

The scalability of BCC appears to depend on the number of tree paths that can be packed into a ciphertext while maintaining the fixed zero/non-zero distribution required for privacy.

Specifically, Lemma D.1 requires:

  • T≤fzeroT \leq f_{\mathrm{zero}}

  • ℓ−T≤N−fzero\ell - T \leq N - f_{\mathrm{zero}}

where TT is the number of trees, ℓ\ell is the total number of paths, and NN is the number of ciphertext slots.

For example, with N=16,384N=16,384, a 1:1 zero/non-zero distribution, and T=100T=100, these conditions permit at most 8,292 paths in one ciphertext. However, 100 complete binary trees of depth 7 could contain 12,800 leaf paths.

Although the actual trained forests may contain fewer paths, the paper does not sufficiently explain how the protocol handles configurations that exceed this capacity. In particular, it is unclear whether multiple ciphertexts are required and how this affects the number of communication rounds, computational overhead, and privacy guarantees.

Given that scalability to large decision forests is one of the paper's central claims, a more comprehensive evaluation across different total path counts and ciphertext capacities is necessary.

W4. Limited comparisons with recent forest-specific private inference methods.

The evaluation includes RCC-PDTE, Zama Concrete ML, and SoK-GGG, demonstrating substantial performance improvements. However, the largest speedups are obtained against a baseline that extends private single-tree evaluation to forests.

More recent approaches specifically designed for large-scale private tree ensemble inference, such as Kangaroo [1] (NDSS 2026), are discussed in the related work but not included in the experimental comparison.

I acknowledge that Kangaroo adopts a different threat model and focuses on amortized inference. Nevertheless, a quantitative comparison of inference latency, communication costs, supported forest sizes, and privacy guarantees would help establish the practical advantages of SilentWood.

Additionally, the comparison with Zama uses different input precisions (14-bit versus 16/32-bit). The implications of this difference for performance comparisons should be discussed more explicitly.

Overall, the current evaluation demonstrates strong improvements over the selected baselines, but does not fully establish SilentWood's advantages over recent methods designed specifically for scalable private forest inference.

Reference

[1] Xu, W., Zhu, H., Zheng, Y., Bian, S., Sun, N., Yuan, H., Feng, D., and Li, H. (2026). Kangaroo: A Private and Amortized Inference Framework over WAN for Large-Scale Decision Tree Evaluation. Proceedings of the Network and Distributed System Security Symposium (NDSS 2026).

Questions for authors
  1. Security guarantees: Does the implemented BFV configuration satisfy the funcCPA-security requirement, or is ciphertext sanitization explicitly implemented? If additional mechanisms are required, are their costs included in the reported inference times?

  2. Model fidelity: How frequently does node clustering change individual predictions relative to the original XGBoost model? Can the authors report prediction agreement and test accuracy across multiple random seeds?

  3. BCC scalability: How does BCC handle forests whose total number of paths exceeds the capacity allowed by the fixed zero/non-zero distribution? How do the resulting computational and communication costs scale?

  4. Recent baselines: Can the authors provide a quantitative comparison with Kangaroo or similar recent forest-specific protocols, accounting for differences in threat models and amortization settings?

  5. Numerical correctness: How are real-valued leaf scores represented and aggregated under BFV? Can the authors clarify the quantization, scaling, and modular overflow conditions required for correct inference?

2 comments

Thank you very much for your positive and constructive feedback to further improve our paper.


Q1. Does the implementation and evaluation include ciphertext sanitization and funcCPA?

Yes. We provide an answer to this question in Q1 of the global comment section.

Q2. How often does node clustering change predictions, and how do agreement and accuracy vary across seeds?

Due to space limit, please read our answer to Q2 of reviewer PbPj, who asked the same question.


Q3. How does BCC handle more paths than what one ciphertext can hold?

BCC is not limited to one ciphertext. When the paths do not fit in one ciphertext, the server uses kk ciphertexts instead of one: it distributes the ℓ masked SumPaths over them (at most N−fzeroN-f_{zero} non-zero paths and fzerof_{zero} zero paths per ciphertext), shuffles their positions, and pads each ciphertext with dummy 0s and non-0s until every ciphertext has the same public distribution (fzerof_{zero} zeros, N−fzeroN-f_{zero} non-zeros). Every ciphertext thus looks the same to the client regardless of the model. k is fixed in advance as a public parameter, like N, so the client learns only a public upper bound on the number of paths (ℓ ≤ kN), not ℓ or TT themselves.

  • Computation cost: The O(ℓ) rotations that merge SumPaths are needed whatever kk is. Each time ℓ exceeds the capacity of one more ciphertext, the additional ciphertext adds one PMult and one PAdd on the server, one decrypt/convert/encrypt on the client, and O(log N) rotations in the final aggregation, so computation grows linearly in ℓ and only marginally in kk.

  • Communication Rounds: All kk ciphertexts travel in the same message, so BCC stays at one RTT (two in total).

  • Network bandwidth usage: With N=214N=2^{14} and the 1:1 distribution, a ciphertext has 8,192 non-zero slots for the false paths and 8,192 zero slots for the true paths (one per tree). Slots not used by real paths are filled with dummies. The largest forest in our evaluation, Elevators (100 trees, depth 7), has 6,521 paths, so every dataset's SumPaths fit in one ciphertext. A second ciphertext adds 0.26 MB for server→client and 0.66 MB for client→server.

  • Model Privacy: Lemma D.1 applies to each ciphertext separately: given the public kk and fzerof_{zero}, each of the k decrypted masked SumPath arrays has exactly the distribution the simulator samples, so the funcCPA argument is unchanged.

  • Evaluation: Multi-ciphertext BCC is already evaluated in Table 8: Elevators with 200 and 300 trees has ≈13,000 and ≈19,500 paths, which the 1:1 distribution spreads over k = 2 and k = 3 ciphertexts, and the deeper (11D/15D) forests likewise exceed one ciphertext. End-to-end latency grows smoothly with the model (8.39s → 10.82s → 14.49s for 100/200/300 trees) with no jump at the ciphertext boundary.


Q4. Evaluate SilentWood’s performance against Kangaroo.

Our evaluation results are provided in Q2 of the global comment section (Common Questions from Reviewers).


Q5. How are real-valued leaf scores quantized and summed in BFV, and when can the sum overflow the plaintext modulus?

In the SilentWood protocol, all arithmetic is in ZpZ_p with pp a 22-bit prime plaintext modulus, and the following three types of values occur:

  • Path Costs: Each tree node's comparison result is either 0/1. Each path's SumPath is either 0 or non-zero random value in [1,p−1][1,p-1]. The client re-maps 0 to 1, and non-zero to 0.

  • Leaf scores: Each real-valued leaf score is quantized to a signed 16- or 32-bit integer vv, scaled so that the sum of all leaves of one class fits in that size. But vv exceeds the 22-bit plaintext modulus, so the server decomposes it into base-282^8 digits, v=v0+28v1+216v2+224v3v=v_0+2^8v_1+2^{16}v_2+2^{24}v_3 with ∣vi∣≤255|v_i|\leq 255, and places each digit in its own plaintext array, slot-aligned with the leaf's SumPath. Negative values use the signed representation of ZpZ_p.

  • Score aggregation: The client returns the encrypted indicator array (1 for a true path, 0 otherwise). The server homomorphically multiplies each indicator sis_i by the four digit arrays [v0,v1,v2,v3][v_0,v_1,v_2,v_3], so only the true leaves' digits survive, and sums each array over all trees, giving [a0,a1,a2,a3][a_0,a_1,a_2,a_3]. These cannot overflow ZpZ_p, because each digit is at most 255 and one leaf per tree contributes, so ∣aj∣≤255T|a_j|\leq 255T. Overflow would need over 8,000 trees. The four sums share four slots of one response ciphertext, so the decomposition costs no extra ciphertext or round. The client decrypts and recombines a0+28a1+216a2+224a3a_0+2^8a_1+2^{16}a_2+2^{24}a_3, the exact sum of the true-path leaf scores, and its sign gives the binary prediction. Multi-class models repeat this per class in separate slot ranges, and the arg-max gives the prediction.

p.s. We ran Zama at 14 bits (not 16/32) because that's the largest precision supported by Concrete ML tree models. But this only makes Zama faster during evaluation.

Thank you for the detailed response. The clarifications on the security implementation (funcCPA via independent re-encryption keys and ciphertext sanitization), multi-ciphertext BCC, numerical representation, and the additional fidelity and Kangaroo comparisons address most of my concerns. I will keep my score of 3.

Since many of these clarifications and corrections (e.g., the security implementation details, the corrected Breast and Steel results, the prediction-agreement analysis, and the Kangaroo comparison) are not yet reflected in the manuscript, uploading a revised version that incorporates them would be very helpful for the final assessment.

Comments on the paper

1 comment
AuthorsOpenReview ↗

[Global Comment]: Common Questions from Reviewers

Q1. Does the evaluated design satisfy funcCPA and ciphertext sanitization?

Yes, we included both. Appendix D mentions them only briefly because they are standard components, not our technical contribution. We'll clarify this.

  • funcCPA: In BCC, the client decrypts the shuffled & padded SumPath array, maps every entry to {0,1}, and re-encrypts the result under an independent key pair used only in the second phase. Thus, the server never sees any ciphertext under the first-phase key pair that depends on a decryption; it receives only a fresh encryption of the 0/1 indicator array under an unrelated key. This is the sanitized decrypt-and-re-encrypt oracle under which Akavia et al. prove funcCPA security of any CPA-secure scheme.

  • Sanitization: SilentWood uses Rényi-divergence flooding (Li et al. 2022). Before returning ciphertexts c₁ and c₂ to the client, the server modulus-switches to the last RNS level, adds a fresh encryption of 0 to re-randomize the polynomial part, and adds a Gaussian noise polynomial with σ = 2s/2B24NQ2^{s/2}B\sqrt{24NQ} (Q: client decryptions, B: noise bound, s=30). Li et al.'s KL bound is scheme-agnostic, and its online cost is two polynomial additions, under 1 ms per ciphertext.

  • Security Parameters: SilentWood's BFV scheme uses polynomial degree 2142^{14}, 420-bit ciphertext modulus, and 22-bit plaintext modulus, which provide more than 128-bit security under the HE Standard (Albrecht et al., 2018).

Thus, the client's input stays private against a malicious server (by funcCPA) and the server's model stays private against a semi-honest client (by sanitization).


Q2. Evaluate SilentWood’s performance against Kangaroo.

SilentWood beats Kangaroo in three aspects: (1) input confidentiality, (2) model confidentiality, and (3) model scaling.

(1) Input confidentiality: Kangaroo is secure only against semi-honest parties (so the client's inputs can be leaked by a malicious server), whereas SilentWood's client privacy is robust against a malicious server.

(2) Model confidentiality: Kangaroo's client decrypts blinded comparison values V = A(x−y)+B whose magnitude grows with the distance to the secret threshold, which leaks model information, whereas SilentWood's client view is independent of the model (Lemma D.1).

(3) Model Scalability: We tested Kangaroo (K) and SilentWood (SW) on the same machine (32-core vCPU with 64GB RAM), for 50ms RTT 100Mb/s, and 200ms RTT 10Mb/s. We measured end-to-end latency (s) and communication size (MB) at XGBoost max_depth D. Our tested Kangaroo pads every tree to a complete binary tree so that it hides tree topology like SilentWood.

[RTT 50 ms, 100 Mb/s (sec)]

DatasetD9 KD9 SWD11 KD11 SWD13 KD13 SW
Spam5.04.513.05.045.04.9
Steel5.24.012.64.344.84.2
Breast3.81.810.51.838.31.7
Heart4.43.510.23.637.03.5
Defect4.47.710.59.238.410.2
Bank3.88.410.99.439.19.8
PenDigits3.42.19.92.134.82.1
Ailerons4.79.213.210.546.010.9
Credit4.11.610.91.639.01.7
Satellite5.62.013.32.044.92.0
Elevators3.810.211.012.238.913.5
Telescope4.01.59.71.535.31.5
MFeat6.27.014.57.050.27.2
AVG4.54.911.65.440.95.6
SW speedup0.9×2.2×7.3×

[RTT 200 ms, 10 Mb/s (sec)]

DatasetD9 KD9 SWD11 KD11 SWD13 KD13 SW
Spam28.214.381.414.830214.7
Steel27.710.081.110.230210.2
Breast26.67.879.17.72967.7
Heart26.57.879.37.92947.9
Defect26.713.079.714.429616.2
Bank26.616.279.117.129717.3
PenDigits26.46.778.26.72926.6
Ailerons27.616.781.518.730319.2
Credit26.57.679.17.62977.7
Satellite28.19.481.49.43029.4
Elevators26.515.879.618.029619.2
Telescope26.45.178.25.12925.1
MFeat28.225.683.525.430625.6
AVG27.112.080.112.529812.8
SW speedup2.3×6.4×23×

[Traffic per query, avg. over 13 datasets (MB)]

D9D11D13
Kangaroo30.694.2356
SilentWood7.98.08.1
SW reduction3.9×11.8×44×

Kangaroo is 8% faster at depth 9 on the fast network (50ms 100Mb/s), but as the depth exceeds 10 or the network slows down (200ms 10Mb/s), SilentWood is faster by 2.2×–23×. This is because Kangaroo's topology-hiding padding increases the traffic size exponentially with depth (30.6 → 94.2 → 356MB), so data transfer dominates latency. In contrast, SilentWood needs no padding to hide tree topology because the server locally computes both comparisons and SumPath aggregation, so the client never sees node-level results, and BCC only needs to pad the total number of paths across all trees to a fixed size. Model scalability is a crucial issue, because many deployed XGBoost models are deep, e.g., depth 16+ for Uber's ETA estimation (Uber Engineering, 2019).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.