succinct non-interactive zero knowledge for a von neumann … · 2016-02-20 · 782 23rd usenix...

This paper is included in the Proceedings of the 23rd USENIX Security Symposium.

August 20–22, 2014 • San Diego, CA

ISBN 978-1-931971-15-7

Open access to the Proceedings of the 23rd USENIX Security Symposium

is sponsored by USENIX

Succinct Non-Interactive Zero Knowledge for a von Neumann Architecture

Eli Ben-Sasson, Technion—Israel Institute of Technology; Alessandro Chiesa, Massachusetts Institute of Technology; Eran Tromer, Tel Aviv University;

Madars Virza, Massachusetts Institute of Technology

https://www.usenix.org/conference/usenixsecurity14/technical-sessions/presentation/ben-sasson

USENIX Association 23rd USENIX Security Symposium 781

Succinct Non-Interactive Zero Knowledge for a von Neumann Architecture

Eli Ben-SassonTechnion

Alessandro ChiesaMIT

Eran TromerTel Aviv University

Madars VirzaMIT

AbstractWe build a system that provides succinct non-interactivezero-knowledge proofs (zk-SNARKs) for program execu-tions on a von Neumann RISC architecture. The systemhas two components: a cryptographic proof system forverifying satisfiability of arithmetic circuits, and a circuitgenerator to translate program executions to such circuits.Our design of both components improves in functionalityand efficiency over prior work, as follows.

Our circuit generator is the first to be universal: itdoes not need to know the program, but only a boundon its running time. Moreover, the size of the outputcircuit depends additively (rather than multiplicatively)on program size, allowing verification of larger programs.

The cryptographic proof system improves proving andverification times, by leveraging new algorithms and apairing library tailored to the protocol.

We evaluated our system for programs with up to10,000 instructions, running for up to 32,000 machinesteps, each of which can arbitrarily access random-accessmemory; and also demonstrated it executing programsthat use just-in-time compilation. Our proofs are 230bytes long at 80 bits of security, or 288 bytes long at128 bits of security. Typical verification time is 5 ms,regardless of the original program’s running time.

1 Introduction

1.1 GoalConsider the setting where a client owns a public input x,a server owns a private input w, and the client wishes tolearn z := F(x,w) for a program F known to both parties.For instance, x may be a query, w a confidential database,and F the program that executes the query on the database.Security. The client is concerned about integrity ofcomputation: how can he ascertain that the server reportsthe correct output z? In contrast, the server is concernedabout confidentiality of his own input: how can he preventthe client from learning information about w?

Cryptography offers a powerful tool to address these se-curity concerns: zero-knowledge proofs [43]. The server,acting as the prover, attempts to convince the client, act-ing as the verifier, that the following NP statement is true:“there exists w such that z = F(x,w)”. Indeed:• The soundness property of the proof system guarantees

that, if the NP statement is false, the prover cannotconvince the verifier (with high probability). Thus,soundness addresses the client’s integrity concern.

• The zero-knowledge property of the proof system guar-antees that, if the NP statement is true, the prover canconvince the verifier without leaking any informationabout w (beyond was is leaked by the output z). Thus,zero knowledge addresses the server’s confidentiality.

Moreover, the client sometimes not only seeks soundnessbut also proof of knowledge [43, 11], which guaranteesthat, whenever he is convinced, not only can he deducethat a witness w exists, but also that the server knows onesuch witness. This stronger property is often necessary tosecurity if F encodes cryptographic computations, and issatisfied by most zero-knowledge proof systems.

Efficiency. Besides the aforementioned security desider-ata, many settings also call for efficiency desiderata. Theclient may be either unable or unwilling to engage inlengthy interactions with the server, or to perform largecomputations beyond the “bare minimum” of sending theinput x and receiving the output z. For instance, the clientmay be a computationally-weak device with intermittentconnectivity (e.g., a smartphone).

Thus, it is desirable for the proof to be non-interactive[25, 55, 23]: the server just send the claimed output z,along with a non-interactive proof string π that atteststhat z is the correct output. Moreover, it is also desirablefor the proof to be succinct: π has size Oλ (1) and can beverified in time Oλ (|F |+ |x|+ |z|), where Oλ (·) is somepolynomial in a security parameter λ ; in other words, π isvery short and easy to verify (i.e., verification time doesnot depend on |w|, nor F’s running time).

782 23rd USENIX Security Symposium USENIX Association

zk-SNARKs. A proof system achieving the above se-curity and efficiency desiderata is called a (publicly-verifiable) zero-knowledge Succinct Non-interactive AR-gument of Knowledge (zk-SNARK). zk-SNARK con-structions can be applied to a wide range of security appli-cations, provided these constructions deliver good enoughefficiency, and support rich enough functionality (i.e., theclass of programs F that is supported).

Remark 1.1. In the zero-knowledge setting above, theclient does not have the server’s input, and so cannotconduct the computation on his own. Hence, it is notmeaningful to compare “efficiency of outsourced compu-tation at the server” and “efficiency of native execution atthe client”, because the latter was never an option. Non-interactive zero-knowledge proofs (and zk-SNARKs) areuseful regardless of cross-over points.

Our goal in this paper is to construct

a zk-SNARK implementation supporting executions on auniversal von Neumann RISC machine.

1.2 Prior work

zk-SNARKs. Many works have obtained zk-SNARKconstructions [45, 51, 38, 22, 56, 16, 52, 27]. Three ofthese [56, 16, 27] provide implementations, and thus webriefly recall them. Parno et al. [56] present two maincontributions.• A zk-SNARK, with essentially-optimal asymptotics,

for arithmetic circuit satisfiability, based on quadraticarithmetic programs (QAPs) [38]. They accompanytheir construction with an implementation.

• A compiler that maps C programs with fixed memoryaccesses and bounded control flow (e.g., array accessesand loop iteration bounds are compile-time constants)into corresponding arithmetic circuits.

Ben-Sasson et al. [16] present three main contributions.• Also a QAP-based zk-SNARK with essentially-

optimal asymptotics for arithmetic circuit satisfiability,and a corresponding implementation. Their construc-tion follows the linear-interactive proofs of [22].

• A simple RISC architecture, TinyRAM, along with acircuit generator for generating arithmetic circuits thatverify correct execution of TinyRAM programs.

• A compiler that, given a C program, produces a corre-sponding TinyRAM program.

Finally, Braun et al. [27] re-implemented the protocolof [56] and combined it with a circuit generator that in-corporates memory-checking techniques [24] to supportrandom-access memory [14].

Outsourcing computation to powerful servers. Nu-merous works [63, 65, 66, 64, 32, 68, 71, 67, 27] seek toverifiably outsource computation to untrusted powerful

servers, e.g., in order to make use of cheaper cycles orstorage. (See Appendix A for a summary.) We stress thatverifiable outsourcing of computations is not our goal.Rather, as mentioned, we study functionality and effi-ciency aspects of non-interactive zero-knowledge proofs,which are useful even when applied to relatively-smallcomputations, and even with high overheads.

Compared to most protocols to outsource computations,known zk-SNARKs use “heavyweight” techniques, suchas probabilistically-checkable proofs [6] and expensivepairing-based cryptography. The optimal choice of pro-tocol, and whether it actually pays off compared to localnative execution, are complex, computation-dependentquestions [71], and we leave to future work the ques-tion of whether zk-SNARKs are useful for the goal ofoutsourcing computations.

1.3 Limitations of prior workRecent work has made tremendous progress in takingzk-SNARKs from asymptotic theory into concrete im-plementations. Yet, known implementations suffer fromseveral limitations.

Per-program key generation. As in any non-interactivezero-knowledge proof, a zk-SNARK requires a one-timetrusted setup of public parameters: a key generator sam-ples a proving key (used to generate proofs) and a ver-ification key (used to check proofs). However, currentzk-SNARK implementations [56, 16] require the setupphase to depend on the program F , which is hard-codedin the keys. Key generation is costly (quasilinear in F’sruntime) and is thus difficult to amortize if conductedanew for each program. More importantly, per-programkey generation requires, for each new choice of program,a trusted party’s help.

Limited support for high-level languages. Known cir-cuit generators have limited functionality or efficiency:(i) [56]’s circuit generator only supports programs with-out data dependencies, since memory accesses and loopiteration bounds cannot depend on a program’s input;(ii) [27]’s circuit generator allows data-dependent memoryaccesses, but each such access requires expensive hashingto verify Merkle-tree authentication paths; (iii) [16]’s cir-cuit generator supports arbitrary programs but its circuitsize scales inefficiently with program size (namely, it hassize Ω(T ) for -instruction T -step TinyRAM programs).Moreover, while there are techniques that mitigate someof the above limitations [72], these only apply in specialcases, and not do address general data dependencies, acommon occurrence in many programs.

Generic sub-algorithms. The aforementionedzk-SNARKs use several sub-algorithms, and in particularelliptic curves and pairings. Protocol-specific optimiza-tions are a key ingredient in fast implementations of

2


pairing-based protocols [59], yet prior implementationsonly utilize off-the-shelf cryptographic libraries, and misskey optimization opportunities.

1.4 ResultsWe present two main contributions: a new circuit genera-tor and a new zk-SNARK for circuits. These can be usedindependently, or combined to obtain an overall system.

1.4.1 A new circuit generator

We design and build a new circuit generator that incorpo-rates the following two main improvements.

(1) Our circuit generator is universal: when given inputbounds ,n,T , it produces a circuit that can verify theexecution of any program with ≤ instructions, on anyinput of size ≤ n, for ≤ T steps. Instead, all prior circuitgenerators [66, 64, 56, 16, 27] hardcoded the programin the circuit. Combined with a zk-SNARK for circuits(or any NP proof system for circuits), we achieve a no-table conceptual advance: once-and-for-all key genera-tion that allows verifying all programs up to a given size.This removes major issues in all prior systems: expen-sive per-program key generation, and the thorny issue ofconducting it anew in a trusted way for every program.

Our circuit generator supports a universal machinethat, like modern computers, follows the von Neumannparadigm (program and data lie in the same read/writeaddress space). Concretely, it supports a von NeumannRISC architecture called vnTinyRAM, a modification ofTinyRAM [17]. Thus, we also support programs leverag-ing techniques such as just-in-time compilation or self-modifying code [36, 58].

To compile C programs to the vnTinyRAM machinelanguage, we ported the GCC compiler to this architecture,building on the work of [16].

See Figure 1 for a functionality comparison with priorcircuit generators (for details, see [27, §2]).

Supported functionality [66, 64, 56] [16] [27] this workside-effect free comp. data-dep. mem. accesses × data-dep. contr. flow × × self-modifying code × × × universality × × ×

Figure 1: Functionality comparison among circuit generators.

