Pith. sign in

REVIEW 3 major objections 3 minor 56 references

PoneglyphDB: Efficient Non-interactive Zero-Knowledge Proofs for Arbitrary SQL-Query Verification

T0 review · 3 major / 3 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 PoneglyphDB claims the first non-interactive zero-knowledge proof system for arbitrary SQL queries, with proof times competitive with or better than prior interactive systems.

desk verdict Promising systems paper with a load-bearing flaw: the group-by boundary constraint is inverted, so the TPC-H evaluation rests on unsound circuits; still worth peer review for repair. read the letter →

arxiv 2411.15031 v1 pith:FKZAKC6N submitted 2024-11-22 cs.DB cs.CR

Binbin Gu , Juncheng Fang , Faisal Nawab This is my paper · ORCID
classification cs.DBcs.CR
keywords zero-knowledgeproofsverifiableSQLqueriesnon-interactiveproofsystemsarithmeticcircuitdesignlookuptablesgroup-byandaggregationdatabasecommitmentTPC-Hbenchmark
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

This paper tries to show that a database can answer arbitrary SQL queries with a cryptographic proof of correctness while keeping the raw data entirely at the server, and without requiring the server and client to interact during proof generation. Earlier zero-knowledge approaches to SQL either needed multiple rounds of communication or did not support ad-hoc queries. The paper's route is to express each core SQL operation—range checks, sorting, group-by, joins, aggregation—as a small arithmetic circuit gate with low-degree polynomial constraints, then chain the gates along the query plan. If the construction holds, a data owner could commit to a database once and let many clients independently verify each query answer later, which is exactly the setting for regulated or shared sensitive data.

What carries the argument

The load-bearing mechanism is a set of custom gates in a tabular arithmetic circuit: a rectangular matrix of values with fixed, advice, and instance columns, where each row must satisfy low-degree polynomial equations and cells can be linked by equality constraints. Range checks are done with lookup tables, so a value is shown to fall in a set by proving it appears in a permuted copy of that set rather than by factoring a high-degree polynomial. Sorting reduces to a permutation check plus adjacent orderedness checks; group-by sorts and then uses a binary marker to record where equal-valued runs start and end; joins use sorted, deduplicated columns to prove non-contributing records from one table cannot match the other. A cryptographic commitment to the whole database is produced once and reused, and recursive proof composition keeps each final proof small.

What would settle it

Take a two-row table whose grouping attribute has distinct values, supply the honest witness with the inverse of their difference, and inspect the constraint satisfaction: a correct boundary marker must set both rows as boundaries, while the equations as written would set neither. If the proving algorithm accepts a witness that places the end index of the first group at the second row's position, the group-by gate is not actually enforcing bin boundaries.

Watch

Extended reading notes

Core claim

On its own terms, the central discovery is that non-interactive zero-knowledge verification of arbitrary SQL is not inherently too expensive, provided the SQL operators are compiled into lookup-table-based arithmetic gates rather than boolean circuits. Each gate establishes one property: a range check proves every value lies in a set by a permutation argument; a sort gate proves the output is a permutation of the input and is ordered; a group-by gate sorts on the grouping attributes and marks the first and last row of each equal-valued run; a join gate splits each table into contributing and non-contributing rows and proves the non-contributing rows are disjoint from the other table. The paper also uses a one-time database commitment so every later proof is tied to the same private data, and recursive proof composition to keep proofs compact. The authors report that on six standard analytics queries the resulting proofs are generated faster than an interactive zero-knowledge SQL system and much faster than a non-interactive comparison system, while using less memory.

Load-bearing premise

All the group-by, aggregation, order-by, and join proofs presume that the circuit equations for marking group-by boundaries identify the first and last row of each run of equal values; as written, those equations appear to flag equal neighboring rows instead of differing ones, so if that reading is correct, the boundary indices would not enforce the intended grouping.

Editorial extensions

If this is right

  • Proofs become transferable: any client holding the verification key can check an answer at any later time, enabling caching and re-use of previously computed responses.
  • Committing to a database is a one-time cost, after which individual queries can be proven and verified independently against the same public commitment.
  • Because gates compose along the query plan, any SQL query expressible with the supported operators inherits a correctness proof from the correctness of its individual gates.
  • Proof generation time and memory grow roughly linearly with input size, since all enforced polynomial constraints have low degree.
  • The zero-knowledge guarantee limits verifier learning to the answer and its logical consequences, so raw rows, intermediate group boundaries, and sort orders stay hidden.

