Pith. sign in

REVIEW 2 major objections 4 minor 103 references

Preserving Privacy in Software Composition Analysis: A Study of Technical Solutions and Enhancements

T0 review · 2 major / 4 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Software composition analysis can be made private without an accuracy or cost blow-up by sending fewer than 5% of functions through encrypted computation.

desk verdict Solid applied systems paper: the measured 11.8x overhead reduction for MPC-based SCA is real, but the vendor-side privacy guarantee is overclaimed and the evaluation has a tuning-on-the-test-set issue. read the letter →

arxiv 2412.00898 v1 pith:VG5F6HA3 submitted 2024-12-01 cs.SE cs.CR

Huaijin Wang , Zhibo Liu , Yanbo Dai , Shuai Wang , Qiyi Tang , Sen Nie , Shi Wu This is my paper · ORCID
classification cs.SEcs.CR
keywords privacy-preservingsoftwarecompositionanalysismulti-partycomputationcodesimilarityprogramfiltersopen-sourcereuseembeddingsecuresupplychainsecurity
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Software composition analysis (SCA) identifies which open-source components a program reuses, but today's services require uploading the whole codebase to a vendor, exposing proprietary code and the SCA report. The paper argues that multi-party computation (MPC) gives both customers and vendors the strongest privacy protection among the studied options, at the price of a 184-fold slowdown. It then shows that the slowdown is mostly wasted work: three client-side filters, namely symbol matching with call-graph checks, selection of complex source functions, and selection of representative assembly functions, reduce the number of functions sent into encrypted computation to under 5% of the total. On a 14-project benchmark the optimized pipeline runs in 16,527 seconds instead of 195,125 seconds (8.5% of the cost) while achieving F1 0.809, essentially matching the non-private baseline's 0.802. The claim is that practical, accuracy-preserving privacy-preserving SCA is achievable when both sides are semi-honest, meaning they follow the protocol but try to learn from what they see.

What carries the argument

The load-bearing mechanism is the filter-then-encrypt pipeline of SAFE SCA. Three client-side filters decide which functions ever touch CrypTen, the secret-sharing multi-party computation framework that encrypts client tensors and the vendor's embedding model during inference. The symbol filter first rules out functions copied from OSS projects by matching complex function names and requiring the matched functions to share the same call-graph edge, reaching F1 0.547 on its own; the informative source function filter keeps only functions with the lowest maintainability indices; and the assembly function filter selects disassembled functions whose names occur in the OSS database while down-weighting very long functions. The net effect is a regression of y = 0.048x + 77 selected functions versus x total functions, i.e., under 5% of functions carry the entire encrypted workload.

What would settle it

Have a client issue queries over a much larger fraction of the OSS database and train a stand-in embedding model on the downloaded vectors paired with public OSS source code, then measure whether the stand-in reaches the plaintext model's F1 of about 0.802. If it does, the claim that the vendor's database is protected 'without sacrificing privacy' is false for the vendor.

Watch

Extended reading notes

Core claim

The central discovery is that the cost of MPC-based SCA is not a fixed tax: it scales with the number of functions sent through the cryptographic protocol, and most functions do not need to be sent at all. By filtering on the client side before encryption, matching complex symbols plus call-graph edges, keeping only low-maintainability source functions, and keeping only assembly functions whose names appear in OSS projects and whose basic-block counts are tractable, the proposed SAFE SCA pipeline encrypts only about 4.8% of the input functions. The paper reports that this brings end-to-end SCA time from 195,125 seconds to 16,527 seconds on a 14-project dataset, while F1 rises slightly to 0.809 from the unfiltered version's 0.791 and compared with 0.802 for the non-private CENTRIS(DPCNN). The same experiments show the SBB-based alternative leaks the SCA report to a curious server, so MPC remains the only studied approach that protects both the customer's code and the vendor's database and model.

Load-bearing premise

The vendor's database stays secret only because the client never gets the embedding model that would make those downloaded vectors useful for code lookups; if a client can reconstruct or steal that model from query results, the vendor-side privacy guarantee collapses.

Editorial extensions

If this is right

  • An industrial SCA vendor can offer a privacy-preserving service at roughly 20 minutes per analyzed binary on average, instead of hours, while keeping accuracy at the level of the non-private state of the art.
  • Customers no longer have to choose between leaking source code to the vendor and forcing the vendor to hand over its OSS database: both assets stay protected under MPC.
  • The SBB-based alternative is unsuitable when the vendor must not learn the SCA report, since a curious server can predict the report from mutated hashes with F1 close to the client's.
  • The approach extends source-based SCA to statically linked libraries: the assembly filter and binary embedding model lift recall from 0.747 to 0.791 when binary code with debug information is available.
  • The commit-based signature generation avoids the prohibitive cost of tagging every release, making large-scale OSS database updates tractable.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The 8.5% figure is tied to this 14-project benchmark and this particular embedding stack; the durable insight is the selection-rate law, under 5% of functions, which should transfer to larger databases but deserves re-measurement at industrial scale.
  • The vendor-side privacy guarantee depends on the embedding model staying secret. The paper's own experiment shows that stealing 1% of the OSS database to approximate the model reaches only 0.589 F1 in about three days; scaling that attack, for example by pairing the downloaded vector database with public OSS source code to train a surrogate embedder, is a concrete way to test whether the guarantee
  • The same filter-then-encrypt pattern could apply to other privacy-preserving code analyses, such as call-stack or vulnerability scanning, wherever a small informative subset of functions carries most of the signal.
  • The semi-honest assumption is the ceiling of the guarantee: a malicious client who deviates from the filtering protocol could query more functions or craft inputs to extract more information, so higher-assurance deployments would need a malicious-secure MPC variant.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. This paper presents the first systematic study of privacy-preserving software composition analysis (SCA). It identifies the privacy assets of both the client (source/binary code, SCA report) and the vendor (OSS database, embedding model), evaluates three privacy-protection setups (private deployment, SBB-based, and MPC-based) and proposes an optimized MPC-based framework called SAFE SCA. SAFE SCA adds three client-side filters—a symbol filter, an informative source function filter, and an assembly function filter—to reduce the number of functions that need expensive encrypted computation. On a 14-project benchmark, the authors report reducing the MPC-based SCA time from 195,125 seconds to 16,527 seconds (8.47%) while maintaining F1 around 0.809, close to the non-private CENTRIS (DPCNN) baseline at 0.802. The paper also reports an SBB-based leakage experiment and argues that MPC offers the strongest privacy guarantee.