(2) Our circuit generator efficiently handles larger arbi-trary programs: the size of the generated circuit C,n,Tis O

((+ n+ T ) · log(+ n+ T )

)gates. Thus, the de-

pendence on program size is additive, instead of multi-plicative as in [16], where the generated (non-universal)circuit has size Θ

((n+T ) ·(log(n+T )+)

). As Figure 2

shows, our efficiency improvement compared to [16] is

not merely asymptotic but yields sizable concrete sav-ings: as program size increases, our amortized per-cyclegate count is essentially unchanged, while that of [16]grows without bound, becoming orders of magnitudesmore expensive.

n = 102 |C,n,T |/T improvementT = 220 [16] this work= 103 1,872 1,368 1.4×= 104 10,872 1,371 7.9×= 105 100,872 1,400 72.1×= 106 1,000,872 1,694 590.8×

Figure 2: Per-cycle gate count improvements over [16].

An efficiency comparison with other non-universal cir-cuit generators [66, 64, 56, 27] is not well-defined. First,they support more restricted classes of programs, so a pro-grammer must “write around” the limited functionality.Second, their efficiency is not easily specified, since theoutput circuit is ad hoc for the given program, and the onlyway to know its size is to actually run the circuit generator.We expect, and find, that such circuit generators performbetter than ours for programs that are already “close to acircuit”, and worse for programs rich in data-dependentmemory accesses and control flow.

1.4.2 A new zk-SNARK for circuits

Our third contribution is a high-performance implementa-tion of a zk-SNARK for arithmetic circuits.

(3) We improve upon and implement the protocol of Parnoet al. [56]. Unlike previous zk-SNARK implementations[56, 16, 27], we do not use off-the-shelf cryptographiclibraries. Rather, we create a tailored implementationof the requisite components: the underlying finite-fieldarithmetic, elliptic-curve group arithmetic, pairing-basedchecks, and so on.

To facilitate comparison with prior work, we instanti-ate our techniques for two specific algebraic setups: weprovide an instantiation based on Edwards curves [33] at80 bits of security (as in [16]), and an instantiation basedon Barreto–Naehrig curves [9] at 128 bits of security (asin [56, 27]).

On our reference platform (a typical desktop), proofverification is fast: at 80-bit security, for an n-byte inputto the circuit, verification takes 4.7+0.0004 ·n millisec-onds, regardless of circuit size; at 128-bit security, it takes4.8+0.0005 ·n. The constant term dominates for smallinputs, and corresponds to the verifier’s pairing-basedchecks; in both cases, it is less than half the time for sep-arately evaluating the 12 requisite pairings of the checks.We achieve this saving by merging parts of the pairings’computation in a protocol-dependent way — another rea-son for a custom implementation of the underlying math.

3


Key generation and proof generation entail a per-gatecost. For example, for a circuit with 16 million gates: at80 bits of security, key generation takes 81 µs per gateand proving takes 109 µs per gate; at 128 bits of security,these per-gate costs mildly increase to 100 µs and 144 µs.

As in previous zk-SNARK implementations, proofshave constant size (independent of the circuit or inputsize); for us, they are 230 bytes at 80 bits of security, and288 bytes at 128 bits of security.

Compared to previous implementations of zk-SNARKsfor circuits [56, 16, 27], our implementation improvesboth proving and verification times, e.g., see Figure 3.

80 bits of security 128 bits of security[16] this impr. [56] this impr.

Key gen. 306s 97s 3.2× 123s 117s 1.1×Prover 351s 115s 3.1× 784s 147s 5.3×Verifier 66.1ms 4.9ms 13.5× 9.2ms 5.1ms 1.8×Proof 322B 230B 1.4× 288B 288B (same)

Figure 3: Comparison with prior zk-SNARKs for a 1-million-gate arith-metic circuit and a 1000-bit input, running on our benchmarking ma-chine, using software provided by the respective authors. Since [27] isa re-implementation of [56], we only include the latter’s performance.(N = 5 and std < 2%)

1.4.3 Two components: independent or combined

Our new circuit generator and our new zk-SNARK forcircuits can be used independently. For instance, thecircuit generator can (up to interface matching) replacethe circuit generators in [66, 64, 56, 16, 27], thus grantingthese systems universality. Similarly, our zk-SNARKfor circuits can replace the underlying zk-SNARKs in[56, 16, 27], or be used directly in applications where asuitable circuit is already specified.

Combining these two components, we obtain a fullsystem: a zk-SNARK for proving/verifying correctness ofvnTinyRAM computations; see Figure 4 and Figure 5 fordiagrams of this system. We evaluated this overall sys-tem for programs with up to 10,000 instructions, runningfor up to 32,000 steps. Verification time is, again, onlyfew milliseconds, independent of the running time of thevnTinyRAM program, even when program size and inputsize are kilobytes. Proofs, as mentioned, have a smallconstant size. Key generation and proof generation entaila per-cycle cost, with a dependence on program size that“tapers off” as computation length increases. For instance,at 128-bit security and vnTinyRAM with a word size of32 bits, key generation takes 210ms per cycle and provingtakes 100ms per cycle, for 8K-instruction programs.

JIT case study: efficient memcpy. Besides evaluat-ing individual components, we give an example demon-strating the rich functionality supported by the integratedsystem. We wrote a vnTinyRAM implementation ofmemcpy that leverages just-in-time compilation (in par-

circuit generator

zk-SNARK key generator

proving key

verification key

program size bound

time bound input size bound

universal circuit

OFFLINE PHASE (ONCE) Key Generator

Figure 4: Offline phase (once). The key generator outputs a provingkey and verification key, for proving and verifying correctness of anyprogram execution meeting the given bounds.

witness map

zk-SNARK prover

zk-SNARK verifier

proving key program input

proof auxiliary input

(nondeterminism)

accept/ reject

verif. key

circuit assignment

ONLINE PHASE (ANY NUMBER OF TIMES) Prover Verifier

program input

Figure 5: Online phase (any number of times). The prover sends ashort and easy-to-verify proof to a verifier. This can be repeated anynumber of times, each time for a different program and input.

ticular, dynamic loop unrolling) to require fewer cycles.(See Section B.)

2 Preliminaries

F[z] denotes the ring of univariate polynomials over F,and by F≤d [z] the subring of polynomials of degree ≤ d.Concatenation of vectors/scalars is denoted by .

2.1 Arithmetic circuitsGiven a finite field F, an F-arithmetic circuit takes inputsthat are elements in F, and its gates output elements in F.The circuits we consider only have bilinear gates.1

Definition 2.1. Let n,h, l respectively denote the input,witness, and output size. The circuit satisfaction prob-lem of a circuit C : Fn ×Fh → Fl with bilinear gates isdefined by the relation RC = (x,a)∈ Fn×Fh : C(x,a) =0l and language LC = x ∈ Fn : ∃a ∈ Fh, C(x,a) = 0l.

All the arithmetic circuits we consider are over primefields Fp. In this case, when passing boolean strings asinputs to arithmetic circuits, we pack the string’s bits intoas few field elements as possible: given s ∈ 0,1m, we

use [[s]]mp to denote the vector x ∈ F|m|pp , where |m|p :=

m/log p, such that the binary representation of xi ∈Fp is the i-th block of log p bits in s (padded with 0’s ifneeded). We extend the notation [[s]]mp to binary strings s ∈0,1n with n < m bits via padding: [[s]]mp := [[s0m−n]]mp .

2.2 Quadratic arithmetic programsOur zk-SNARK leverages quadratic arithmetic programs(QAPs), introduced by Gennaro et al. [38].

Definition 2.2. A quadratic arithmetic program of sizem and degree d over F is a tuple (A,B,C,Z), whereA,B,C are three vectors, each of m+ 1 polynomials inF≤d−1[z], and Z ∈ F[z] has degree exactly d.

1A gate with inputs x1, . . . ,xm ∈ F is bilinear if the output is〈a,(1,x1, . . . ,xm)〉 · 〈b,(1,x1, . . . ,xm)〉 for somea,b ∈ Fm+1. In particu-lar, these include addition, multiplication, and constant gates.

4


Like a circuit, a QAP induces a satisfaction problem:

Definition 2.3. The satisfaction problem of a size-mQAP (A,B,C,Z) is the relation R(A,B,C,Z) of pairs (x,s)such that (i) x ∈ Fn, s ∈ Fm, and n ≤ m; (ii) xi = si fori ∈ [n] (i.e., s extends x); and (iii) the polynomial Z(z)divides the following one:

(A0(z)+∑mi=1 siAi(z)) · (B0(z)+∑m

i=1 siBi(z))

−(C0(z)+∑mi=1 siCi(z)) .

We denote by L(A,B,C,Z) the language of R(A,B,C,Z).

Gennaro et al. [38] showed that circuit satisfiability canbe efficiently reduced to QAP satisfiability (which canthen be proved and verified using zk-SNARKs):

Lemma 2.4. There exist two polynomial-time algorithmsQAPinst,QAPwit that work as follows. For any circuitC : Fn×Fh → Fl with a wires and b gates, (A,B,C,Z) :=QAPinst(C) is a QAP of size m and degree d over F thatsatisfies the following three properties.• EFFICIENCY. It holds that m = a and d = b+ l +1.• COMPLETENESS. For any (x,a) ∈ RC, it holds that(x,s) ∈ R(A,B,C,Z), wheres := QAPwit(C,x,a).

• PROOF OF KNOWLEDGE. For any (x,s) ∈ R(A,B,C,Z),it holds that (x,a) ∈ RC, wherea is a prefix ofs.

• NON-DEGENERACY. The polynomials A0, . . . ,An arenonzero and distinct.

2.3 PairingsLet G1 and G2 be two cyclic groups of order r. Wedenote elements of G1,G2 via calligraphic letters suchas P,Q. We write G1 and G2 in additive notation.Let P1 be a generator of G1, i.e., G1 = αP1α∈Fr

(α is also viewed as an integer, hence αP1 is well-defined); let P2 be a generator for G2. A pairing isan efficient map e : G1 ×G2 → GT , where GT is also acyclic group of order r (which we write in multiplicativenotation), satisfying the following properties: (i) bilin-earity: for every nonzero elements α,β ∈ Fr, it holdsthat e(αP1,βP2) = e(P1,P2)

αβ ; (ii) non-degeneracy:e(P1,P2) is not the identity in GT .

2.4 zk-SNARKs for arithmetic circuitsA (preprocessing) zk-SNARK for F-arithmetic circuitsatisfiability (see, e.g., [22]) is a triple of polynomial-time algorithms (G,P,V ), called key generator, prover,and verifier. The key generator G, given a security pa-rameter λ and an F-arithmetic circuit C : Fn ×Fh → Fl ,samples a proving key pk and a verification key vk; theseare the proof system’s public parameters, which needto be generated only once per circuit. After that, any-one can use pk to generate non-interactive proofs for the