Reading between the lines

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

  • Editorial inference: the gate decomposition is portable: the same SQL gates could be compiled onto a future, faster proving system, so the architecture's value is likely to outlive the specific proving implementation used in the paper.
  • Editorial inference: the group-by boundary equations are the most fragile link; if they are corrected or replaced by a separate proof, the rest of the gate library would be unchanged, suggesting the design is modular rather than inherently flawed.
  • Editorial inference: a natural next test is queries with nested subqueries and HAVING clauses, since the demonstrated benchmark set exercises flat filters, joins, group-by, and aggregates but not nested query plans.
  • Editorial inference: combining the commitment-and-proof structure with differential privacy could make privacy budgets auditable, though the paper notes this would add circuit overhead.
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

3 major / 3 minor

Summary. PoneglyphDB is a proposed database system that uses non-interactive zero-knowledge proofs to let a prover answer SQL queries over a private database while convincing clients of correct execution. The paper's contribution is a set of PLONKish/Halo2 gates for range checks, sorting, group-by, joins, and aggregation, which are combined into circuits for TPC-H queries, with experiments comparing proof generation time and memory against ZKSQL and Libra. The paper claims to be the first system to combine zero-knowledge, non-interactive operation, and support for arbitrary SQL queries, and it reports substantial speedups over Libra and competitive or better performance than ZKSQL on the selected workload.

Significance. If the gate designs were sound, the paper would be a meaningful advance: it would demonstrate that a non-interactive ZKP stack can express a substantial fragment of SQL with practical proof-generation times, and its use of lookup tables, recursive composition, and arithmetic PLONKish circuits is a reasonable engineering direction. The paper grounds its comparisons in the standard TPC-H benchmark and existing systems (ZKSQL and Libra), and it does not rely on fitted parameters or self-cited artifacts. However, two central gate constructions, the group-by boundary detector and the conditional range-check gate, are unsound as written, and because all six evaluated TPC-H queries depend on these gates, the experimental claims currently rest on incorrect circuits.

major comments (3)
  1. [Section 4.3, Eqs. (6)-(7)] The constraints in Eqs. (6)-(7) implement an equality indicator, not a bin-boundary marker. For every satisfying assignment, b=1 when v1=v2 and b=0 when v1 differs from v2: Eq. (6) with p=0 gives b=1 for equal values, and for unequal values Eq. (7) forces p=1/(v1-v2), hence b=0. The text, however, states that b=1 marks a record as the start or end of a bin, which should occur exactly when the record's group-by value differs from the previous adjacent record (for a start) or from the next adjacent record (for an end). The paper's own correctness analysis in this subsection confirms the equality-indicator reading. Consequently, the S and E columns used in Example 4.2 and the SUM and aggregation gates built on them are inverted for runs of equal values; for a sorted group-by column [1,1,2], the interior equal pair is marked as a boundary and the true end of the first bin is not. Since Q1, Q3, Q5, Q8, Q9, and Q18 all use group-by and/or order-by, the soundness of every reported TPC-H circuit depends on this gate. The fix is localized, such as defining separate start and end flags with constraints tied to adjacent unequal values, but it must be made before the experimental results can be taken as evidence for the system's claims.
  2. [Section 4.1, Design D and Eq. (4)] The conditional range-check gate does not constrain the prover-determined check column. Equation (4) only range-checks the value (x-t)+check*u; there is no constraint imposing that check lies in {0,1} and no constraint relating check to the sign of x-t. Because u is invertible in the finite field, a prover can, for any x-t, choose a field element check that makes this expression an element of [0,u); for example, with x-t=100 and u=10, taking check=-10 gives 0. Thus the gate accepts witnesses in which check is neither 0 nor 1 and does not encode whether x<t. The paper's Correctness paragraph argues that setting the binary variable check correctly is sufficient, but soundness requires that incorrect assignments be rejected by the constraints, not merely that a correct assignment exists. This unsoundness propagates to the sort gate, which uses Eq. (4) to enforce R_i <= R_{i+1}, and to all filtering and join predicates built on range checks. The gate needs explicit constraints, for instance check*(check-1)=0 together with a constraint that links check to the difference x-t, such as a sign-carrying decomposition.
  3. [Section 4.4, Join gate] The disjointness argument for the join gate is under-specified in a load-bearing way. The text first says that a sorted table S is created to store the unique values in T1'_non-p and T2'_non-p, then later says that S is a permutation of T1_de union T2_de and satisfies S_i < S_{i+1}. If union is interpreted as set union of deduplicated values, strict increasingness of S cannot detect a value appearing in both T1'_non-p and T2'_non-p, because the duplicate is removed before S is built. If union is intended as multiset union, then the earlier 'unique values' wording must be corrected and the proof should state explicitly that duplicates are preserved until the strict-inequality check. As written, the completeness and exclusivity claims in the join correctness proof do not follow from the described constraints.