Significance. If the central claim is sustained, the work would be a meaningful step toward practical privacy-preserving SCA: the 11.8x speedup over unoptimized MPC and 23x overhead over non-private CENTRIS are directly measured, and the artifact is publicly released, which supports reproducibility. However, the significance is moderated by two concerns. First, the vendor-side privacy guarantee is not cryptographically established: the client downloads the full OSS vector database and obtains plaintext embeddings through MPC queries, making model extraction a concrete threat that the paper's own 1% stealing experiment partially demonstrates. Second, the accuracy comparison relies on a small 14-project dataset with hyperparameter β selected on the same evaluation set, so the reported F1 values are partly in-sample fits. These issues affect the paper's headline claim that the optimizations come 'without sacrificing privacy guarantee or accuracy,' but they do not invalidate the measured overhead reduction.

major comments (2)
  1. [Abstract and Sec. IV-C] The claim that MPC-based SCA achieves privacy 'without sacrificing SCA's privacy guarantee' is not supported for the vendor side. In Sec. IV-C, the paper argues that the downloaded OSS vector database is harmless because the client lacks the embedding model, but the client can use the MPC protocol as an oracle: it submits arbitrary function tensors and receives plaintext embeddings. Under the stated semi-honest threat model, the client may use these input-output pairs to approximate the model. The paper's own experiment shows that stealing 1% of the OSS database yields F1 = 0.589 in about three days, which is measurable leakage. Calling this 'orthogonal' and citing external defenses (query limiting, periodic model updates) is not sufficient, since those defenses are neither implemented nor evaluated. The vendor-side privacy guarantee should either be substantiated with an implemented defense or explicitly weakened in the abstract and conclusion.
  2. [Sec. VII-A and Table III] The reported accuracy of SAFE SCA, F1 = 0.809, is obtained by selecting β = 40 as the value giving the highest F1 on the same 14-project evaluation set (Fig. 8), and this same in-sample result is then presented in Table III as SAFE SCA's accuracy. This makes the reported F1 partly a fitted value. The paper notes that performance is not sensitive to β, which mitigates the concern, but it would be more convincing to use a separate tuning set or cross-validation. Additionally, the 14-project dataset is small and no variance or significance tests are reported, so the claim that accuracy is not sacrificed relative to CENTRIS (DPCNN) should be stated with appropriate caution.
minor comments (4)
  1. [Fig. 4] The caption of Fig. 4 contains the stray text 'Fig 4：Try enlarging the font', which appears to be a formatting artifact and should be removed.
  2. [Sec. IV-C] The sentence 'without the embedding model, which is exclusive to the client, the client cannot exploit the DB' appears to contain a typo: the model is exclusive to the server, not the client. The wording should be corrected to avoid confusion.
  3. [Sec. IV-B] The weight formula w = LoC/(5N−1) is introduced without a derivation or ablation study; a brief explanation of the chosen constants (5 and −1) would improve clarity.
  4. [Sec. VII] The hyperparameters θ1 and θ2 are both fixed at 0.02 and the sensitivity analysis is only referenced on the project website; including at least a brief sensitivity plot or table in the paper would make the evaluation more self-contained.

Circularity Check

1 steps flagged · score 4.0 of 10

Reported SAFE SCA accuracy is partly an in-sample fitted value via beta selection; overhead and privacy analyses otherwise independent of their inputs.

  1. fitted input called prediction [Sec. VII-A 'Performance of SAFE SCA' (Fig. 8) and Table III]
    "Fig. 8 presents the precision, recall, and F1 score of SAFE SCA with different β values. ... The highest F1 score is 0.81 when β is 40. Compared with CENTRIS (DPCNN), SAFE SCA achieves a similar F1 score, which demonstrates the effectiveness of our proposed three filters. ... SAFESCA .828 .791 .809 16527.3 8.47%"

    The reuse-detection threshold β is a free parameter of the weighted scoring rule from Sec. IV-B, and the paper selects it by sweeping over the same 14-project benchmark used for evaluation (Fig. 8). The reported F1=0.809 in Table III is the value at the in-sample optimum β=40, so the headline accuracy is the fitted maximum of a parameter sweep rather than an independent out-of-sample prediction. This is a mild fitted-input-called-prediction issue. It is limited because the authors also show F1 stays above 0.78 for all β>5, giving some robustness, and because the central runtime reduction to 8.47% is governed by the filter ratios θ1 and θ2 and the measured selected-function fraction, not by β.

full rationale

The derivation chain is otherwise self-contained: SAFE SCA's overhead reduction is measured directly from the number of functions selected for encrypted computation (Fig. 9 and Table III) and does not reduce to an input parameter. The MPC privacy claim for the client follows from the CrypTen protocol and is not circular. The vendor-side privacy guarantee is the main correctness risk, not a circularity: Sec. IV-C states the downloaded OSS DB is useless 'without the embedding model,' yet the paper itself reports that stealing 1% of the DB via MPC queries reaches 0.589 of the plaintext model's F1 in about three days, and then dismisses further model stealing as 'orthogonal.' That is an unsupported privacy claim, but it is an empirical/security gap rather than a derivation that is equivalent to its inputs by construction. No load-bearing self-citation or imported uniqueness theorem appears; benchmarks against CENTRIS, BAT, GEMINI, and SAFE are external. Overall score 4 reflects the one partially fitted accuracy result while the central overhead and architecture claims retain independent content.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The central claims rest on four kinds of unpurchased inputs: the semi-honest adversary model, the assumption that a downloaded vector database without the model is not a valuable leak, the hand-built 14-project ground truth, and the hand-designed weighting/filter formulas with tuned thresholds. The most fragile is the vendor-side privacy premise, which the paper partially undermines with its own model-stealing experiment.