language LC, and anyone can use the vk to check theseproofs. Namely, given pk and any (x,a) ∈ RC, the hon-est prover P(pk,x,a) produces a proof π attesting thatx ∈ LC; the verifier V (vk,x,π) checks that π is a validproof forx ∈LC. A proof π is both a proof of knowledge,and a (statistical) zero-knowledge proof. The succinctnessproperty requires that π has length Oλ (1) and V runs intime Oλ (|x|), where Oλ hides a (fixed) polynomial in λ .

Constructions. Several zk-SNARK constructions areknown [45, 51, 38, 22, 56, 16, 52]. The most efficient onesare based on quadratic span programs (QSPs) [38, 52] orquadratic arithmetic programs (QAPs) [38, 22, 56, 16].We focused on QAP-based constructions, because QAPsallow for tighter reductions from arithmetic circuits (seeLemma 2.4). Concretely, we build on the QAP-basedzk-SNARK protocol of Parno et al. [56] (see Section 4).

Remark 2.5 (full succinctness). The key generator Gtakes C as input, and so its complexity is linear in |C|.One could require G to not take C as input, and haveits output keys work for all (polynomial-size) circuitsC; then, G’s running time would be independent of C.A zk-SNARK satisfying this stronger property is fullysuccinct. Theoretical constructions of such zk-SNARKsare known, based on various cryptographic assumptions[54, 69, 21]. Despite achieving essentially-optimal asymp-totics [6, 18, 15, 14, 21] no implementations of them havebeen reported to date.

2.5 A von Neumann RISC architectureBen-Sasson et al. [16] introduced TinyRAM, a HarvardRISC architecture with word-addressable memory. Wemodify TinyRAM to obtain vnTinyRAM, which differsfrom it in two main ways. First, vnTinyRAM follows thevon Neumann paradigm, whereby program and data arestored in the same read-write address space; programsmay use runtime code generation. Second, vnTinyRAMhas byte-addressable memory, along with instructions toload/store bytes or words.2

Besides the above main differences, vnTinyRAM isvery similar to TinyRAM. Namely, it is parametrized bythe word size, denoted W , and the number of registers,denoted K. The CPU state of the machine consists of(i) a W -bit program counter; (ii) K general-purpose W -bitregisters; (iii) a 1-bit condition flag. The full state of themachine also includes memory, which is a linear arrayof 2W bytes, and two tapes, each with a string of W -bitwords, and read-only in one direction. One tape is for aprimary input and the other for an auxiliary input(treated as nondeterministic, untrusted advice).

2Byte-addressing is common in programs performing array or stringoperations (and is a deeply-ingrained assumption in the GCC and LLVMcompilers), while word-addressing in programs performing arithmetic.

5


In memory, an instruction is represented as a doubleword (one word for an immediate, and another for opcode,etc.). Thus, a program is a list of address/double-wordpairs specifying the initial contents of memory; all othermemory locations assume the initial value of 0.

We define the language of accepting computations:

Definition 2.6. Fix bounds ,n,T . The language L,n,Tconsists of pairs ( , ) such that: (i) is a programwith ≤ instructions, (ii) is a primary input with ≤ nwords, (iii) there exists an auxiliary input s.t. ( , )accepts in ≤ T steps. We denote by R,n,T the relationcorresponding to L,n,T .

3 Our circuit generator

A circuit generator translates the correctness of suitably-bounded program executions into circuit satisfiability:given input bounds ,n,T , it produces a circuit that canverify the execution of any program with ≤ instructions,on any input of size ≤ n, for ≤ T steps. More precisely,using the notations [[s]]p (for packing the binary strings into field elements) and |s|p (for computing the num-ber of field elements required to pack s) introduced inSection 2.1, we define a (universal) circuit generator forvnTinyRAM as follows.

Definition 3.1. A (universal) circuit generator of effi-ciency f (·) over a prime field Fp is a polynomial-timealgorithm circ, together with an efficient witness mapwit, working as follows. For any program size bound, time bound T , and primary-input size bound n, C :=circ(,n,T ) is an Fp-arithmetic circuit C : Fm

p ×Fhp → Fl

p,for m := |2W |p + |nW |p and some h, l, where W is theword size (cf. Section 2.5).• EFFICIENCY. The circuit C has f (,n,T ) gates.• COMPLETENESS. Given any program , primary in-

put , and witness such that(( , ),

)∈ R,n,T , it

holds that (x,a) ∈ RC, wherex := [[ ]]2Wp [[ ]]nW

p anda := wit(,n,T, , , ).

• PROOF OF KNOWLEDGE. There is a polynomial-timealgorithm such that, given any (x,a) ∈ RC, outputs awitness for ( , ) ∈ L,n,T .

The circuit C output by circ is universal because it doesnot depend on the program or primary input , but onlyon their respective size bounds and n (as well as thetime bound T ). When combined with any proof systemfor circuit satisfiability (e.g., our zk-SNARK), this factenables the generation of the proof systems’ parametersto be universal as well. Namely, it is possible to generatekeys for all bound choices (e.g., in powers of 2) up to someconstant, once and for all; afterwards, one can pick thekeys corresponding to bounds fitting a given computation.This avoids expensive per-program key generation and,

more importantly, the need for a trusted party to conductkey generation anew for every program.

We construct a universal circuit generator with the fol-lowing efficiency:

Theorem 3.2. There is a circuit generator of efficiencyf (,n,T ) = O

((+ n + T ) · log(+ n + T )

)over any

prime field Fp of size p > 22W , where W is the wordsize (cf. Section 2.5).

(In our case, the condition p > 22W is always fulfilled.)

3.1 Past techniquesMost of the difficulties that arise when designing a circuitgenerator have to do with data dependencies. A circuit’stopology does not depend on its inputs but, in contrast,program flow and memory accesses depend on the choiceof program and the program’s inputs. Thus, a circuittasked with verifying program executions must be “ready”to support a multitude of program flows and memoryaccesses, despite the fact that its topology has alreadybeen fixed. Various techniques have been applied to thedesign of circuit generators.

Program analysis. In the extreme, if both the programand its inputs ( , ) are known in advance, designing

a circuit generator is simple: construct a circuit that eval-uates on ( , ) by preparing the circuit’s topology tomatch the pre-determined program flow and memory ac-cesses. But now suppose that only is known in advance,but not its inputs ( , ). In this case, by analyzingpiece by piece (e.g., separately examine the various loops,branches, and so on), one could try to design a circuit Cthat can handle different choices of inputs. Most priorcircuit generators [66, 64, 56, 27] take this approach.

However, this approach suffers from several limitations.First, the class of supported programs is not rich, be-cause support for data dependencies is limited. E.g., [56]requires array accesses and loop iteration bounds to becompile-time constants; also, while [27] supports data-dependent memory accesses, most program flow is alsorestricted to be known (or bounded) at compile-time; mit-igations are possible, but only in special cases [72]. Sec-ond, and more importantly, this approach does not seem toallow for designing universal circuit generators, becausethe program is not known in advance and thus there isno program to analyze.

Multiplex every access. Computers are universalrandom-access machines (RAMs), so one approach ofdesigning a universal circuit is to mimic a computer’sexecution, building a layered circuit as follows. The i-thlayer contains the entire state of the machine (CPU stateand random-access memory) at time step i, and layer i+1is computed from it by evaluating the transition function

6


of the machine, handling any accesses to memory via mul-tiplexing. While this approach supports arbitrary programflow, memory accesses are inefficiently supported; indeed,if memory has S addresses, the resulting circuit is huge:it has size Ω(T S).

Nondeterministic routing. Ben-Sasson et al. [14] sug-gested using nondeterministic routing on a Benes networkto support memory accesses efficiently; Our circuit gen-erator builds on the techniques of [14, 16], so we brieflyreview the main idea behind nondeterministic routing.

Following [14], Ben-Sasson et al. [16] introduced asimple computer architecture, called TinyRAM, and con-structed a routing-based circuit generator for TinyRAM.They define the following notions. A CPU state, denotedS, is the CPU’s contents (e.g., program counter, regis-ters, flags) at a given time step. An execution trace fora program , time bound T , and primary input is asequence tr = (S1, . . . ,ST ) of CPU states. An executiontrace tr is valid if there is an auxiliary input such thatthe execution trace induced by running on inputs ( , )is tr.

We seek an arithmetic circuit C for verifying that tr isvalid. We break this down by splitting validity into threesub-properties: (i) validity of instruction fetch (for eachtime step, the correct instruction is fetched); (ii) validityof instruction execution (for each time step, the fetchedinstruction is correctly executed); and (iii) validity ofmemory accesses (each load from an address retrieves thevalue of the last store to that address).

The first two properties are verified as follows. Con-struct a circuit C so that, for any two CPU states S and S′,C (S,S′,g) is satisfied for some “guess” g if and only if S′

can be reached from S (by fetching from the instructionindicated by the program counter in S and then executingit), for some state of memory. Then, properties (i) and(ii) hold if C (Si,Si+1, ·) is satisfiable for i = 1, . . . ,T −1.Thus, C contains T −1 copies of C , each wired to a pairof adjacent states in tr.

The third property is verified via nondeterministic rout-ing. Assume that C also gets as input MemSort(tr), whichequals to the sorting of tr by accessed memory addresses(breaking ties via timestamps), and write a circuit Cmem sothat validity of memory accesses holds if Cmem is satisfiedby each pair of adjacent states in MemSort(tr). (Roughly,Cmem checks consistency of “load-after-load”, “load-after-store”, and so on.) However, C merely gets some auxiliaryinput tr∗, which purports to be MemSort(tr). So C worksas follows: (a) C has T −1 copies of Cmem, each wired toa pair of adjacent states in tr∗; (b) C separately verifiesthat tr∗ =MemSort(tr) by routing on a O(T logT )-nodeBenes network. The switches of the routing network areset according to non-deterministic guesses (i.e., additionalvalues in the auxiliary input), and the routing networkmerely verifies that the switch settings induce a permu-

tation; this allows for a very tight reduction. (Knownconstructions that compute the correct permutation hidelarge constants in big-oh notation [1].)

Past inefficiencies. After filling in additional details,the construction of [16] reviewed above gives a circuitof size Θ

((n + T ) · (log(n + T ) + )

)= Ω( · T ). The

Ω( ·T ) arises from the fact that all of the instructionsin are hardcoded into each of the T −1 copies of C .Thus, besides being non-universal, the circuit scales inef-ficiently as grows (e.g., for = 104, C ’s size is alreadydominated by ’s size).