minor comments (3)
  1. [Section 3.3] The section title 'Application Framework Disuccsion' contains a typo and should read 'Application Framework Discussion'.
  2. [Author affiliations] The affiliation of all three authors is spelled 'Unversity of California, Irvine'; this should be corrected to 'University'.
  3. [Table 1] The symbols '%' and '!' in Table 1 are not explained in the caption; please add a legend stating which symbol denotes support and which denotes lack of support.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: PoneglyphDB's gates are built from external cryptographic primitives and benchmarked against external systems; the paper's main defect is a correctness bug in the group-by boundary constraints, not a circular derivation.

full rationale

The paper's derivation chain is self-contained in the sense relevant to circularity analysis. The range-check gate is a direct adaptation of the external Plookup framework (Section 4.1, Equations 1-3), the sort gate uses a standalone permutation check plus adjacent-order inequalities (Section 4.2, Equation 5), the group-by gate relies on sorting plus the equality-check constraints in Equations 6 and 7, and the join gate uses permutation checks, lookup-table deduplication, and equality constraints (Section 4.4). None of these constructions is defined in terms of the paper's own conclusions or performance claims. There are no fitted parameters that are later renamed as predictions, and the experimental comparison is against external implementations (ZKSQL and Libra) using the same TPC-H queries. The paper does cite prior work by the same authors (references [24], [25], and [31]), but those citations appear only in related-work or application-context discussion and do not carry any load-bearing step of the circuit derivations or the benchmark claims. The one substantive concern in the manuscript is a correctness issue, not circularity: in Section 4.3, Equation 6 gives b = 1 - (v1-v2)p, so for v1 = v2 the constraint forces b = 1, meaning b is an equality indicator; the text, however, states that b marks starting or ending records of group-by bins, which should be 1 exactly when adjacent values differ. This inverted semantics would break the group-by and aggregation gates as written, but that is an unsound-constraint or implementation bug, not a case of a result reducing to its inputs by construction. Because no prediction or claimed result is equivalent to an input, fitted value, or self-citation chain, the circularity score is 0.

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

The central claims rest entirely on external cryptographic components (Halo2, Plookup) and on circuit-level premises that the paper states but does not validate. No free parameters are fitted to data. The most fragile premises are the group-by boundary constraint, the conditional range check's prover-determined check column, and the assumption that fixed-width integer encoding covers SQL semantics.

assumptions (5)
  • standard math The random challenges alpha and beta in Eqs. 2, 3, and 5 make multiset equality checks sound with overwhelming probability.
    Used to prove permutation integrity in range check and sort gates; requires Schwartz-Zippel style reasoning that the paper does not state.
  • domain assumption Halo2's PLONKish arithmetization and recursive proof composition provide completeness, knowledge soundness, and zero-knowledge.
    The paper delegates all cryptographic security to Halo2 and does not prove these properties itself.
  • domain assumption All SQL values can be represented as fixed-width 64-bit integers with a known upper bound u, and floating point can be converted without semantic loss.
    Range check Design D requires an upper bound u; Section 5.1 converts all floats to 64-bit integers; NULLs and native decimals are not handled.
  • ad hoc to paper The prover-determined check column in Design D is forced to the correct binary value by the range constraint even though no explicit constraint links check, x, and t.
    Section 4.1 Design D says check values are prover-determined with no explicit constraints among x, t, and check, and asserts proof generation fails if they are wrong.
  • ad hoc to paper Equation 6 correctly detects group-by bin boundaries.
    This premise is false as written: b=1 for equal adjacent values, so start/end indices cannot be computed correctly; see Section 4.3.

how reviews work

0 comments
Cite this review