free parameters (5)
  • beta (OSS reuse score threshold) = 40
    Chosen on the evaluation set; Fig. 8 shows F1 peaking at beta=40, and the final result uses this value without held-out validation.
  • theta1 (informative source function proportion) = 0.02
    Set in Sec. VII; sensitivity analysis is deferred to the project website, so tuning on the same dataset cannot be ruled out.
  • theta2 (assembly function proportion) = 0.02
    Set in Sec. VII together with theta1; same deferral to the website applies.
  • SBB gamma and theta = 50 and 1000
    SBB mutation bias and bucket size fixed in Sec. V-C; no sensitivity analysis is reported in the main text.
  • weight-formula constants (5 and -1) in w = LoC/(5N-1) = 5, -1
    Hand-chosen formula in Sec. IV-B; no derivation or ablation is given for these constants.
assumptions (5)
  • domain assumption Semi-honest threat model: both parties follow the protocol but may try to infer information.
    Stated in Sec. IV; all privacy claims are limited to this adversary model, so malicious clients or servers are out of scope.
  • ad hoc to paper The OSS vector database is not a meaningful leak without the secret embedding model.
    Core vendor-side privacy argument in Sec. IV-C; the paper's own model-stealing study (1% of DB, F1 0.589) shows partial leakage, so this premise is partially challenged.
  • domain assumption The manually constructed ground truth for 14 projects is accurate.
    Sec. V-B: two authors spent 40 man-hours manually checking reuses; this ground truth has no independent release or third-party verification.
  • domain assumption Function-level similarity and the weighting formula w = LoC/(5N-1) capture OSS reuse accurately.
    Sec. IV-B; the improvement of CENTRIS(DPCNN) over CENTRIS(TLSH) is attributed to this weighting, but the formula itself is not derived or ablated.
  • domain assumption Customers of SAFE SCA have source code and binaries with debug information.
    Stated as an assumption in Sec. VI; the symbol filter and binary analysis depend on debug symbols, limiting applicability to other deployment scenarios.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Preserving Privacy in Software Composition Analysis: A Study of Technical Solutions and Enhancements." pith.science (2026). https://pith.science/paper/VG5F6HA3

@misc{pith2026241200898,
  author       = {Pith},
  title        = {Pith review of: Preserving Privacy in Software Composition Analysis: A Study of Technical Solutions and Enhancements},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VG5F6HA3}},
  note         = {Machine review of arXiv:2412.00898}
}
read the original abstract

Software composition analysis (SCA) denotes the process of identifying open-source software components in an input software application. SCA has been extensively developed and adopted by academia and industry. However, we notice that the modern SCA techniques in industry scenarios still need to be improved due to privacy concerns. Overall, SCA requires the users to upload their applications' source code to a remote SCA server, which then inspects the applications and reports the component usage to users. This process is privacy-sensitive since the applications may contain sensitive information, such as proprietary source code, algorithms, trade secrets, and user data. Privacy concerns have prevented the SCA technology from being used in real-world scenarios. Therefore, academia and the industry demand privacy-preserving SCA solutions. For the first time, we analyze the privacy requirements of SCA and provide a landscape depicting possible technical solutions with varying privacy gains and overheads. In particular, given that de facto SCA frameworks are primarily driven by code similarity-based techniques, we explore combining several privacy-preserving protocols to encapsulate the similarity-based SCA framework. Among all viable solutions, we find that multi-party computation (MPC) offers the strongest privacy guarantee and plausible accuracy; it, however, incurs high overhead (184 times). We optimize the MPC-based SCA framework by reducing the amount of crypto protocol transactions using program analysis techniques. The evaluation results show that our proposed optimizations can reduce the MPC-based SCA overhead to only 8.5% without sacrificing SCA's privacy guarantee or accuracy.

Figures

Figures reproduced from arXiv: 2412.00898 by the authors.