3.2 Our constructionIn comparison to [16], our circuit generator is universaland, moreover, its size only grows with +T (additivedependence on program size) instead of with ·T (mul-tiplicative dependence). As our evaluation demonstrates(see Section 5.1), the size improvement actually translatesinto significant savings in practice.

Instead of hardcoding the program into each copyof the circuit C , we follow the von Neumann paradigm,where the program lies in the same read/write memoryspace as data. We ensure that is loaded into the initialstate of memory, using a dedicated circuit; we then verifyinstruction fetch via the same routing network that is usedfor checking data loads/stores. While the idea is intuitive,realizing it involves numerous technical difficulties, someof which are described below.

Routing instructions and data. We extend an executiontrace to not only include CPU states but also instructions:tr= (S1, I1, . . . ,ST , IT ) where Si is the i-th CPU state, andIi is the i-th executed instruction. We seek an arithmeticcircuit C that checks tr, in this “extended” format, for thesame three properties as above: (i) validity of instructionfetch; (ii) validity of instruction execution; (iii) validity ofmemory accesses.

As in [16], checking that tr satisfies property (ii)is quite straightforward. Construct a circuit Cexe sothat, given two CPU states S,S′ and an instruction I,Cexe(S,S′, I,g) is satisfied, for some guess g, if and onlyif S′ can be reached from S, by executing I, for some stateof memory. Then, C contains T −1 copies of Cexe, eachwired to adjacent CPU states and an instruction, i.e., thei-th copy is Cexe(Si,Si+1, Ii,gi).

Unlike [16], though, we verify properties (i) and (iii)jointly, via the same routing network. The auxiliary inputnow contains tr∗ = (A1, . . . ,A2T ), purportedly equal to thememory-sorted list of both instructions fetches and CPUstates. (Since the program lies in the same read-writememory as data, an instruction fetch from is merelya special type of memory load.) Thus, to check that trsatisfies properties (i) and (iii), we design C to (a) verifythat tr∗ =MemSort(tr) via nondeterministic routing, and

7


(b) verify validity of all (i.e., instruction and data) memoryaccesses, via a new circuit C′

mem applied to each pair ofadjacent items Ai,Ai+1 in tr∗. Thus, in this approach,

is never replicated T times; rather, the fetching of itsinstructions is verified together with all other memoryaccesses, one instruction fetch at a time.

Multiple memory-access types. Each copy of C′mem

inspects a pair of items in tr∗ and (assuming tr∗ =MemSort(tr)) must ensure consistency of “load-after-load”, “load-after-store”, and so on. However, unlikein [16], the byte-addressable memory of vnTinyRAMis accessed in different-sized blocks: instruction-sizeblocks for instruction fetch; word-size blocks whenloading/storing words; and byte-size blocks when load-ing/storing bytes. The consistency checks in C′

mem musthandle “aliasing”, i.e., accesses to the same point in mem-ory via different addresses and block sizes.

We tackle this difficulty as follows. Double-wordblocks are the largest blocks in which memory is ac-cessed (as instructions are encoded as double words; cf.Section 2.5). We thus let each item in tr∗ always specifya double-word, even if the item’s memory access waswith respect to a smaller-sized block (e.g., word or byte).With this modification, we can let C′

mem perform consis-tency checks “at the double-word level”, and handlingword/byte accesses by mapping them to double-word ac-cesses with suitable shifting and masking.

Booting the machine. We have so far assumed thatthe program , given as input to C, already appears inmemory. However, the circuit C sketched so far onlyverifies the validity of tr with respect to a machine whosememory is initialized to some state, corresponding to theexecution of some program. But C must verify correctexecution of, specifically, , and so it must also verifythat memory is initialized to contain . Since C doesnot explicitly maintain memory (not even the initial one)and only implicitly reasons about memory via the routingnetwork, it is not clear how C can perform this check.

We tackle this difficulty as follows. We further modifythe the execution trace tr, by extending it with an initialboot section, preceding the beginning of the computation,during which the input program is stored into mem-ory, one instruction i at a time. This extends the lengthof both tr and tr∗ from 2T to + 2T , for -instructionprograms, and introduces a new type of item, “boot in-put store”, in tr∗. Similarly, the routing network is nowresponsible for routing +2T , rather than 2T , packets.

Further optimizations. The above construction sketch(depicted in Figure 6) is only intuitive, and does not dis-cuss other optimizations that ultimately yield the perfor-mance that we report in Section 5.1.

For example, while [16] rely on Benes networks, werely on arbitrary-size Waksman networks [10], which

only require N(logN −0.91) switches to route N packets,instead of 2logN(logN− 0.5). Besides being closerto the information-theoretic lower bound of N(logN −1.443), such networks eliminate costly rounding effectsin [16], where the size of the network is doubled if N isjust above a power of 2.

Compiling to vnTinyRAM. To enable verification ofhigher-level programs, written in C, we ported the GCCcompiler to the vnTinyRAM architecture, by modifyingthe Harvard-architecture, word-addressible TinyRAM Ccompiler of [16]. Given a C program, written in thesame subset of C as in [16], the compiler produces theinitial memory map representing a program . This alsoserved to validate the vnTinyRAM architectural choices(e.g., the move to byte-addressing significantly, and addedinstructions, improved efficiency for many programs).

𝐶𝐶mem 𝐶𝐶mem ⋮

boot

𝐶𝐶exe 𝐼𝐼1

𝐼𝐼2

𝑆𝑆𝑇

𝑆𝑆1

𝑆𝑆2

𝐼𝐼𝑇

⋮

𝐏𝐏1 𝐏𝐏𝟐𝟐

𝐏𝐏ℓ𝓁𝓁 ⋮

𝑆𝑆3 𝐶𝐶exe

⋮

𝐶𝐶exe

𝐴𝐴2

𝐴𝐴4

𝐴𝐴1

𝐴𝐴3

𝐴𝐴5

𝐴𝐴7

𝐴𝐴2T+ℓ𝓁𝓁−1

𝐴𝐴6

𝐴𝐴8

𝐴𝐴2T+ℓ𝓁𝓁

⋮ 𝐶𝐶mem 𝐶𝐶mem 𝐶𝐶mem 𝐶𝐶mem 𝐶𝐶mem 𝐶𝐶mem

𝐶𝐶mem

routing network

⋮

Figure 6: Outline of our universal circuit construction with the extendedtrace tr on the left and (allegedly) its memory sort tr∗ on the right.

4 Our zk-SNARK for circuits

We discuss our second main contribution: a high-performance implementation of a zk-SNARK for arith-metic circuit satisfiability. Our approach is to tailorthe requisite mathematical algorithms to the specificzk-SNARK protocol at hand. While our techniques can beinstantiated in many algebraic setups and security levels,we demonstrate them in two specific settings, to facilitatecomparison with prior work.

See Section 2.4 for an informal definition of azk-SNARK for arithmetic circuit satisfiability. We im-prove upon and implement the zk-SNARK of Parno etal. [56]. For completeness the “PGHR protocol” is sum-marized in the full version of this paper, which providespseudocode for its key generator G, prover P, and verifierV . The construction is based on QAPs, introduced inSection 2.2.

Like most other zk-SNARKs, the PGHR protocol relieson a pairing, which is specified by a prime r ∈ N, three

8


cyclic groups G1,G2,GT of order r, and a bilinear mape : G1 ×G2 →GT . (See Section 2.3.)

A pairing is typically instantiated via a pairing-friendlyelliptic curve. Concretely, suppose that one uses a curveE defined over Fq, with embedding degree k with re-spect to r, to instantiate the pairing. Then GT is set toµr, the subgroup of r-th roots of unity in F∗

qk . The in-stantiation of G1 and G2 depends on the choice of e;typically, G1 is instantiated as an order-r subgroup ofE(Fq), while, for efficiency reasons [7, 8], G2 as an order-r subgroup of E ′(Fk/d) where E ′ is a d-th twist of E.Finally, the pairing e is typically a two-stage functione(P,Q) := FE(ML(P,Q)), where ML : G1×G2 → Fk

q

is known as Miller loop, and FE : Fkq → Fk

q is known as

final exponentiation and maps α to FE(α) := α(qk−1)/r.As mentioned, we instantiate our techniques based on

two different curves: an Edwards curve for the 80-bitsecurity level (as in [16]) and a Barreto–Naehrig curve forthe 128-bits security level (as in [56, 27]). We selectedboth the Edwards curve and Barreto–Naehrig curve sothat r−1 has high 2-adic order (i.e., r−1 is divisible bya large power of 2), because this was shown to improvethe efficiency of the key generator and the prover [16].

4.1 An optimized verifierThe verifier V takes as input a verification key vk, inputx ∈ Fn

r , and proof π , and checks if π is a valid proof forthe statement “x ∈ LC”. The computation of V consistsof two parts. First, use vkIC,0, . . . ,vkIC,n ∈ G1 (part ofvk) and input x to compute vkx := vkIC,0 +∑n

i=1 xivkIC,i.Second, use vk, vkx, and π , to compute 12 pairings andperform the required checks. In other words, V performsO(n) scalar multiplications in G1, followed by O(1) pair-ing evaluations.

With regard to V ’s first part, variable-base multi-scalarmultiplication techniques can be used to reduce the num-ber of G1 operations needed to compute vkx [16, 56].With regard to V ’s second part, even if the pairing evalu-ations take constant time (independent of the input sizen), these evaluations are very expensive and dominate forsmall n. Our focus here is to minimize the cost of thesepairing evaluations.

When only making “black-box” use of a pairing, theverifier must evaluate 12 pairings, amounting to 12 Millerloops plus 12 final exponentiations. The straightfor-ward approach is to compute these using a generic high-performance pairing library. We proceed differently:we obtain high-performance implementations of sub-components of a pairing, and then tailor their use specifi-cally to V ’s protocol.

Namely, first, we obtain state-of-the-art implementa-tions of a Miller loop and final exponentiation. We utilizeoptimal pairings [70] to minimize the number of loop

iterations in each Miller loop, and, to efficiently eval-uate each Miller loop, rely on the formulas of [3] (forEdwards curves) and [20] (for BN curves). As for finalexponentiation, we use multiple techniques to speed itup: [62, 44, 35, 50].

Next, building on the above foundation, we incorporatein V the following optimizations.

(1) Sharing Miller loops and final exponentiations.The verifier V computes two products of two pairings.We leverage the fact that a product of pairings can beevaluated faster than evaluating each pairing separatelyand then multiplying the results [60]. Concretely, in aproduct of m pairings, the Miller loop iterations for evalu-ating each factor can be carried out in “lock-step” so toshare a single Miller accumulator variable, using one Fqk

squaring per loop instead of m.In a similar vein, one can perform a single final expo-