Pith. "Pith review of PoneglyphDB: Efficient Non-interactive Zero-Knowledge Proofs for Arbitrary SQL-Query Verification." pith.science (2026). https://pith.science/paper/FKZAKC6N

@misc{pith2026241115031,
  author       = {Pith},
  title        = {Pith review of: PoneglyphDB: Efficient Non-interactive Zero-Knowledge Proofs for Arbitrary SQL-Query Verification},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FKZAKC6N}},
  note         = {Machine review of arXiv:2411.15031}
}
read the original abstract

In database applications involving sensitive data, the dual imperatives of data confidentiality and provable query processing are important. This paper introduces PoneglyphDB, a database system that leverages non-interactive zero-knowledge proofs (ZKP) to support both confidentiality and provability. Unlike traditional databases, PoneglyphDB enhances confidentiality by ensuring that raw data remains exclusively with the host, while also enabling verification of the correctness of query responses by providing proofs to clients. The main innovation in this paper is proposing efficient ZKP designs (called circuits) for basic operations in SQL query processing. These basic operation circuits are then combined to form ZKP circuits for larger, more complex queries. PoneglyphDB's circuits are carefully designed to be efficient by utilizing advances in cryptography such as PLONKish-based circuits, recursive proof composition techniques, and designs with low-order polynomial constraints. We demonstrate the performance of PoneglyphDB with the standard TPC-H benchmark. Our experimental results show that PoneglyphDB can efficiently achieve both confidentiality and provability, outperforming existing state-of-the-art ZKP methods.

Figures

Figures reproduced from arXiv: 2411.15031 by the authors.