Figure 1
Figure 1. A common SCA pipeline. in Table I, each studied solution exhibits distinct privacy guarantees, required resources, overhead, and potential pitfalls. Furthermore, we concretize the technical solutions and empiri￾cally benchmark their overheads and accuracies. Specifically, the two novel solutions we proposed involve advanced privacy￾preserving protocols to offer privacy-preserving SCA. One solution relies on similari… view at source ↗
Figure 2
Figure 2. Similarity-based bucketization protocol. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. presents the workflow of SBB-based SCA. The client first dissects the input source repository into functions (➀) and then generates the signatures with TLSH (➁). By employing the SBB protocol to protect the private data, a function’s hash Client Report Server ② Hashing Hash value 𝑝 Hash value 𝑝′ ③ Mutation ℎ଴ -- 𝑂𝑆𝑆௔ Functions o o o o o o o o o o o Database (DB) o o o o o o o o ℎଵ -- 𝑂𝑆𝑆௕ … ℎଵ -- 𝑂𝑆𝑆௕ Input The most… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Workflow of MPC-based SCA [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: SBB-based CENTRIS’s F1 according to γ and δ ′ . of mutated hash values I ′ , from which the curious vendor can predict the client’s SCA report. Formally, let DBk be the hash value set of the k-th OSS project, and the function dis evaluates the distance between two hash…
Figure 7
Figure 7. Figure 7: A common pipeline of binary code similarity analysis (BCSA). motivates us to build a practical privacy-preserving SCA framework based on MPC. However, the MPC-based SCA framework comes with a high overhead. This section optimizes the standard setup of MPC-based SCA by …
Figure 9
Figure 9. Figure 9: Number of selected functions of SAFESCA to to￾tal functions of each binary. VII. EVALUATION To evaluate SAFESCA, we reuse our large-scale OSS database described in Sec. V-A and the manually-built evalua￾tion dataset (Sec. V-B). We also reuse the source-based OSS scorin…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

103 extracted references · 71 canonical work pages

  1. [1]

    Black Duck Binary Analysis,

    “Black Duck Binary Analysis,” https://www.synopsys.com/ software-integrity/security-testing/software-composition-analysis/ binary-analysis.html

  2. [2]

    CODESentry: Binary Software Composition Analysis,

    “CODESentry: Binary Software Composition Analysis,” https://www. grammatech.com/binary-software-composition-analysis-sca

  3. [3]

    crashpad,

    “crashpad,” https://chromium.googlesource.com/crashpad

  4. [4]

    “glad,” https://github.com/Dav1dde/glad

  5. [5]

    libunwind,

    “libunwind,” https://www.nongnu.org/libunwind/

  6. [6]

    mod pagespeed,

    “mod pagespeed,” https://github.com/apache/ incubator-pagespeed-mod

  7. [7]

    RapidJSON,

    “RapidJSON,” https://github.com/Tencent/rapidjson/

  8. [8]

    “raylib,” https://github.com/raysan5/raylib

Show all 103 references
  1. [9]

    SafeSCA,

    “SafeSCA,” https://sites.google.com/view/safesca

  2. [10]

    “Snyk,” https://snyk.io/what-is-snyk/

  3. [11]

    Whitesource,

    “Whitesource,” https://www.whitesourcesoftware.com/ product-overview/

  4. [12]

    “yuzu,” https://github.com/yuzu-emu/yuzu

  5. [13]

    Black Duck Binary Analysis,

    “Black Duck Binary Analysis,” https://community.synopsys.com/s/ black-duck-binary-analysis, 2023

    2023

  6. [14]

    Centris,

    “Centris,” https://github.com/wooseunghoon/Centris-public, 2023

    2023

  7. [15]

    “SDL,” https://github.com/libsdl-org/SDL, 2023

    2023

  8. [16]

    Tencent BinaryAI,

    “Tencent BinaryAI,” https://www.binaryai.cn/, 2023

    2023

  9. [17]

    yuv2rgb,

    “yuv2rgb,” https://github.com/descampsa/yuv2rgb, 2023

    2023

  10. [18]

    Private server lawsuit of maplestory,

    “Private server lawsuit of maplestory,” https: //maplenewsnetwork.wordpress.com/2012/04/24/ nexon-awarded-3-6-million-in-private-server-lawsuit/, 2024

    2012

  11. [19]

    Software bill of materials,

    A. C. D. Agency, “Software bill of materials,” https://www.cisa.gov/sbom, 2024

    2024

  12. [20]

    Code2Vec: Learning distributed representations of code,

    U. Alon, M. Zilberstein, O. Levy, and E. Yahav, “Code2Vec: Learning distributed representations of code,” Proc. ACM Program. Lang., vol. 3, no. POPL, Jan. 2019

    2019

  13. [21]

    Reliable third-party library detection in android and its security applications,

    M. Backes, S. Bugiel, and E. Derr, “Reliable third-party library detection in android and its security applications,” in ACM CCS, 2016, pp. 356– 367

    2016

  14. [22]

    Code obfuscation against symbolic execution attacks,

    S. Banescu, C. Collberg, V . Ganesh, Z. Newsham, and A. Pretschner, “Code obfuscation against symbolic execution attacks,” in Proceedings of the 32nd Annual Conference on Computer Security Applications , 2016, pp. 189–200

    2016

  15. [23]

    Efficient multiparty protocols using circuit randomization,

    D. Beaver, “Efficient multiparty protocols using circuit randomization,” in Advances in Cryptology—CRYPTO’91: Proceedings 11 . Springer, 1992, pp. 420–432

    1992

  16. [24]

    Neural code comprehen- sion: A learnable representation of code semantics,

    T. Ben-Nun, A. S. Jakobovits, and T. Hoefler, “Neural code comprehen- sion: A learnable representation of code semantics,” ser. NIPS, 2018

    2018

  17. [25]

    Semi- homomorphic encryption and multiparty computation,

    R. Bendlin, I. Damg ˚ard, C. Orlandi, and S. Zakarias, “Semi- homomorphic encryption and multiparty computation,” in Annual Inter- national Conference on the Theory and Applications of Cryptographic Techniques. Springer, 2011, pp. 169–188

    2011

  18. [26]

    Automated identification of libraries from vulnerability data,

    Y . Chen, A. E. Santosa, A. Sharma, and D. Lo, “Automated identification of libraries from vulnerability data,” in Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering: Software Engineering in Practice , 2020, pp. 90–99

    2020

  19. [27]

    A machine learning approach for vulnerability curation,

    Y . Chen, A. E. Santosa, A. M. Yi, A. Sharma, A. Sharma, and D. Lo, “A machine learning approach for vulnerability curation,” in Proceedings of the 17th International Conference on Mining Software Repositories , 2020, pp. 32–42

    2020

  20. [28]

    Clickhouse,

    ClickHouse, “Clickhouse,” https://clickhouse.com/, 2023

    2023

  21. [29]

    Denial of service via algorithmic complexity attacks,

    S. A. Crosby and D. S. Wallach, “Denial of service via algorithmic complexity attacks,” in 12th USENIX Security Symposium (USENIX Security 03), 2003

    2003

  22. [30]

    Multiparty compu- tation from somewhat homomorphic encryption,

    I. Damg ˚ard, V . Pastro, N. Smart, and S. Zakarias, “Multiparty compu- tation from somewhat homomorphic encryption,” in Annual Cryptology Conference. Springer, 2012, pp. 643–662

    2012

  23. [31]

    Asm2Vec: Boosting static representation robustness for binary clone search against code obfuscation and compiler optimization,

    S. H. Ding, B. M. Fung, and P. Charland, “Asm2Vec: Boosting static representation robustness for binary clone search against code obfuscation and compiler optimization,” in IEEE S&P, 2019

    2019

  24. [32]

    Identifying open- source license violation and 1-day security risk at large scale,

    R. Duan, A. Bijlani, M. Xu, T. Kim, and W. Lee, “Identifying open- source license violation and 1-day security risk at large scale,” in Proceedings of the 2017 ACM SIGSAC Conference on computer and communications security, 2017, pp. 2169–2185

    2017

  25. [33]

    DEEPBINDIFF: Learning program-wide code representations for binary diffing,

    Y . Duan, X. Li, J. Wang, and H. Yin, “DEEPBINDIFF: Learning program-wide code representations for binary diffing,” 2020

    2020

  26. [34]

    Codebert: A pre-trained model for programming and natural languages,

    Z. Feng, D. Guo, D. Tang, N. Duan, X. Feng, M. Gong, L. Shou, B. Qin, T. Liu, D. Jiang et al. , “Codebert: A pre-trained model for programming and natural languages,” arXiv preprint arXiv:2002.08155 , 2020

    2002 arXiv

  27. [35]

    Monitoring-based differential privacy mechanism against query flooding-based model extraction attack,

    M. A. Q. Flooding-Based, “Monitoring-based differential privacy mechanism against query flooding-based model extraction attack,” 2021

    2021

  28. [36]

    GitHub, “CodeQL,” https://codeql.github.com/, 2021

    M. . GitHub, “CodeQL,” https://codeql.github.com/, 2021

    2021

  29. [37]

    Goldreich, Foundations of Cryptography, Volume 2

    O. Goldreich, Foundations of Cryptography, Volume 2 . Cambridge university press Cambridge, 2004

    2004

  30. [38]

    Software complexity analysis using halstead metrics,

    T. Hariprasad, G. Vidhyagaran, K. Seenu, and C. Thirumalai, “Software complexity analysis using halstead metrics,” in International Conference on Trends in Electronics and Informatics (ICEI) , 2017, pp. 1109–1113

    2017

  31. [39]

    Finding software license violations through binary code clone detection,

    A. Hemel, K. T. Kalleberg, R. Vermaas, and E. Dolstra, “Finding software license violations through binary code clone detection,” in Proceedings of the 8th Working Conference on Mining Software Repositories, 2011, pp. 63–72

    2011

  32. [40]

    Code vectors: understanding programs through embedded abstracted symbolic traces,

    J. Henkel, S. K. Lahiri, B. Liblit, and T. Reps, “Code vectors: understanding programs through embedded abstracted symbolic traces,” in Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engin...

    2018

  33. [41]

    Increasing adversarial uncertainty to scale private similarity testing,

    Y . Hua, A. Namavari, K. Cheng, M. Naaman, and T. Ristenpart, “Increasing adversarial uncertainty to scale private similarity testing,” in 31st USENIX Security Symposium , 2022, pp. 1777–1794

    2022

  34. [42]

    1-to-1 or 1-to-n? investigating the effect of function inlining on binary similarity analysis,

    A. Jia, M. Fan, W. Jin, X. Xu, Z. Zhou, Q. Tang, S. Nie, S. Wu, and T. Liu, “1-to-1 or 1-to-n? investigating the effect of function inlining on binary similarity analysis,” ACM Trans. Softw. Eng. Methodol. , vol. 32, no. 4, pp. 1–26, 2023

    2023

  35. [43]

    Bina- ryai: Binary software composition analysis via intelligent binary source code matching,

    L. Jiang, J. An, H. Huang, Q. Tang, S. Nie, S. Wu, and Y . Zhang, “Bina- ryai: Binary software composition analysis via intelligent binary source code matching,” Proceedings of the 46th International Conference on Software Engineering, 2024

    2024

  36. [44]

    Third-party library dependency for large-scale sca in the c/c++ ecosystem: How far are we?

    L. Jiang, H. Yuan, Q. Tang, S. Nie, S. Wu, and Y . Zhang, “Third-party library dependency for large-scale sca in the c/c++ ecosystem: How far are we?” in Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis , 2023, pp. 1383–1395

    2023

  37. [45]

    Billion-scale similarity search with GPUs,

    J. Johnson, M. Douze, and H. J ´egou, “Billion-scale similarity search with GPUs,” IEEE Transactions on Big Data, vol. 7, no. 3, pp. 535–547, 2019

    2019

  38. [46]

    Deep pyramid convolutional neural networks for text categorization,

    R. Johnson and T. Zhang, “Deep pyramid convolutional neural networks for text categorization,” in Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) , 2017, pp. 562–570

    2017

  39. [47]

    Obfuscator-LLVM: Software protection for the masses,

    P. Junod, J. Rinaldini, J. Wehrli, and J. Michielin, “Obfuscator-LLVM: Software protection for the masses,” ser. SPRO, 2015

    2015

  40. [48]

    Prada: protecting against dnn model stealing attacks,

    M. Juuti, S. Szyller, S. Marchal, and N. Asokan, “Prada: protecting against dnn model stealing attacks,” in 2019 IEEE European Symposium on Security and Privacy (EuroS&P) . IEEE, 2019, pp. 512–527

    2019

  41. [49]

    Model extraction warning in mlaas paradigm,

    M. Kesarwani, B. Mukhoty, V . Arya, and S. Mehta, “Model extraction warning in mlaas paradigm,” in Proceedings of the 34th Annual Computer Security Applications Conference , 2018, pp. 371–380

    2018

  42. [50]

    Crypten: Secure multi-party computation meets machine learning,

    B. Knott, S. Venkataraman, A. Hannun, S. Sengupta, M. Ibrahim, and L. van der Maaten, “Crypten: Secure multi-party computation meets machine learning,” in arXiv 2109.00984, 2021

    2021 arXiv

  43. [51]

    Large-scale third-party library detection in android markets,

    M. Li, P. Wang, W. Wang, S. Wang, D. Wu, J. Liu, R. Xue, W. Huo, and W. Zou, “Large-scale third-party library detection in android markets,” IEEE Transactions on Software Engineering , vol. 46, no. 9, pp. 981– 1003, 2018

    2018

  44. [52]

    Libd: Scalable and precise third-party library detection in android markets,

    M. Li, W. Wang, P. Wang, S. Wang, D. Wu, J. Liu, R. Xue, and W. Huo, “Libd: Scalable and precise third-party library detection in android markets,” in 2017 IEEE/ACM 39th International Conference on Software Engineering , 2017, pp. 335–346

    2017

  45. [53]

    Palmtree: Learning an assembly language model for instruction embedding,

    X. Li, Y . Qu, and H. Yin, “Palmtree: Learning an assembly language model for instruction embedding,” in ACM CCS, 2021, pp. 3236–3251

    2021

  46. [54]

    Defending against model stealing via verifying embedded external features,

    Y . Li, L. Zhu, X. Jia, Y . Jiang, S.-T. Xia, and X. Cao, “Defending against model stealing via verifying embedded external features,” in Proceedings of the AAAI conference on artificial intelligence , vol. 36, no. 2, 2022, pp. 1464–1472

    2022

  47. [55]

    Unleashing the power of compiler intermediate representation to enhance neural program embeddings,

    Z. Li, P. Ma, H. Wang, S. Wang, Q. Tang, S. Nie, and S. Wu, “Unleashing the power of compiler intermediate representation to enhance neural program embeddings,” in Proceedings of the 44th International Conference on Software Engineering , 2022, pp. 2253– 2265

    2022

  48. [56]

    How to simulate it–a tutorial on the simulation proof technique,

    Y . Lindell, “How to simulate it–a tutorial on the simulation proof technique,” Tutorials on the Foundations of Cryptography: Dedicated to Oded Goldreich , pp. 277–346, 2017

    2017

  49. [57]

    αdiff: cross-version binary code similarity detection with dnn,

    B. Liu, W. Huo, C. Zhang, W. Li, F. Li, A. Piao, and W. Zou, “ αdiff: cross-version binary code similarity detection with dnn,” in Proceedings of the 33rd ACM/IEEE international conference on automated software engineering, 2018, pp. 667–678

    2018

  50. [58]

    How far we have come: Testing decompilation correctness of c decompilers,

    Z. Liu and S. Wang, “How far we have come: Testing decompilation correctness of c decompilers,” in Proceedings of the 29th ACM SIGSOFT International Symposium on Software Testing and Analysis , 2020, pp. 475–487

    2020

  51. [59]

    Sok: Demystifying binary lifters through the lens of downstream applications,

    Z. Liu, Y . Yuan, S. Wang, and Y . Bao, “Sok: Demystifying binary lifters through the lens of downstream applications,” in 2022 IEEE Symposium on Security and Privacy (SP) , 2022, pp. 1100–1119

    2022

  52. [60]

    Decompiling x86 deep neural network executables,

    Z. Liu, Y . Yuan, S. Wang, X. Xie, and L. Ma, “Decompiling x86 deep neural network executables,” in 32nd USENIX Security Symposium (USENIX Security 23) , 2023, pp. 7357–7374

    2023

  53. [61]

    Semantics-based obfuscation-resilient binary code similarity comparison with applica- tions to software plagiarism detection,

    L. Luo, J. Ming, D. Wu, P. Liu, and S. Zhu, “Semantics-based obfuscation-resilient binary code similarity comparison with applica- tions to software plagiarism detection,” in Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering, 20...

    2014

  54. [62]

    Semantics-based obfuscation-resilient binary code similarity comparison with applications to software and algorithm plagiarism detection,

    ——, “Semantics-based obfuscation-resilient binary code similarity comparison with applications to software and algorithm plagiarism detection,” IEEE Transactions on Software Engineering , vol. 43, no. 12, pp. 1157–1177, 2017

    2017

  55. [63]

    Libradar: fast and accurate detection of third-party libraries in android apps,

    Z. Ma, H. Wang, Y . Guo, and X. Chen, “Libradar: fast and accurate detection of third-party libraries in android apps,” in Proceedings of the 38th international conference on software engineering companion , 2016, pp. 653–656

    2016

  56. [64]

    Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs,

    Y . A. Malkov and D. A. Yashunin, “Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs,” IEEE transactions on pattern analysis and machine intelligence , vol. 42, no. 4, pp. 824–836, 2018

    2018

  57. [65]

    Manadhata and J

    P. Manadhata and J. M. Wing, Measuring a system’s attack surface . School of Computer Science, Carnegie Mellon University Pittsburgh, PA, USA, 2004

    2004

  58. [66]

    An attack surface metric,

    P. K. Manadhata and J. M. Wing, “An attack surface metric,” IEEE Transactions on Software Engineering , vol. 37, no. 3, pp. 371–386, 2010

    2010

  59. [67]

    How machine learning is solving the binary function similarity problem,

    A. Marcelli, M. Graziano, X. Ugarte-Pedrero, Y . Fratantonio, M. Man- souri, and D. Balzarotti, “How machine learning is solving the binary function similarity problem,” in 31st USENIX Security Symposium (USENIX Security 22) , 2022, pp. 2099–2116

    2022

  60. [68]

    Safe: Self-attentive function embeddings for binary similarity,

    L. Massarelli, G. A. D. Luna, F. Petroni, R. Baldoni, and L. Querzoni, “Safe: Self-attentive function embeddings for binary similarity,” in International Conference on Detection of Intrusions and Malware, and Vulnerability Assessment. Springer, 2019, pp. 309–329

    2019

  61. [69]

    Code metrics - maintainability index range and meaning,

    Microsoft, “Code metrics - maintainability index range and meaning,” https://learn.microsoft.com/en-us/visualstudio/code-quality/ code-metrics-maintainability-index-range-and-meaning, 2023

    2023

  62. [70]

    Efficient estimation of word representations in vector space,

    T. Mikolov, K. Chen, G. Corrado, and J. Dean, “Efficient estimation of word representations in vector space,” arXiv preprint arXiv:1301.3781 , 2013

    2013 arXiv

  63. [71]

    Dis- tributed representations of words and phrases and their compositionality,

    T. Mikolov, I. Sutskever, K. Chen, G. S. Corrado, and J. Dean, “Dis- tributed representations of words and phrases and their compositionality,” Advances in neural information processing systems , vol. 26, 2013

    2013

  64. [72]

    Tlsh–a locality sensitive hash,

    J. Oliver, C. Cheng, and Y . Chen, “Tlsh–a locality sensitive hash,” in 2013 Fourth Cybercrime and Trustworthy Computing Workshop , 2013, pp. 7–13

    2013

  65. [73]

    Ddos attacks at the application layer: Challenges and research perspectives for safeguarding web applications,

    A. Praseed and P. S. Thilagam, “Ddos attacks at the application layer: Challenges and research perspectives for safeguarding web applications,” IEEE Communications Surveys & Tutorials, vol. 21, no. 1, pp. 661–685, 2018

    2018

  66. [74]

    Sourcerercc: Scaling code clone detection to big-code,

    H. Sajnani, V . Saini, J. Svajlenko, C. K. Roy, and C. V . Lopes, “Sourcerercc: Scaling code clone detection to big-code,” in Proceedings of the 38th International Conference on Software Engineering , 2016, pp. 1157–1168

    2016

  67. [75]

    A critique of cyclomatic complexity as a software metric,

    M. Shepperd, “A critique of cyclomatic complexity as a software metric,” Software Engineering Journal , vol. 3, no. 2, pp. 30–36, 1988

    1988

  68. [76]

    Libdb: An effective and efficient framework for detecting third-party libraries in binaries,

    W. Tang, Y . Wang, H. Zhang, S. Han, P. Luo, and D. Zhang, “Libdb: An effective and efficient framework for detecting third-party libraries in binaries,” 19th International Conference on Mining Software Repositories, 2022

    2022

  69. [77]

    Towards understanding third-party library dependency in c/c++ ecosystem,

    W. Tang, Z. Xu, C. Liu, J. Wu, S. Yang, Y . Li, P. Luo, and Y . Liu, “Towards understanding third-party library dependency in c/c++ ecosystem,” in 37th IEEE/ACM International Conference on Automated Software Engineering, 2022, pp. 1–12

    2022

  70. [78]

    T. J. Team, “Joern,” https://joern.io, 2021

    2021

  71. [79]

    Apache log4j,

    The Apache Software Foundation, “Apache log4j,” https://logging.apache.org/log4j/2.x/, 2024

    2024

  72. [80]

    Anchor: Fast and precise value-flow analysis for containers via memory orientation,

    C. Wang, W. Wang, P. Yao, Q. Shi, J. Zhou, X. Xiao, and C. Zhang, “Anchor: Fast and precise value-flow analysis for containers via memory orientation,” ACM Trans. Softw. Eng. Methodol. , vol. 32, no. 3, pp. 66:1–66:39, 2023

    2023

  73. [81]

    jtrans: Jump-aware transformer for binary code similarity,

    H. Wang, W. Qu, G. Katz, W. Zhu, Z. Gao, H. Qiu, J. Zhuge, and C. Zhang, “jtrans: Jump-aware transformer for binary code similarity,” arXiv preprint arXiv:2205.12713 , 2022

    2022 arXiv

  74. [82]

    Wukong: A scalable and accurate two-phase approach to android app clone detection,

    H. Wang, Y . Guo, Z. Ma, and X. Chen, “Wukong: A scalable and accurate two-phase approach to android app clone detection,” in Proceedings of the 2015 International Symposium on Software Testing and Analysis, 2015, pp. 71–82

    2015

  75. [83]

    Are we there yet? filling the gap between binary similarity analysis and binary software composition analysis,

    H. Wang, Z. Liu, S. Wang, Y . Wang, Q. Tang, S. Nie, and S. Wu, “Are we there yet? filling the gap between binary similarity analysis and binary software composition analysis,” in 2024 IEEE 9th European Symposium on Security and Privacy (Euro S&P) , 2024, pp. 506–523

    2024

  76. [84]

    sem2vec: Semantics-aware assembly tracelet embedding,

    H. Wang, P. Ma, S. Wang, Q. Tang, S. Nie, and S. Wu, “sem2vec: Semantics-aware assembly tracelet embedding,” ACM Trans. Softw. Eng. Methodol., vol. 32, no. 4, pp. 1–34, 2023

    2023

  77. [85]

    Enhancing DNN-based binary code function search with low- cost equivalence checking,

    H. Wang, P. Ma, Y . Yuan, Z. Liu, S. Wang, Q. Tang, S. Nie, and S. Wu, “Enhancing DNN-based binary code function search with low- cost equivalence checking,” IEEE Transactions on Software Engineering, vol. 49, no. 1, pp. 226–250, 2022

    2022

  78. [86]

    Generating effective software obfuscation sequences with reinforcement learning,

    H. Wang, S. Wang, D. Xu, X. Zhang, and X. Liu, “Generating effective software obfuscation sequences with reinforcement learning,” IEEE Transactions on Dependable and Secure Computing , vol. 19, no. 3, pp. 1900–1917, 2020

    1900

  79. [87]

    PP-CSA: Practical privacy- preserving software call stack analysis,

    Z. Wang, P. Ma, H. Wang, and S. Wang, “PP-CSA: Practical privacy- preserving software call stack analysis,” Proceedings of the ACM on Programming Languages, vol. 8, no. OOPSLA1, pp. 1264–1293, 2024

    2024

  80. [88]

    BinAug: Enhancing binary similarity analysis with low-cost input repairing,

    W. K. Wong, H. Wang, Z. Li, and S. Wang, “BinAug: Enhancing binary similarity analysis with low-cost input repairing,” in Proceedings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE), 2024, pp. 1–13

    2024

  81. [89]

    Deceiving deep neural networks-based binary code matching with adversarial programs,

    W. K. Wong, H. Wang, P. Ma, S. Wang, M. Jiang, T. Y . Chen, Q. Tang, S. Nie, and S. Wu, “Deceiving deep neural networks-based binary code matching with adversarial programs,” in 2022 IEEE International Conference on Software Maintenance and Evolution, 2022, pp. 117–128

    2022

  82. [90]

    Centris: A precise and scalable approach for identifying modified open-source software reuse,

    S. Woo, S. Park, S. Kim, H. Lee, and H. Oh, “Centris: A precise and scalable approach for identifying modified open-source software reuse,” in 2021 IEEE/ACM 43rd International Conference on Software Engineering, 2021, pp. 860–872

    2021

  83. [91]

    Ossfp: Precise and scalable c/c++ third-party library detection using fingerprinting functions,

    J. Wu, Z. Xu, W. Tang, L. Zhang, Y . Wu, C. Liu, K. Sun, L. Zhao, and Y . Liu, “Ossfp: Precise and scalable c/c++ third-party library detection using fingerprinting functions,” in 2023 IEEE/ACM 45th International Conference on Software Engineering , 2023, pp. 270–282

    2023

  84. [92]

    Libalchemy: A two-layer persistent summary design for taming third-party libraries in static bug-finding systems,

    R. Wu, Y . He, J. Huang, C. Wang, W. Tang, Q. Shi, X. Xiao, and C. Zhang, “Libalchemy: A two-layer persistent summary design for taming third-party libraries in static bug-finding systems,” in Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, 2...

    2024

  85. [93]

    Neural network- based graph embedding for cross-platform binary code similarity detection,

    X. Xu, C. Liu, Q. Feng, H. Yin, L. Song, and D. Song, “Neural network- based graph embedding for cross-platform binary code similarity detection,” in CCS, 2017

    2017

  86. [94]

    Modx: binary level partially imported third-party library detection via program modularization and semantic matching,

    C. Yang, Z. Xu, H. Chen, Y . Liu, X. Gong, and B. Liu, “Modx: binary level partially imported third-party library detection via program modularization and semantic matching,” in Proceedings of the 44th International Conference on Software Engineering , 2022, pp. 1393– 1405

    2022

  87. [95]

    How to generate and exchange secrets,

    A. C.-C. Yao, “How to generate and exchange secrets,” in 27th annual symposium on foundations of computer science , 1986, pp. 162–167

    1986

  88. [96]

    Order matters: Semantic-aware neural networks for binary code similarity detection,

    Z. Yu, R. Cao, Q. Tang, S. Nie, J. Huang, and S. Wu, “Order matters: Semantic-aware neural networks for binary code similarity detection,” in Proceedings of the AAAI Conference on Artificial Intelligence , vol. 34, no. 01, 2020, pp. 1145–1152

    2020

  89. [97]

    Codecmr: Cross-modal retrieval for function-level binary source code matching,

    Z. Yu, W. Zheng, J. Wang, Q. Tang, S. Nie, and S. Wu, “Codecmr: Cross-modal retrieval for function-level binary source code matching,” Advances in Neural Information Processing Systems , vol. 33, pp. 3872– 3883, 2020

    2020

  90. [98]

    B2sfinder: detecting open-source software reuse in cots software,

    Z. Yuan, M. Feng, F. Li, G. Ban, Y . Xiao, S. Wang, Q. Tang, H. Su, C. Yu, J. Xu et al., “B2sfinder: detecting open-source software reuse in cots software,” in 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE) , 2019, pp. 1038–1049

    2019

  91. [99]

    Atvhunter: Reliable version detection of third-party libraries for vulnerability identification in android applications,

    X. Zhan, L. Fan, S. Chen, F. Wu, T. Liu, X. Luo, and Y . Liu, “Atvhunter: Reliable version detection of third-party libraries for vulnerability identification in android applications,” in 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE) , 2021, pp. 1695–1707

    2021

  92. [100]

    Libid: reliable identification of obfuscated third-party android libraries,

    J. Zhang, A. R. Beresford, and S. A. Kollmann, “Libid: reliable identification of obfuscated third-party android libraries,” in Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis, 2019, pp. 55–65

    2019

  93. [101]

    Detecting third-party libraries in android applications with high precision and recall,

    Y . Zhang, J. Dai, X. Zhang, S. Huang, Z. Yang, M. Yang, and H. Chen, “Detecting third-party libraries in android applications with high precision and recall,” in 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER) , 2018, pp. 141–152

    2018

  94. [102]

    Plankton: Reconciling binary code and debug information,

    A. Zhou, C. Ye, H. Huang, Y . Cai, and C. Zhang, “Plankton: Reconciling binary code and debug information,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 , 2024, pp. 912–928

    2024

  95. [103]

    Neural machine translation inspired binary code similarity comparison beyond function pairs,

    F. Zuo, X. Li, P. Young, L. Luo, Q. Zeng, and Z. Zhang, “Neural machine translation inspired binary code similarity comparison beyond function pairs,” in NDSS, 2019

    2019

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.