nentiation on the product of the outputs of the m Millerloops, instead of m final exponentiations and then multi-plying the results. In fact, since the output of the pairingcan be inverted for free (as the element is unitary so thatinverting equals conjugating [61]), the idea of “sharing”final exponentiations extends to a ratio of pairing products.Thus, in the verifier we only need to perform 5, instead of12, final exponentiations.

Our implementation incorporates both of the abovetechniques. For example, at the 80-bit security level,separately computing 12 optimal pairings costs 13.6ms,but the above techniques reduce the time to only 8.1ms.We decrease this further as discussed next.

(2) Precomputation by processing the verification key.Of the 12 pairings the verifier needs to evaluate, only oneis such that both of its inputs come from the proof π . Theother 11 pairings have one fixed input, either a generatorof G1 or G2, or coming from the verification key vk.

When one input to a pairing is fixed, precomputationtechniques apply [60], especially in the case when thefixed input is the base point in Miller’s algorithm. In V ,this holds for 9 out of the 11 pairing evaluations. Wethus split the verifier’s computation into an offline phase,which consists of a one-time precomputation that onlydepends on vk, and a many-time online phase, whichdepends on the precomputed values, inputx, and proof π .The result of the offline phase is a processed verificationkey vk∗. While vk∗ is longer than vk, it allows the onlinephase to be faster.

E.g., at the 80-bit security level, vk∗ decreases the totalcost of pairing checks from 8.1ms to 4.7ms.

4.2 An optimized proverThe prover P takes as input a proving key pk (which in-cludes the circuit C : Fn

r ×Fhr → Fl

r), input x ∈ Fnr , and

witnessa ∈ Fr. The prover P is tasked to produce a proof

9


π , attesting that x ∈ LC. The computation of P con-sists of two main parts. First, compute the coefficientshof the polynomial H(z) := A(z)B(z)−C(z)

Z(z) , where A,B,C ∈Fr[z] are derived from the QAP instance (A,B,C,Z) :=QAPinst(C) and QAP witnesss :=QAPwit(C,x,a). Sec-ond, use the coefficientsh, QAP witnesss, and public keypk to compute π .

With regard to the first part of P, the coefficients hcan be efficiently computed via FFT techniques [16, 56];our implementation follows [16], and leverages the high2-adic order of r − 1 for both of the elliptic curves weuse. With regard to P’s second part, computing π requiressolving large instances of the following problem: givenelements Q1, . . . ,Qn all in G1 (or all in G2) and scalarsα1, . . . ,αn ∈ Fr, compute 〈α, Q〉 := α1Q1 + · · ·+αnQn.Previous work [56, 16] has leveraged generic multi-scalarmultiplication to compute π . We observe that these algo-rithms can be tailored to the specific scalar distributionsarising in P. In P, the vector α is one of two types:(i) α ∈ Fd+1

r and represents the coefficients of the degree-d polynomial H; or (ii) α = (1sδ1 δ2 δ3) ∈ F4+m

r ,for random δ1,δ2,δ3 ∈ Fr.

In case i, the entries in of α are random-looking. Weuse the Bos–Coster algorithm [26] due to its lesser mem-ory requirements (as compared to, e.g., [57]). We follow[19]’s suggestions and achieve an assembly-optimizedheap to implement the Bos–Coster algorithm.

In case ii, the entries ins depend on the input (C,x,a)to QAPwit; in turn, (C,x,a) depends on our circuit gen-erator (Section 3). Using the above algorithm “as is” isinefficient: the algorithm works well when all the scalarshave roughly the same bit complexity, but the entries inc have very different bit complexity. Indeed, α equals tos augmented with a few entries; ands, the QAP witness,can be thought of as the list of wire values in C whencomputing on (x,a); the bit complexity of a wire valuedepends on whether it is storing a boolean value, a wordvalue, and so on. We observe that there are only a few“types” of values, so that the entries of α can be clusteredinto few groups of scalars with approximately the samebit complexity; we then apply the algorithm of [26] toeach such group.

4.3 An optimized key generator

The key generator G takes as input a circuit C : Fnr ×Fh

r →Fl

r, and is tasked to compute a proving key pk and averification key vk. The computation of G consists oftwo main parts. First, evaluate each Ai,Bi,Ci at a randomelement τ , where (A,B,C,Z) := QAPinst(C) is the QAPinstance. Second, use these evaluations to compute pkand vk.

With regard to G’s first part, we follow [16] and againleverage the fact that Fr has a primitive root of unity of

large order. With regard to G’s second part, it is dominatedby the cost of computing pk, which requires solving largeinstances of the following problem: given an elementP in G1 or G2 and scalars α1, . . . ,αn ∈ Fr, computeα1P, . . . ,αnP . Previous work [56, 16], used fixed-basewindowing [28] to efficiently compute such fixed-basemulti-scalar multiplications.

In our implementation, we achieve additional efficiency,in space rather than in time. Specifically, we leveragea structural property of QAPs derived from arithmeticcircuits, in order to reduce the size of the proving keypk, as we now explain. Lemma 2.4 states that an F-arithmetic circuit C : Fn × Fh → Fl , with α wires andβ gates, can be converted into a corresponding QAP ofsize m = α and degree d ≈ β over F. Roughly, this isachieved in two steps. First, construct three matricesA,B,C ∈ F(m+1)×d that encode C’s topology: for eachj ∈ [d], the j-th column of A,B respectively encodes the

“left” and “right” coefficients of the j-th bilinear gate inC, while the j-th column of C encodes the coefficients ofthe gate’s output. Second, letting S ⊂ F be a set of sized, define Z(z) := ∏ω∈S(z−ω) and, for i ∈ 0, . . . ,m,let Ai be the low-degree extension of the i-th row of A;similarly define each Bi and Ci. All prior QAP-basedzk-SNARK implementations exploit the fact that columnsin the matrices A,B,C are very sparse.

In contrast, we also leverage a different kind of spar-sity: we observe that it is common for entire rows ofA,B,C to be all zeroes, causing the corresponding low-degree extensions to be zero polynomials.3 For instance,our circuit generator typically outputs a circuit for whichthe percentage of non-zero polynomials in A,B,C is onlyabout 52%,15%,71% respectively. The fact that manypolynomials in A,B,C evaluate to zero can be used to-wards reducing the size of pk, by switching from a denserepresentation to a sparse one.

In fact, we have engineered our circuit generator to re-duce the number of non-zero polynomials in B as much aspossible, because computations associated to evaluationsof B are conducted with respect to more expensive G2arithmetic, which we want to avoid as much as possible.

5 Evaluation

We evaluated our system on a desktop computer witha 3.40 GHz Intel Core i7-4770 CPU (with Turbo Boostdisabled) and 32 GB of RAM. All experiments, except thelargest in Figure 8 and 9, used a small fraction of the RAM.For the two largest experiments in Figure 9 we added aCrucial M4 solid state disk for swap space. (While ourcode supports multi-threading, our experiments are insingle-thread mode, for comparison with prior work.)

3E.g., if the i-th wire never appears with a non-zero coefficient asthe “left” input of a bilinear gate, then the i-th row of A is zero.

10


5.1 Performance of our circuit generatorIn Section 3 we described our universal circuit generator;we now benchmark its performance.

Parameters. The circuit supports vnTinyRAM, whichis parametrized by two quantities: the word size W andthe number of registers K (see Section 2.5). We reportperformance for a machine with K = 16 registers, andtwo choices of word size: W = 16 and W = 32.

Methodology. Theorem 3.2 provides an asymptotic ef-ficiency guarantee: it states that our circuit generator hasefficiency f (,n,T ) = O

((+n+T ) · log(+n+T )

). To

understand concrete efficiency, we “uncover” the con-stants hidden in the big-oh notation. By studying the num-ber of gates in various subcircuits of the generated circuitC := circ(,n,T ), we computed the following (quite tight)upper bound on C’s size:

(12+2W ) · +(12+W ) ·n+ |Cexe| ·T +(|Cmem|+4logH −1.82) ·H

where H := (+ n+ 2T ) is the “height” of the routingnetwork, and• for (W,K) = (16,16): |Cexe|= 777 and |Cmem|= 211;• for (W,K) = (32,16): |Cexe|= 1114 and |Cmem|= 355.In Figure 7, we give per-cycle gate counts (i.e., |C|/|T |)for various choices of (,n,T ); we also give sub-countsdivided among program/input boot, CPU execution, mem-ory checking, and routing. (See the full version of thispaper for an extended table with additional data.)

Discussion. We first go through the size expression, tounderstand it: The first two terms, (12+2W ) · +(12+W ) ·n, correspond to the pre-execution boot phase, duringwhich an -instruction program and an n-word primaryinput are loaded into the machine. The term |Cexe| · Tcorresponds to the T copies of Cexe used to verify eachCPU transition, given the fetched instruction and two CPUstates. The term |Cmem| ·H corresponds to the H copiesof Cmem used to verify consistency on the memory-sortedtrace. Finally, the term (4logH−1.82) ·H corresponds tothe routing network for routing H packets (two gates foreach of (2logH − 0.91) ·H binary switches). Note thatH = (+n+2T ) because boot needs +n memory stores(one for each program instruction and primary input word)and execution needs 2T memory accesses (1 instructionfetch and 1 data store/load per execution cycle).

The gate counts in Figure 7 demonstrate the additive(instead of multiplicative) dependence on program size ofour universal circuit pays off. For example, for (W,K) =(32,16), a 100-fold increase in program size, from =103 to = 105, barely impacts the per-cycle gate count:for T = 220, it increases from 1,992.5 to only 2,041.5.Indeed, the cost of program size is incurred, once andfor all, during the machine boot; Figure 7 shows that theper-cycle cost of machine boot diminishes as T grows.

Second, less than half of C’s gates are dedicated toverifying accesses to random-access memory, while themajority of gates are dedicated to verifying executionof the CPU; indeed, almost always, |Cexe|T > 1

2 |C|. Putotherwise, C, which verifies an automaton with random-access memory (vnTinyRAM), has size that is less thantwice that for verifying an automaton with the same CPUbut no random-access memory at all. Moreover, note thatthe size of Cexe appears quite tight: for example, with(W,K) = (32,16), it has size 1114, not much larger thanthe size of the CPU state (545 bits).

5.2 Performance of our zk-SNARK for cir-cuit satisfiability

In Section 4 we described our zk-SNARK implementa-tion; we now benchmark its performance.Methodology. We provide performance characteristicsfor each of the zk-SNARK algorithms, G, P and V , at the80-bit and 128-bit security levels.(1) The key generator G takes as input an arithmetic cir-cuit C : Fn

r ×Fhr → Fl