Figure 1
Figure 1. PLONKish circuits illustration for calculating the [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 3
Figure 3. Detailed components for generating ZK proofs. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Range check with lookup tables illustration. [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: Illustration with the SQL query “SELECT SUM(D2) [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 8
Figure 8. Figure 8: PoneglyphDB’s performance breakdown of different proof generation steps for Q1.              "  "      [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: PoneglyphDB’s performance breakdown of different proof generation steps for Q3. 5.4 Benchmarking with Libra Since Libra is a non-interactive ZKP system, we benchmarked Poneg￾lyphDB against Libra in terms of three critical factors: proving time, verification time, and p…
Figure 10
Figure 10. Figure 10: Proof generation time and memory usage over data [PITH_FULL_IMAGE:figures/full_fig_p013_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

56 extracted references · 51 canonical work pages

  1. [1]

    Rakesh Agrawal, Jerry Kiernan, Ramakrishnan Srikant, and Yirong Xu. 2002. Hippocratic databases. In VLDB’02: Proceedings of the 28th International Conference on Very Large Databases. Elsevier, 143–154

    work page 2002

  2. [2]

    AKM Mubashwir Alam, Justin Boyce, and Keke Chen. 2023. SGX-MR-Prot: Efficient and Developer-Friendly Access-Pattern Protection in Trusted Execution SIGMOD’25, June 22-27, 2025, Berlin, Germany Trovato and Tobin, et al. Environments. In 2023 IEEE 43rd International Conference on Distributed Computing Systems (ICDCS). IEEE, 1029–1032

    work page 2023

  3. [3]

    Arvind Arasu, Ken Eguro, Raghav Kaushik, Donald Kossmann, Pingfan Meng, Vineet Pandey, and Ravi Ramamurthy. 2017. Concerto: A high concurrency key-value store with integrity. In Proceedings of the 2017 ACM International Conference on Management of Data. 251–266

    work page 2017

  4. [4]

    Sumeet Bajaj and Radu Sion. 2013. CorrectDB: SQL engine with practical query authentication. Proceedings of the VLDB Endowment6, 7 (2013), 529–540

    work page 2013

  5. [5]

    Eli Ben-Sasson, Iddo Bentov, Yinon Horesh, and Michael Riabzev. 2019. Scalable zero knowledge with no trusted setup. InAdvances in Cryptology–CRYPTO 2019: 39th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 18–22, 2019, Proceedings, Part III 39. Springer, 701–732

    work page 2019

  6. [6]

    Eli Ben-Sasson, Alessandro Chiesa, Daniel Genkin, Eran Tromer, and Madars Virza. 2013. SNARKs for C: Verifying program executions succinctly and in zero knowledge. In Annual cryptology conference. Springer, 90–108

    work page 2013

  7. [7]

    Eli Ben-Sasson, Alessandro Chiesa, Eran Tromer, and Madars Virza. 2017. Scalable zero knowledge via cycles of elliptic curves.Algorithmica 79, 4 (2017), 1102–1160

    work page 2017

  8. [8]

    Jonathan Bootle, Andrea Cerulli, Pyrros Chaidos, Jens Groth, and Christophe Petit

    work page

Show all 56 references
  1. [9]

    Sean Bowe, Jack Grigg, and Daira Hopwood. 2019. Recursive proof composition without a trusted setup. Cryptology ePrint Archive(2019)

    2019

  2. [10]

    Benedikt Bünz, Jonathan Bootle, Dan Boneh, Andrew Poelstra, Pieter Wuille, and Greg Maxwell. 2018. Bulletproofs: Short proofs for confidential transactions and more. In 2018 IEEE symposium on security and privacy (SP). IEEE, 315–334

    2018

  3. [11]

    Benedikt Bünz, Alessandro Chiesa, Pratyush Mishra, and Nicholas Spooner

  4. [12]

    Ji-Won Byun and Ninghui Li. 2008. Purpose based access control for privacy protection in relational database systems.The VLDB Journal17 (2008), 603–619

    2008

  5. [13]

    Alessandro Chiesa, Yuncong Hu, Mary Maller, Pratyush Mishra, Noah Vesely, and Nicholas Ward. 2020. Marlin: Preprocessing zkSNARKs with universal and updatable SRS. InAdvances in Cryptology–EUROCRYPT 2020: 39th Annual Inter- national Conference on the Theory and Applications of...

    2020

  6. [14]

    Tal Derei, Benjamin Aulenbach, Victor Carolino, Caleb Geren, Michael Kaufman, Jonathan Klein, Rishad Islam Shanto, and Henry F Korth. 2023. Scaling Zero-Knowledge to Verifiable Databases. InProceedings of the 1st Workshop on Verifiable Database Systems. 1–9

    2023

  7. [15]

    Cynthia Dwork. 2006. Differential privacy. In International colloquium on automata, languages, and programming. Springer, 1–12

    2006

  8. [16]

    Amos Fiat and Adi Shamir. 1986. How to prove yourself: Practical solutions to identification and signature problems. InConference on the theory and application of cryptographic techniques. Springer, 186–194

    1986

  9. [17]

    Uriel Fiege, Amos Fiat, and Adi Shamir. 1987. Zero knowledge proofs of identity. In Proceedings of the nineteenth annual ACM symposium on Theory of computing. 210–217

    1987

  10. [18]

    Georg Fuchsbauer, Eike Kiltz, and Julian Loss. 2018. The algebraic group model and its applications. In Advances in Cryptology–CRYPTO 2018: 38th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 19–23, 2018, Proceedings, Part II 38. Springer, 33–62

    2018

  11. [19]

    Ariel Gabizon and Zachary J Williamson. 2020. plookup: A simplified polynomial protocol for lookup tables. Cryptology ePrint Archive(2020)

    2020

  12. [20]

    Shafi Goldwasser, Yael Tauman Kalai, and Guy N Rothblum. 2015. Delegating computation: interactive proofs for muggles. Journal of the ACM (JACM)62, 4 (2015), 1–64

    2015

  13. [21]

    Goldwasser, S

    S. Goldwasser, S. Micali, and C. Rackoff. 1985. The Knowledge Complexity of Interactive Proof-Systems. In Proceedings of the 17th Annual ACM Symposium on Theory of Computing, May 6-8, 1985, Providence, Rhode Island, USA

    1985

  14. [22]

    Shafi Goldwasser and Michael Sipser. 1986. Private coins versus public coins in interactive proof systems. InProceedings of the eighteenth annual ACM symposium on Theory of computing. 59–68

    1986

  15. [23]

    Michael T Goodrich, Michael Mitzenmacher, Olga Ohrimenko, and Roberto Tamassia. 2012. Privacy-preserving group data access via stateless oblivious RAM simulation. In Proceedings of the twenty-third annual ACM-SIAM symposium on Discrete Algorithms. SIAM, 157–167

    2012

  16. [24]

    Binbin Gu and Faisal Nawab. 2024. zk-oracle: Trusted off-chain compute and storage for decentralized applications. Distributed and Parallel Databases(2024), 1–24

    2024

  17. [25]

    Binbin Gu, Abhishek Singh, Yinan Zhou, Juncheng Fang, and Faisal Nawab. 2023. ML on Chain: The Case and Taxonomy of Machine Learning on Blockchain. In 2023 IEEE International Conference on Blockchain and Cryptocurrency (ICBC). IEEE, 1–18

    2023

  18. [26]

    Noah Johnson, Joseph P Near, and Dawn Song. 2018. Towards practical differential privacy for SQL queries. Proceedings of the VLDB Endowment 11, 5 (2018), 526–539

    2018

  19. [27]

    Gunawi, Cody Hammock, Joe Mambretti, Alexander Barnes, François Halbach, Alex Rocha, and Joe Stubbs

    Kate Keahey, Jason Anderson, Zhuo Zhen, Pierre Riteau, Paul Ruth, Dan Stanzione, Mert Cevik, Jacob Colleran, Haryadi S. Gunawi, Cody Hammock, Joe Mambretti, Alexander Barnes, François Halbach, Alex Rocha, and Joe Stubbs. 2020. Lessons Learned from the Chameleon Testbed. InProc...

    2020

  20. [28]

    Abhiram Kothapalli, Srinath Setty, and Ioanna Tzialla. 2022. Nova: Recursive zero-knowledge arguments from folding schemes. In Annual International Cryptology Conference. Springer, 359–388

    2022

  21. [29]

    Duc V Le, Lizzy Tengana Hurtado, Adil Ahmad, Mohsen Minaei, Byoungyoung Lee, and Aniket Kate. 2020. A tale of two trees: one writes, and other reads. Proceedings on Privacy Enhancing Technologies(2020)

    2020

  22. [30]

    Xiling Li, Chenkai Weng, Yongxin Xu, Xiao Wang, and Jennie Rogers. 2023. ZKSQL: Verifiable and Efficient Query Evaluation with Zero-Knowledge Proofs. Proceedings of the VLDB Endowment16, 8 (2023), 1804–1816

    2023

  23. [31]

    Qi Lin, Binbin Gu, and Faisal Nawab. 2024. RollStore: Hybrid Onchain-Offchain Data Indexing for Blockchain Applications. IEEE Transactions on Knowledge and Data Engineering(2024)

    2024

  24. [32]

    Ralph C. Merkle. 1980. Protocols for Public Key Cryptosystems. In Pro- ceedings of the 1980 IEEE Symposium on Security and Privacy, Oakland, California, USA, April 14-16, 1980 . IEEE Computer Society, 122–134. https://doi.org/10.1109/SP.1980.10006

    1980

  25. [33]

    Dimitrios Papadopoulos, Stavros Papadopoulos, and Nikos Triandopoulos. 2014. Taking authenticated range queries to arbitrary dimensions. In Proceedings of the 2014 ACM SIGSAC Conference on Computer and Communications Security. 819–830

    2014

  26. [34]

    Dimitrios Papadopoulos, Charalampos Papamanthou, Roberto Tamassia, and Nikos Triandopoulos. 2015. Practical authenticated pattern matching with optimal proof size. Proceedings of the VLDB Endowment8, 7 (2015), 750–761

    2015

  27. [35]

    Mohamed Sabt, Mohammed Achemlal, and Abdelmadjid Bouabdallah. 2015. Trusted execution environment: what it is, and what it is not. In 2015 IEEE Trustcom/BigDataSE/Ispa, V ol. 1. IEEE, 57–64

    2015

  28. [36]

    Srinath Setty, Justin Thaler, and Riad Wahby. 2024. Unlocking the lookup singularity with Lasso. In Annual International Conference on the Theory and Applications of Cryptographic Techniques. Springer, 180–209

    2024

  29. [37]

    Rohit Sinha and Mihai Christodorescu. 2018. Veritasdb: High throughput key-value store with integrity. Cryptology ePrint Archive(2018)

    2018

  30. [38]

    Roberto Tamassia. 2003. Authenticated data structures. InAlgorithms-ESA 2003: 11th Annual European Symposium, Budapest, Hungary, September 16-19, 2003. Proceedings 11. Springer, 2–5

    2003

  31. [39]

    Transaction Processing Council. 2023. TPC-H Benchmark. http: //www.tpc.org/tpch/. Accessed: 2023-xx-xx

    2023

  32. [40]

    Tiacheng Xie, Jiaheng Zhang, Yupeng Zhang, Charalampos Papamanthou, and Dawn Song. 2019. Libra: Succinct zero-knowledge proofs with optimal prover computation. In Advances in Cryptology–CRYPTO 2019: 39th Annual International Cryptology Conference, Santa Barbara, CA, USA, Augus...

    2019

  33. [41]

    Yin Yang, Dimitris Papadias, Stavros Papadopoulos, and Panos Kalnis. 2009. Authenticated join processing in outsourced databases. InProceedings of the 2009 ACM SIGMOD International Conference on Management of data. 5–18

    2009

  34. [42]

    Cong Yue, Tien Tuan Anh Dinh, Zhongle Xie, Meihui Zhang, Gang Chen, Beng Chin Ooi, and Xiaokui Xiao. 2022. GlassDB: An efficient verifiable ledger database system through transparency.arXiv preprint arXiv:2207.00944(2022)

    2022 arXiv

  35. [43]

    Cong Yue, Meihui Zhang, Changhao Zhu, Gang Chen, Dumitrel Loghin, and Beng Chin Ooi. 2023. VeriBench: Analyzing the Performance of Database Systems with Verifiability.Proceedings of the VLDB Endowment16, 9 (2023), 2145–2157

    2023

  36. [44]

    Zcash. [n.d.]. halo2. https://github.com/zcash/halo2

  37. [45]

    Zcash. [n.d.]. Halo2 Protocol. https://zcash.github.io/halo2/design/protocol.html

  38. [46]

    Zcash. [n.d.]. PLONKish Arithmetization. https://zcash.github.io/halo2/concepts/ arithmetization.html

  39. [47]

    Yupeng Zhang, Daniel Genkin, Jonathan Katz, Dimitrios Papadopoulos, and Charalampos Papamanthou. 2017. vSQL: Verifying arbitrary SQL queries over dynamic outsourced databases. In2017 IEEE Symposium on Security and Privacy (SP). IEEE, 863–880

    2017

  40. [48]

    Yupeng Zhang, Daniel Genkin, Jonathan Katz, Dimitrios Papadopoulos, and Charalampos Papamanthou. 2017. A zero-knowledge version of vSQL.Cryptology ePrint Archive(2017)

    2017

  41. [49]

    Yupeng Zhang, Jonathan Katz, and Charalampos Papamanthou. 2015. IntegriDB: Verifiable SQL for outsourced databases. InProceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security. 1480–1491

    2015

  42. [50]

    Qingji Zheng, Shouhuai Xu, and Giuseppe Ateniese. 2012. Efficient query integrity for outsourced dynamic databases. In Proceedings of the 2012 ACM Workshop on Cloud computing security workshop. 71–82

    2012

  43. [51]

    Wenting Zheng, Ankur Dave, Jethro G Beekman, Raluca Ada Popa, Joseph E Gonzalez, and Ion Stoica. 2017. Opaque: An oblivious and encrypted distributed analytics platform. In 14th USENIX Symposium on Networked Systems Design and Implementation (NSDI 17). 283–298. PoneglyphDB: Ef...

    2017

  44. [52]

    Wenchao Zhou, Yifan Cai, Yanqing Peng, Sheng Wang, Ke Ma, and Feifei Li. 2021. Veridb: An sgx-based verifiable database. InProceedings of the 2021 International Conference on Management of Data. 2182–2194

    2021

  45. [53]

    Yizheng Zhu, Yuncheng Wu, Zhaojing Luo, Beng Chin Ooi, and Xiaokui Xiao

  46. [2016]

    Efficient zero-knowledge arguments for arithmetic circuits in the discrete log setting. In Advances in Cryptology–EUROCRYPT 2016: 35th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Vienna, Austria, May 8-12, 2016, Proceedings, Part...

    2016

  47. [2020]

    In Theory of Cryptography: 18th International Conference, TCC 2020, Durham, NC, USA, November 16–19, 2020, Proceedings, Part II 18

    Recursive proof composition from accumulation schemes. In Theory of Cryptography: 18th International Conference, TCC 2020, Durham, NC, USA, November 16–19, 2020, Proceedings, Part II 18. Springer, 1–18

    2020

  48. [2023]

    arXiv preprint arXiv:2311.15310(2023)

    Secure and verifiable data collaboration with low-cost zero-knowledge proofs. arXiv preprint arXiv:2311.15310(2023)

    2023 arXiv

Pith tools

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