Sequentially composing ZK (cont.) and black box simulated ZK


Cryptography 2019-02-19

The materials in this post are mostly from the talk by Alon Rosen in the BIU school, but some proofs are written by myself. So feel free to contact me in case there are any typos or mistakes.

The protocol from yesterday

Recall the protocol from yesterday. (Prof. Rosen cited as [GMR’85])

Given as common input to

  1. :
    sample .
    • If send to ;
    • If send to .
  2. :
    • If send to ;
    • Otherwise send to .
  3. accepts iff .

The argument for ZK was invalid. That is due to the fact that we need to show that for any verifier (including malicious ones which might deviate from the protocol) there is a simulator for it. But we have only shown that for an honest verifier we can simulate the view.

Non-ZK-ness of the protocol

The protocol turns out to be only honest verifier zero knowledge (HVZK).

To see why, notice that a cheating verifier can choose on purpose, and not to sample at all. He can decide to send and choose to be some specific number on which he need to decide whether . In this case, the returned bit signifies the answer.

This might be adversarially utilized when composing protocols. For example, one can imagine that in a certain protocol some party needs to prove that it can decide . Then when the protocols are running together, this particular party may use the other protocol to cheat (though contrived, there are real protocols (with computational simulation) that break down when running in parallel, one is mentioned in the talk Alon Rosen: Lower Bounds and Limitations on Zero Knowledge in the school).

ZK with auxiliary input

A better definition for ZK that enables sequential composition is as follows.

(ZK with auxilary input) An IP is said to be zero-knowledge with auxiliary input if for any PPT verifier there exists a PPT simulator such that,

View.

Where represents the context (auxiliary input) and the corresponds to perfect (statistical, computational) indistinguishablility respectively.

Proving closure under sequential composition

Using the previous definition, one can prove that ZK is closed under sequential composition.

Suppose is ZK with auxiliary input, then where the protocol is sequentially executed times, is also ZK with auxiliary input.

This can be proven by induction.

Suppose the claim is true for . Then there is a simulator for the view produced by . To simulate , on input , we first run to obtain a view for the first execution. Then we feed this view into the auxiliary input of , i.e. we run to obtain . Now by perfect simulation of and by the fact that the state that is passed from the first execution to the second distributes exactly as , by perfect simulation of . Therefore the above procedure describes a perfect simulator for .


The black box simulation barrier

Wow the protocol by Barak using non-black-box simulation is really amazing and I am still trying to understand the constructions. I will definitely try to explain the protocols in the following posts if I have time.

But, why would we need the non-black-box simulation in the very first place?

Here I will describe the so-called black box simulation barrier, which seems to be first published by Goldreich and Krawczyk in 1990 (Paper).

The theorem goes as follows.

The following condition hold for an IP for a language L if and only if L BPP.

  1. It has constant-round, i.e. the number of rounds of exchanging messages is bounded by a constant;
  2. It is Arthur-Merlin, i.e. the verifier does not have hidden randomness from the prover;
  3. It admits black-box simulation. That is to say, for any , there is a simulator which is an oracle machine that treats as a black-box, and that produces a simulated view that is computationally indistinguishable from a real execution by .

A trivial case

The proof is a bit complicated. Here let us consider a very much simplied situation (or because the author is very sleepy).

Let be an ZK interactive proof system for L in which the protocol consists of a single message from to . Then L BPP.

In the following by we mean the verifier is given random coins and received message from the prover. Let be the simulator for , then the following is a PPT algorithm for L.

On input :

  1. Let ;
  2. Accept iff accepts.

If L then because otherwise, the prover that always sends violates soundness.

If L, suppose . Then we can build a distinguisher for attacking which runs step 2 of the above procedure. When given simulated views, output 1 with probability less than , but when given real views in the protocol, the distinguisher outputs 1 with probability 1 due to completeness. Therefore .

Hence L BPP.

Reference:

Alon Rosen: Introduction to Zero Knowledge, talk & slides. (Day 1 of BIU school)

Alon Rosen: Lower Bounds and Limitations on Zero Knowledge. (Day 2 of BIU school)

Oded Goldreich, Hugo Krawczyk: On the Composition of Zero-Knowledge Proof Systems.

official site of BIU Winter School.