r. Its efficiency mostly depends onthe number of gates and wires in C, because these af-fect the size and degree of the corresponding QAP (seeLemma 2.4). Thus, we evaluate G on a circuit with2i gates and 2i wires for i ∈ 10,12, . . . ,24 (and fixedn = h = l = 100). In Figure 8 we report the resultingrunning times and key sizes, as per-gate costs.(2) The prover P takes as input a proving key pk, inputx ∈ Fn

r , and witnessa ∈ Fhr . Its efficiency mostly depends

on the number of gates and wires in C (the circuit usedto generate pk); we thus evaluate P on the proving keysoutput by G, for the same circuits as above. In Figure 8we report the times, as per-gate costs, and proof sizes.(3) The verifier V takes as input a verification key vk,inputx ∈ Fn

r , and proof π . Its efficiency depends only onx (since the size of x determines that of vk). Thus, weevaluate V on a random input x ∈ Fn

r of 2i bytes for i ∈2,4, . . . ,20. In Figure 8 we report the resulting runningtimes, along with corresponding key sizes.Discussion. The data demonstrates that our zk-SNARKimplementation works and scales as expected, as long assufficient memory is available (e.g., on a desktop com-puter with 32GB of DRAM: up to 16 million gates). Keygeneration takes about 10ms per gate of C; the size of aproving key is about 300B per gate, and the size of a ver-ification key is about 1B per byte of input to C. Runningthe prover takes 11ms to 14ms per gate. For an n-byteinput, proof verification time is c1n+ c0, where c0 is afew milliseconds and c1 is a few tenths of microseconds.

5.3 Performance of the combined systemAs discussed, our circuit generator (Section 3) andzk-SNARK for circuits (Section 4) can be used in-

11


Per-cycle gate count of C := circ(,n,T ) with vnTinyRAM parameters (W,K)

n = 102, K = 16W = 16 W = 32

|C|/T |C|/T divided among Percycle

|C|/T divided amongboot exec. mem. routing boot exec. mem. routing

=

103 T = 220 1,367.4 0.04 777.0 422.2 168.1 1,992.5 0.08 1,114.0 710.4 168.1

T = 224 1,399.0 0.00 777.0 422.0 200.0 2,024.0 0.00 1,114.0 710.0 200.0T = 228 1,431.0 0.00 777.0 422.0 232.0 2,056.0 0.00 1,114.0 710.0 232.0

=

104 T = 220 1,370.3 0.41 777.0 424.0 168.8 1,997.0 0.72 1,114.0 713.4 168.8

T = 224 1,399.2 0.03 777.0 422.1 200.1 2,024.3 0.05 1,114.0 710.2 200.1T = 228 1,431.0 0.00 777.0 422.0 232.0 2,056.0 0.00 1,114.0 710.0 232.0

=

105 T = 220 1,399.7 4.12 777.0 442.1 176.4 2,041.5 7.19 1,114.0 743.9 176.4

T = 224 1,401.1 0.26 777.0 423.3 200.6 2,027.2 0.45 1,114.0 712.1 200.6T = 228 1,431.1 0.02 777.0 422.1 232.0 2,056.2 0.03 1,114.0 710.1 232.0

Figure 7: Per-cycle gate counts in C := circ(,n,T ) for different choices of (,n,T ) and vnTinyRAM parameters (W,K).

80 bits of security 128 bits of security

key gen. G time/|C| |pk|/|C| time/|C| |pk|/|C|

n=

100

|C|= 210 0.21ms 248.8B 0.21ms 304.1B|C|= 212 0.16ms 252.5B 0.17ms 309.1B|C|= 214 0.14ms 253.4B 0.16ms 310.3B|C|= 216 0.12ms 253.7B 0.14ms 310.6B|C|= 218 0.11ms 253.7B 0.12ms 310.7B|C|= 220 0.10ms 253.7B 0.12ms 310.7B|C|= 222 0.09ms 253.7B 0.11ms 310.7B|C|= 224 0.08ms 253.7B 0.10ms 310.7B|vk| 2.8KB 3.6KB

prover P time/|C| |π| time/|C| |π|

n=

100

|C|= 210 0.18ms 230B 0.21ms 288B|C|= 212 0.16ms 230B 0.18ms 288B|C|= 214 0.14ms 230B 0.16ms 288B|C|= 216 0.13ms 230B 0.15ms 288B|C|= 218 0.12ms 230B 0.15ms 288B|C|= 220 0.12ms 230B 0.15ms 288B|C|= 222 0.11ms 230B 0.14ms 288B|C|= 224 0.11ms 230B 0.14ms 288B

verifier V |vk|/|x| time/|x| |vk|/|x| time/|x||x|= 4B 118.7B 1.2ms 123.4B 1.2ms|x|= 16B 29.7B 0.3ms 30.8B 0.3ms|x|= 64B 8.1B 76.7 µs 8.7B 81.2 µs|x|= 256B 2.8B 19.5 µs 2.9B 20.3 µs|x|= 1.0KB 1.5B 5.4 µs 1.5B 5.9 µs|x|= 4.1KB 1.1B 1.8 µs 1.1B 2.1 µs|x|= 16.4KB 1.1B 0.8 µs 1.0B 1.0 µs|x|= 65.5KB 1.0B 0.5 µs 1.0B 0.7 µs|x|= 262.1KB 1.0B 0.4 µs 1.0B 0.6 µs|x|= 1.0MB 1.0B 0.4 µs 1.0B 0.5 µs

Figure 8: Per-gate costs of the key generator and prover; and per-bytecosts of the verifier. (N = 10 and std < 1%)

dependently, or combined to obtain a zk-SNARK forvnTinyRAM. For completeness, the paper’s full versionwe spell out how these two components can be combined.Here we report measured performance of this combinedsystem, at the 128-bit security level, and for a word sizeW = 32 and number of registers K = 16.

Methodology. A zk-SNARK for vnTinyRAM is a tripleof algorithms (KeyGen,Prove,Verify). Given bounds,n,T (for program size, input size, and time), the ef-ficiency of KeyGen and Prove depends on ,n,T , while

that of Verify essentially depends only on ,n. Thus, webenchmark the system as follows. We evaluate KeyGenand Prove for various choices of and T , while keepingn = 100. Instead, since the efficiency of Verify does notdepend on T , we evaluate Verify, for various choices of and n, on random -instruction programs and n-word in-puts. In Figure 9, we report the following measurements:KeyGen’s running time, the sizes of the keys pk and vk,Prove’s runtime, the (constant) proof size, and Verify’srunning time. For quantities growing with T , we divideby T and report the per-cycle cost.Discussion. The measurements demonstrate that, ona desktop computer, our zk-SNARK for vnTinyRAMscales up to computations of 32,000 machine cycles, forprograms with up to 10,000 instructions. Key generationtakes about 200ms per cycle; the size of a proving key is500KB to 650KB per cycle, and the size of a verificationkey is a few kilobytes. Running the prover takes 100msto 200ms per cycle. Verification times remain a few ms ,even for inputs and programs of several kilobytes.

Program-specific vk. The time complexity of Verify isO(+ n), so verification time grows with program size.This is inevitable, because Verify must read a program(of at most instructions) and input (of at most n words)in order to check, via the given proof π , if ( , ) ∈L,n,T(cf. Definition 2.6). However, this is inconvenient, e.g.,when one has to verify many proofs relative to differentinputs to the same program . In our zk-SNARK it ispossible to amortize this cost as follows. Given vk and ,one can derive, in time O(), a program-specific verifica-tion key vk , which can be used to verify proofs relativeto any input to . Subsequently, the time complexity ofVerify for any input (to ) is O(n), independent of .

5.4 Comparison with prior work

5.4.1 Comparison with prior circuit generators

Universality is the main innovative feature of our circuitgenerator. No previous circuit generator achieves univer-

12


128 bits of securityW = 32, K = 16

= 2K = 4K = 6K = 8K = 10K

KeyGen

time/

T

n=

100

T = 4K 209.8ms 232.1ms 257.5ms 275.9ms 306.4msT = 8K 190.9ms 205.9ms 216.1ms 228.9ms 238.8msT = 16K 195.4ms 198.1ms 204.2ms 213.6ms 218.3msT = 32K 206.0ms 208.4ms 211.2ms 213.5ms 223.7ms

|pk|/

T

T = 4K 584.2KB 653.6KB 727.1KB 784.0KB 876.8KBT = 8K 552.4KB 585.2KB 618.1KB 655.1KB 683.7KBT = 16K 539.4KB 553.9KB 570.4KB 586.9KB 605.5KBT = 32K 533.8KB 541.1KB 548.3KB 555.6KB 563.4KB

|vk|

T = ∗ 17.0KB 33.1KB 49.2KB 65.3KB 81.5KBProve

time/

T

n=

100 T = 4K 75.7ms 86.7ms 103.4ms 104.8ms 133.7ms

T = 8K 69.2ms 79.7ms 97.0ms 110.4ms 113.0msT = 16K 89.0ms 89.1ms 98.4ms 99.6ms 103.3msT = 32K 98.9ms 98.6ms 102.3ms 102.1ms 114.2ms

Verify

time

(ind

ep.o

fT) n = 0 19.0ms 30.0ms 40.6ms 51.2ms 61.3ms

n = 10 19.1ms 30.2ms 40.7ms 51.2ms 61.4msn = 102 19.6ms 30.7ms 41.3ms 51.8ms 61.9msn = 103 23.0ms 34.1ms 44.7ms 55.2ms 65.4msn = 104 48.9ms 60.0ms 70.6ms 81.1ms 91.3ms

Figure 9: Per-cycle costs of KeyGen and Prove for various program sizes , and total running time of Verify for various and n.

sality. (See Figure 1 and Section 3.)Putting universality aside and focusing on efficiency

instead, a comparison with previous circuit generators is amulti-faceted problem. On one hand, due to a shared coreof techniques, a comparison with [16]’s circuit generatoris straightforward, and shows significant improvementsin circuit size, especially as program size grows. SeeSection 1.4.1 and Figure 2 (the figure is for W,K = 16).

Instead, a comparison with other circuit generators[66, 64, 56, 27] is complex. First, they support a smallerclass of programs (see Figure 1), so a programmer must“write around” the limited functionality, somehow. Andsecond, their efficiency is not easily specified: due to theprogram-analysis techniques (see Section 3.1) the outputcircuit is ad hoc for the given program, and the only wayto know its size is to actually run the circuit generator.

Compared to [66, 64, 56, 27], our circuit generatorperforms better for programs that are rich in memoryaccesses and control flow, and worse for programs thatare more “circuit like”.

Comparison with [66, 64, 56]. The circuit generatorsin [66, 64, 56] restrict loop iteration bounds and memoryaccesses to be known at compile time; if a program doesnot respect these restrictions, it must be first somehowmapped to another one that does. For simplicity, we take[56]’s circuit generator (the latest one) as representativeand, to illustrate the differences between [56]’s and ourcircuit generator, we consider two “extremes”.

On one extreme, we wrote a simple C program multi-plying two 10×10 matrices of 16-bit integers. The circuitgenerator in [56] produces a circuit with 1100 gates; in-stead, our circuit generator (when given the correspondingvnTinyRAM assembly) produces a much larger circuit:one with ≈ 107 gates.

On the other extreme, we consider a program mak-ing many random accesses to memory: pointer-chasing.

Given a permutation π of [N], start position i ∈ [N], andan integer k, the program outputs πk(i), the element ob-tained by starting from i and following “pointers” for ktimes. Since no information about π is known at com-pile time, the only way of obtaining π( j), the pointer tofollow, in [56] is via a linear scan. On a simple C pro-gram that does one linear scan of π to obtain each newpointer, [56]’s generator outputs a circuit with 2Nk+ 1gates (each of the k array accesses costs 2N gates).

In vnTinyRAM, the corresponding program consistsof 9 instructions, and the input to it is N + 3 words.Booting vnTinyRAM with and requires 9+N + 3“boot stores” (see Section 3.2), and takes 5+ 4k cyclesto execute (independent of N). Say that we fix k = 10;then, in our circuit generator (with W = 32 and K = 16),each cycle costs about 2000 gates, and can perform arandom access to memory. Thus, pointer chasing in ourcase is cheaper than in [56] already for N > 5000, and themultiplicative saving, which is about 20N

2000·(5+40) =N

4500 ,grows unbounded as N increases.

Comparison with [27]. The circuit generator of [27] isalso based on program analysis, but provides an additionalfeature that allows data-dependent memory accesses: aprogram may access memory by guessing the value andverifying its validity via a subcircuit that checks Merkle-tree authentication paths. In [27], memory consists of230 cells, and each access costs many gates: 140K for aload, and 280K for a store. In comparison, in our circuitgenerator for vnTinyRAM (with word size W = 32 sothat memory has 232 cells), each memory store/load costsless than 1000 gates out of about 2000 per cycle (seeSection 5.1). Besides the aforementioned feature, [27]rely on program analysis, and (as in [66, 64, 56]) onlysupport bounded control flow. Thus, [27] performs betterthan our circuit generator for programs with boundedcontrol flow and few data-dependent accesses to memory.

13


5.4.2 Comparison with prior zk-SNARKsAddressing the other component of our system, thezk-SNARK for circuits: Figure 3 compares our imple-mentation with prior ones, on a 1-million-gate circuitwith a 1000-byte input. As shown, we mildly improve thekey generation time and, more importantly, significantlyimprove the “online” costs of proving and verification.

6 Conclusion

We have presented two main contributions: (i) a circuitgenerator for a von Neumann RISC architecture that isuniversal and scales additively with program size; and(ii) a high-performance zk-SNARK for arithmetic circuitsatisfiability. These two components can be used inde-pendently to the benefit of other systems, or combinedinto a zk-SNARK that can prove/verify correctness ofcomputations on this architecture.The benefits of universality. Universality attains theconceptual advance of once-and-for-all key generation,allowing verifying all programs up to a given size. Thisremoves major issues in prior systems: expensive per-program key generation and the thorny issue of conduct-ing it anew in a trusted way for every program.The price of universality. The price of universality isstill very high. Going forward, and aiming for widespreaduse in security applications, more work is required toslash costs of key generation and proving so to scale up tolarger computations: e.g., billion-gate circuits, or millionsof vnTinyRAM cycles, and beyond. An interesting openproblem is whether the “program analysis” techniquesunderlying most prior circuit generators [66, 64, 56, 27],typically more efficient for restricted classes of programs,can be used to construct universal circuits.Beyond vnTinyRAM. Finally, going beyond the foun-dation of a von Neumann RISC architecture, more worklies ahead towards a richer architecture (e.g., efficientsupport for floating-point arithmetic and cryptographicacceleration), code libraries, and tighter compilers.

A Other prior work

Prior work most relevant to us is about zk-SNARKs, andis discussed in Section 1.2. There are also numerousworks studying variations or relaxations of the goal weconsider; here, we summarize some of them.Interactive proofs for low-depth circuits. Goldwasseret al. [42] obtained an interactive proof for outsourc-ing computations of low-depth circuits. A set of works[32, 68, 67] has optimized and implemented the proto-col of [42]. The protocol of [42] can also be reducedto a two-message argument system [48, 47]. Canetti etal. [30] showed how to extend the techniques in [42] toalso handle non-uniform circuits.

Batching arguments. Ishai et al. [46] constructed abatching argument for NP, where, to simultaneously ver-ify that N circuits of size S are satisfiable, the verifier runsin time maxS2,N.

A set of works [63, 65, 66, 64] has improved, optimized,and implemented the batching argument of Ishai et al. [46]for the purpose of outsourcing computation. In particular,by relying on quadratic arithmetic programs of [38], Settyet al. [64] have improved the running time of the veri-fier and prover to maxS,N ·poly(λ ) and O(S) ·poly(λ )respectively. Vu et al. [71] provide a system that incorpo-rates both the batching arguments of [63, 65, 66, 64] aswell as the interactive proofs of [32, 68, 67]. The systemdecides which of the two approaches is more efficient touse for outsourcing a given computation.

Braun et al. [27] apply batching techniques (as wellas zk-SNARKs) to verify MapReduce computations, byrelying on various verifiable data structures.

Arguments with competing provers. Canetti et al. [29]use collision-resistant hashes to get a protocol for out-sourcing deterministic computations in a model wherea verifier interacts with two computationally-boundedprovers at least one of which is honest [34]. The proto-col in [29] works directly for random-access machines,and therefore does not require reducing random-accessmachines to any “lower-level” representation (such ascircuits). Canetti et al. implement their protocol for deter-ministic x86 programs.

Previous circuit generators. Some prior work ad-dresses the problem of translating high-level languagesinto low-level languages such as circuits. Most prior workonly supports restricted classes of programs: [66, 64]present a circuit generator based on Fairplay [53, 12],whose SFDL language does not support important primi-tives and has inefficient support for others; [56] present acircuit generator for programs without data dependencies(pointers and array indices must be known at compiletime, and so do loop iteration bounds).

Other works support more general functionality: [16]rely on nondeterministic routing to support random-access machine computations [14]; [27] rely on onlinememory checking [24, 14] to support accessing untrustedstorage from a circuit. See [27, Section 2] for a moredetailed overview of some of the above techniques.

Other cryptographic tools. Fully-homomorphic en-cryption (FHE) [39] and probabilistically-checkableproofs [5, 4] are powerful tools that are often used in pro-tocols for outsourcing computations (with integrity or con-fidentiality guarantees, or both) [49, 54, 2, 37, 31, 47, 41].However, such constructions have so far not been exploredin practice. Another powerful tool is secure multi-partycomputation [40, 13], but most work in this area does notconsider the goal of succinctness.

14


B Case study: memcpy

The function memcpy is a standard C function that worksas follows: given as input two array pointers and a length,memcpy copies the contents of one array to the other.Of course, with no data dependencies, copying data in acircuit is trivial: you just connect the appropriate wires.However, when the array addresses and their lengths areunknown, and memcpy is invoked as a subroutine in alarger program, the trivial solution does not work, and anefficient implementation is needed.

A naive implementation of memcpy iterates, via a loop,over each array position i and copies the i-th value fromone array to the other. In vnTinyRAM each such loopiteration costs 6 instructions; 2 of these are to increase theiteration counter and jump back to the start of the loop.Thus, for m-long arrays, copying takes 6m instructions(discounting loop initialization). But, in vnTinyRAM,one can do better: loop unrolling can be used to avoidpaying for the 2 “control” instructions. Asymptotically,the optimal number of unrollings depends on the arraylength: it is Θ(

√m). Thus, optimal unrolling requires

dynamic code generation on a von Neumann architec-ture. We wrote a 54-instruction vnTinyRAM programfor memcpy that uses dynamic loop unrolling to achievean efficiency of ≈ 4m+ 11.5

√m cycles for m-long ar-

rays. For m ≥ 600, we get 1.25× speed-up over the naiveimplementation, and 1.4× speed-up for m ≥ 3000.

Acknowledgments

We thank Daniel Genkin, Raluca Ada Popa, Ron Rivest,and Nickolai Zeldovich for helpful comments and discus-sions, and Lior Greenblatt, Shaul Kfir, Michael Riabzev,and Gil Timnat for programming assistance.

This work was supported by: the Center for Scienceof Information (CSoI), an NSF Science and TechnologyCenter, under grant agreement CCF-0939370; the CheckPoint Institute for Information Security; the EuropeanCommunity’s Seventh Framework Programme (FP7/2007-2013) under grant agreement number 240258; the IsraeliCenters of Research Excellence I-CORE program (center4/11); the Israeli Ministry of Science, Technology andSpace; the Simons Foundation, with a Simons Award forGraduate Students in Theoretical Computer Science; andthe Skolkovo Foundation.

References[1] AJTAI, M., KOMLOS, J., AND SZEMEREDI, E. An o(n logn)

sorting network. In STOC ’83 (1983).

[2] APPLEBAUM, B., ISHAI, Y., AND KUSHILEVITZ, E. Fromsecrecy to soundness: Efficient verification via secure computation.In ICALP ’10 (2010).

[3] ARENE, C., LANGE, T., NAEHRIG, M., AND RITZENTHALER,C. Faster computation of the Tate pairing. Journal of NumberTheory (2011).

[4] ARORA, S., LUND, C., MOTWANI, R., SUDAN, M., ANDSZEGEDY, M. Proof verification and the hardness of approxi-mation problems. JACM (1998).

[5] ARORA, S., AND SAFRA, S. Probabilistic checking of proofs: anew characterization of NP. JACM (1998).

[6] BABAI, L., FORTNOW, L., LEVIN, L. A., AND SZEGEDY, M.Checking computations in polylogarithmic time. In STOC ’91(1991).

[7] BARRETO, P. S. L. M., KIM, H. Y., LYNN, B., AND SCOTT, M.Efficient algorithms for pairing-based cryptosystems. In CRYPTO

’02 (2002).

[8] BARRETO, P. S. L. M., LYNN, B., AND SCOTT, M. Efficientimplementation of pairing-based cryptosystems. Journal of Cryp-tology (2004).

[9] BARRETO, P. S. L. M., AND NAEHRIG, M. Pairing-friendlyelliptic curves of prime order. In SAC’05 (2006).

[10] BEAUQUIER, B., AND ERIC, D. On arbitrary size Waksman net-works and their vulnerability. Parallel Processing Letters (2002).

[11] BELLARE, M., AND GOLDREICH, O. On defining proofs ofknowledge. In CRYPTO ’92 (1993).

[12] BEN-DAVID, A., NISAN, N., AND PINKAS, B. FairplayMP: asystem for secure multi-party computation. In CCS ’08 (2008).

[13] BEN-OR, M., GOLDWASSER, S., AND WIGDERSON, A. Com-pleteness theorems for non-cryptographic fault-tolerant distributedcomputation (extended abstract). In STOC ’88 (1988).

[14] BEN-SASSON, E., CHIESA, A., GENKIN, D., AND TROMER,E. Fast reductions from RAMs to delegatable succinct constraintsatisfaction problems. In ITCS ’13 (2013).

[15] BEN-SASSON, E., CHIESA, A., GENKIN, D., AND TROMER, E.On the concrete efficiency of probabilistically-checkable proofs.In STOC ’13 (2013).

[16] BEN-SASSON, E., CHIESA, A., GENKIN, D., TROMER, E.,AND VIRZA, M. SNARKs for C: Verifying program executionssuccinctly and in zero knowledge. In CRYPTO ’13 (2013).

[17] BEN-SASSON, E., CHIESA, A., GENKIN, D., TROMER, E., ANDVIRZA, M. TinyRAM architecture specification v2.00, 2013.

[18] BEN-SASSON, E., GOLDREICH, O., HARSHA, P., SUDAN, M.,AND VADHAN, S. Short PCPs verifiable in polylogarithmic time.In CCC ’05 (2005).

[19] BERNSTEIN, D. J., DUIF, N., LANGE, T., SCHWABE, P., ANDYANG, B.-Y. High-speed high-security signatures. In CHES ’11(2011).

[20] BEUCHAT, J.-L., GONZALEZ-DIAZ, J. E., MITSUNARI, S.,OKAMOTO, E., RODRIGUEZ-HENRIQUEZ, F., AND TERUYA, T.High-speed software implementation of the optimal ate pairingover Barreto-Naehrig curves. In Pairing ’10 (2010).

[21] BITANSKY, N., CANETTI, R., CHIESA, A., AND TROMER, E.Recursive composition and bootstrapping for SNARKs and proof-carrying data. In STOC ’13 (2013).

[22] BITANSKY, N., CHIESA, A., ISHAI, Y., OSTROVSKY, R., ANDPANETH, O. Succinct non-interactive arguments via linear inter-active proofs. In TCC ’13 (2013).

[23] BLUM, M., DE SANTIS, A., MICALI, S., AND PERSIANO, G.Non-interactive zero-knowledge. SIAM J. Comp. (1991).

[24] BLUM, M., EVANS, W., GEMMELL, P., KANNAN, S., ANDNAOR, M. Checking the correctness of memories. In FOCS ’91(1991).

[25] BLUM, M., FELDMAN, P., AND MICALI, S. Non-interactivezero-knowledge and its applications. In STOC ’88 (1988).

15


[26] BOS, J., AND COSTER, M. Addition chain heuristics. In CRYPTO’89 (1989).

[27] BRAUN, B., FELDMAN, A. J., REN, Z., SETTY, S., BLUMBERG,A. J., AND WALFISH, M. Verifying computations with state. InSOSP ’13 (2013).

[28] BRICKELL, E. F., GORDON, D. M., MCCURLEY, K. S., ANDWILSON, D. B. Fast exponentiation with precomputation. InEUROCRYPT ’92 (1993).

[29] CANETTI, R., RIVA, B., AND ROTHBLUM, G. N. Practicaldelegation of computation using multiple servers. In CCS ’11(2011).

[30] CANETTI, R., RIVA, B., AND ROTHBLUM, G. N. Two protocolsfor delegation of computation. In ICITS 12 (2012).

[31] CHUNG, K.-M., KALAI, Y., AND VADHAN, S. Improved dele-gation of computation using fully homomorphic encryption. InCRYPTO ’10 (2010).

[32] CORMODE, G., MITZENMACHER, M., AND THALER, J. Prac-tical verified computation with streaming interactive proofs. InITCS ’12 (2012).

[33] EDWARDS, H. M. A normal form for elliptic curves. Bulletin ofthe American Mathematical Society (2007).

[34] FEIGE, U., AND KILIAN, J. Making games short. In STOC ’97(1997).

[35] FUENTES-CASTANEDA, L., KNAPP, E., AND RODRIGUEZ-HENRIQUEZ, F. Faster hashing to G2. In SAC ’11 (2012).

[36] GAL, A., EICH, B., SHAVER, M., ANDERSON, D., MANDELIN,D., HAGHIGHAT, M. R., KAPLAN, B., HOARE, G., ZBARSKY,B., ORENDORFF, J., RUDERMAN, J., SMITH, E. W., REIT-MAIER, R., BEBENITA, M., CHANG, M., AND FRANZ, M. Trace-based just-in-time type specialization for dynamic languages. InPLDI ’09 (2009).

[37] GENNARO, R., GENTRY, C., AND PARNO, B. Non-interactiveverifiable computing: outsourcing computation to untrusted work-ers. In CRYPTO ’10 (2010).

[38] GENNARO, R., GENTRY, C., PARNO, B., AND RAYKOVA, M.Quadratic span programs and succinct NIZKs without PCPs. InEUROCRYPT ’13 (2013).

[39] GENTRY, C. Fully homomorphic encryption using ideal lattices.In STOC ’09 (2009).

[40] GOLDREICH, O., MICALI, S., AND WIGDERSON, A. How toplay any mental game or a completeness theorem for protocolswith honest majority. In STOC ’87 (1987).

[41] GOLDWASSER, S., KALAI, Y., POPA, R. A., VAIKUN-TANATHAN, V., AND ZELDOVICH, N. Reusable garbled circuitsand succinct functional encryption. In STOC ’13 (2013).

[42] GOLDWASSER, S., KALAI, Y. T., AND ROTHBLUM, G. N. Dele-gating computation: Interactive proofs for Muggles. In STOC ’08(2008).

[43] GOLDWASSER, S., MICALI, S., AND RACKOFF, C. The knowl-edge complexity of interactive proof systems. SIAM J. Comp.(1989).

[44] GRANGER, R., AND SCOTT, M. Faster squaring in the cyclotomicsubgroup of sixth degree extensions. In PKC’10 (2010).

[45] GROTH, J. Short non-interactive zero-knowledge proofs. InASIACRYPT ’10 (2010).

[46] ISHAI, Y., KUSHILEVITZ, E., AND OSTROVSKY, R. Efficientarguments without short PCPs. In CCC ’07 (2007).

[47] KALAI, Y., RAZ, R., AND ROTHBLUM, R. Delegation forbounded space. In STOC ’13 (2013).

[48] KALAI, Y. T., AND RAZ, R. Probabilistically checkable argu-ments. In CRYPTO ’09 (2009).

[49] KILIAN, J. A note on efficient zero-knowledge proofs and argu-ments. In STOC ’92 (1992).

[50] KIM, T., KIM, S., AND CHEON, J. H. On the final exponentiationin Tate pairing computations. IEEE Trans. on Inf. Theory (2013).

[51] LIPMAA, H. Progression-free sets and sublinear pairing-basednon-interactive zero-knowledge arguments. In TCC ’12 (2012).

[52] LIPMAA, H. Succinct non-interactive zero knowledge argumentsfrom span programs and linear error-correcting codes. In ASI-ACRYPT ’13 (2013).

[53] MALKHI, D., NISAN, N., PINKAS, B., AND SELLA, Y. Fairplay— a secure two-party computation system. In SSYM ’04 (2004).

[54] MICALI, S. Computationally sound proofs. SIAM J. Comp.(2000).

[55] NAOR, M., AND YUNG, M. Public-key cryptosystems provablysecure against chosen ciphertext attacks. In STOC ’90 (1990).

[56] PARNO, B., GENTRY, C., HOWELL, J., AND RAYKOVA, M.Pinocchio: Nearly practical verifiable computation. In Oak-land ’13 (2013).

[57] PIPPENGER, N. On the evaluation of powers and monomials.SIAM J. Comp. (1980).

[58] RIGO, A., AND PEDRONI, S. PyPy’s approach to virtual machineconstruction. In OOPSLA ’06 (2006).

[59] SCOTT, M. Computing the Tate pairing. In CT-RSA ’05 (2005).

[60] SCOTT, M. Implementing cryptographic pairings. In Pairing ’07(2007).

[61] SCOTT, M., AND BARRETO, P. S. L. M. Compressed pairings.In CRYPTO ’04 (2004).

[62] SCOTT, M., BENGER, N., CHARLEMAGNE, M.,DOMINGUEZ PEREZ, L. J., AND KACHISA, E. J. Onthe final exponentiation for calculating pairings on ordinaryelliptic curves. In Pairing ’09 (2009).

[63] SETTY, S., BLUMBERG, A. J., AND WALFISH, M. Towardpractical and unconditional verification of remote computations.In HotOS ’11 (2011).

[64] SETTY, S., BRAUN, B., VU, V., BLUMBERG, A. J., PARNO, B.,AND WALFISH, M. Resolving the conflict between generality andplausibility in verified computation. In EuroSys ’13 (2013).

[65] SETTY, S., MCPHERSON, M., BLUMBERG, A. J., AND WAL-FISH, M. Making argument systems for outsourced computationpractical (sometimes). In NDSS ’12 (2012).

[66] SETTY, S., VU, V., PANPALIA, N., BRAUN, B., BLUMBERG,A. J., AND WALFISH, M. Taking proof-based verified computa-tion a few steps closer to practicality. In Security ’12 (2012).

[67] THALER, J. Time-optimal interactive proofs for circuit evaluation.In CRYPTO ’13 (2013).

[68] THALER, J., ROBERTS, M., MITZENMACHER, M., AND PFIS-TER, H. Verifiable computation with massively parallel interactiveproofs. CoRR (2012).

[69] VALIANT, P. Incrementally verifiable computation or proofs ofknowledge imply time/space efficiency. In TCC ’08 (2008).

[70] VERCAUTEREN, F. Optimal pairings. IEEE Trans. on Inf. Theory(2010).

[71] VU, V., SETTY, S., BLUMBERG, A. J., AND WALFISH, M.A hybrid architecture for interactive verifiable computation. InOakland ’13 (2013).

[72] ZAHUR, S., AND EVANS, D. Circuit structures for improvingefficiency of security and privacy tools. In SP ’13 (2013).

16

succinct non-interactive zero knowledge for a von neumann … · 2016-02-20 · 782 23rd usenix...

Documents