2019-07-05 12:41:22 -07:00
|
|
|
extern crate pairing;
|
2019-07-03 16:05:27 -07:00
|
|
|
extern crate rand;
|
|
|
|
|
2019-07-05 12:41:22 -07:00
|
|
|
use super::*;
|
2019-07-03 16:05:27 -07:00
|
|
|
use rand::{thread_rng, Rng};
|
|
|
|
use cl::{KeyPair, Signature, PublicParams, setup, BlindKeyPair, ProofState, SignatureProof, BlindPublicKey};
|
2019-07-05 12:41:22 -07:00
|
|
|
use ped92::{CSParams, Commitment, CSMultiParams};
|
|
|
|
use pairing::{Engine, CurveProjective};
|
|
|
|
use ff::PrimeField;
|
2019-07-03 16:05:27 -07:00
|
|
|
use util::hash_g2_to_fr;
|
2019-07-05 12:41:22 -07:00
|
|
|
use commit_scheme::commit;
|
2019-07-03 16:05:27 -07:00
|
|
|
|
|
|
|
#[derive(Clone)]
|
|
|
|
struct Proof<E: Engine> {
|
2019-07-04 07:56:34 -07:00
|
|
|
sig: Signature<E>,
|
2019-07-03 16:05:27 -07:00
|
|
|
sigProof: SignatureProof<E>,
|
2019-07-12 07:46:25 -07:00
|
|
|
T: E::G1,
|
|
|
|
D: E::G1,
|
2019-07-05 12:41:22 -07:00
|
|
|
z: Vec<E::Fr>,
|
2019-07-03 16:05:27 -07:00
|
|
|
}
|
|
|
|
|
2019-07-12 08:01:40 -07:00
|
|
|
fn prove<R: Rng, E: Engine>(rng: &mut R, comParams: &CSMultiParams<E>, r: E::Fr,
|
2019-07-07 14:15:36 -07:00
|
|
|
oldWallet: Vec<E::Fr>, newWallet: Vec<E::Fr>, rPrime: E::Fr, paymentToken: &Signature<E>,
|
2019-07-03 16:05:27 -07:00
|
|
|
mpk: &PublicParams<E>, kp: &BlindKeyPair<E>) -> Proof<E> {
|
2019-07-05 13:57:30 -07:00
|
|
|
//Commitment phase
|
2019-07-05 14:57:03 -07:00
|
|
|
//Commit linear relationship
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut T = comParams.pub_bases[2].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
let t1 = E::Fr::rand(rng);
|
|
|
|
T.mul_assign(t1);
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut h = comParams.pub_bases[0].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
let t2 = E::Fr::rand(rng);
|
|
|
|
h.mul_assign(t2);
|
|
|
|
T.add_assign(&h);
|
2019-07-05 14:57:03 -07:00
|
|
|
|
|
|
|
//commit signature
|
2019-07-03 16:05:27 -07:00
|
|
|
let proofState = kp.prove_commitment(rng, &mpk, &paymentToken);
|
2019-07-05 13:57:30 -07:00
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
//commit commitment
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut D = E::G1::zero();
|
|
|
|
let mut t = Vec::<E::Fr>::with_capacity(comParams.pub_bases.len() - 1);
|
|
|
|
for g in comParams.pub_bases.clone() {
|
2019-07-05 13:57:30 -07:00
|
|
|
let ti = E::Fr::rand(rng);
|
|
|
|
t.push(ti);
|
|
|
|
let mut gt = g.clone();
|
|
|
|
gt.mul_assign(ti.into_repr());
|
|
|
|
D.add_assign(>);
|
|
|
|
}
|
|
|
|
|
|
|
|
//Compute challenge
|
|
|
|
let challenge = hash::<E>(proofState.a, T, D);
|
|
|
|
|
|
|
|
//Response phase
|
2019-07-05 14:57:03 -07:00
|
|
|
//response for signature
|
2019-07-07 14:15:36 -07:00
|
|
|
let sigProof = kp.prove_response(&proofState, challenge, &mut oldWallet.clone());
|
2019-07-03 16:05:27 -07:00
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
//response linear relationship
|
2019-07-05 13:57:30 -07:00
|
|
|
let mut z = Vec::<E::Fr>::with_capacity(t.len() + 2);
|
2019-07-05 14:57:03 -07:00
|
|
|
let mut z1 = newWallet[1].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
z1.negate();
|
|
|
|
z1.mul_assign(&challenge);
|
|
|
|
z1.add_assign(&t1);
|
2019-07-05 13:57:30 -07:00
|
|
|
z.push(z1);
|
2019-07-05 12:41:22 -07:00
|
|
|
let mut z2 = r.clone();
|
|
|
|
z2.sub_assign(&rPrime.clone());
|
|
|
|
z2.mul_assign(&challenge);
|
|
|
|
z2.add_assign(&t2);
|
2019-07-05 13:57:30 -07:00
|
|
|
z.push(z2);
|
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
//response commitment
|
|
|
|
let mut z0 = rPrime.clone();
|
|
|
|
z0.mul_assign(&challenge);
|
|
|
|
z0.add_assign(&t[0]);
|
|
|
|
z.push(z0);
|
|
|
|
for i in 1..t.len() {
|
|
|
|
let mut zi = newWallet[i-1].clone();
|
2019-07-05 13:57:30 -07:00
|
|
|
zi.mul_assign(&challenge);
|
|
|
|
zi.add_assign(&t[i]);
|
|
|
|
z.push(zi);
|
|
|
|
}
|
|
|
|
|
|
|
|
Proof { sig: proofState.blindSig, sigProof, T, D, z }
|
2019-07-03 16:05:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
fn verify<E: Engine>(proof: Proof<E>, epsilon: E::Fr, com1: &Commitment<E>, com2: &Commitment<E>,
|
2019-07-05 14:21:48 -07:00
|
|
|
wpk: E::Fr, comParams: &CSMultiParams<E>, mpk: &PublicParams<E>, pk: &BlindPublicKey<E>) -> bool {
|
2019-07-05 14:57:03 -07:00
|
|
|
//compute challenge
|
2019-07-05 13:57:30 -07:00
|
|
|
let challenge = hash::<E>(proof.sigProof.a, proof.T, proof.D);
|
2019-07-05 12:41:22 -07:00
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
//verify linear relationship
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut gWpk = comParams.pub_bases[2].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
let mut minWpk = wpk.clone();
|
|
|
|
minWpk.negate();
|
|
|
|
gWpk.mul_assign(minWpk.into_repr());
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut gEps = comParams.pub_bases[4].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
gEps.mul_assign(epsilon.into_repr());
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut gMinEps = comParams.pub_bases[3].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
let mut mineps = epsilon.clone();
|
|
|
|
mineps.negate();
|
|
|
|
gMinEps.mul_assign(mineps.into_repr());
|
|
|
|
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut commitment = com1.c.clone();
|
|
|
|
commitment.sub_assign(&com2.c.clone());
|
2019-07-05 12:41:22 -07:00
|
|
|
commitment.add_assign(&gWpk);
|
|
|
|
commitment.add_assign(&gEps);
|
|
|
|
commitment.add_assign(&gMinEps);
|
|
|
|
commitment.mul_assign(challenge.into_repr());
|
|
|
|
commitment.add_assign(&proof.T);
|
|
|
|
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut g2 = comParams.pub_bases[2].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
g2.mul_assign(proof.z[0].into_repr());
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut h = comParams.pub_bases[0].clone();
|
2019-07-05 12:41:22 -07:00
|
|
|
h.mul_assign(proof.z[1].into_repr());
|
|
|
|
g2.add_assign(&h);
|
2019-07-05 14:57:03 -07:00
|
|
|
let r = commitment == g2;
|
2019-07-05 12:41:22 -07:00
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
//verify knowledge of signature
|
|
|
|
let r1 = pk.verify_proof(&mpk, proof.sig, proof.sigProof, challenge);
|
2019-07-05 12:41:22 -07:00
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
//verify knowledge of commitment
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut comc = com2.c.clone();
|
2019-07-05 13:57:30 -07:00
|
|
|
comc.mul_assign(challenge.into_repr());
|
|
|
|
comc.add_assign(&proof.D.clone());
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut x = E::G1::zero();
|
2019-07-05 13:57:30 -07:00
|
|
|
for i in 2..proof.z.len() {
|
2019-07-12 07:46:25 -07:00
|
|
|
let mut base = comParams.pub_bases[i - 2].clone();
|
2019-07-05 13:57:30 -07:00
|
|
|
base.mul_assign(proof.z[i].into_repr());
|
|
|
|
x.add_assign(&base);
|
|
|
|
}
|
2019-07-05 14:57:03 -07:00
|
|
|
let r3 = x == comc;
|
2019-07-05 13:57:30 -07:00
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
r && r1 && r3
|
2019-07-03 16:05:27 -07:00
|
|
|
}
|
|
|
|
|
2019-07-12 07:46:25 -07:00
|
|
|
fn hash<E: Engine>(a: E::Fqk, T: E::G1, D: E::G1) -> E::Fr {
|
2019-07-05 13:14:14 -07:00
|
|
|
let mut x_vec: Vec<u8> = Vec::new();
|
|
|
|
x_vec.extend(format!("{}", a).bytes());
|
|
|
|
x_vec.extend(format!("{}", T).bytes());
|
2019-07-05 13:57:30 -07:00
|
|
|
x_vec.extend(format!("{}", D).bytes());
|
2019-07-05 13:14:14 -07:00
|
|
|
|
|
|
|
util::hash_to_fr::<E>(x_vec)
|
|
|
|
}
|
|
|
|
|
2019-07-03 16:05:27 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-07-07 14:15:36 -07:00
|
|
|
use pairing::bls12_381::{Bls12, Fr};
|
2019-07-03 16:05:27 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn nizk_proof_works() {
|
|
|
|
let rng = &mut rand::thread_rng();
|
|
|
|
let pkc = Fr::rand(rng);
|
|
|
|
let wpk = Fr::rand(rng);
|
|
|
|
let wpkprime = Fr::rand(rng);
|
|
|
|
let bc = Fr::rand(rng);
|
|
|
|
let mut bc2 = bc.clone();
|
|
|
|
let bm = Fr::rand(rng);
|
|
|
|
let mut bm2 = bm.clone();
|
|
|
|
let epsilon = &Fr::rand(rng);
|
|
|
|
bc2.sub_assign(epsilon);
|
|
|
|
bm2.add_assign(epsilon);
|
|
|
|
let r = Fr::rand(rng);
|
|
|
|
let rprime = Fr::rand(rng);
|
|
|
|
|
2019-07-07 14:15:36 -07:00
|
|
|
let mpk = setup(rng);
|
|
|
|
let keypair = BlindKeyPair::<Bls12>::generate(rng, &mpk, 4);
|
|
|
|
let comParams = keypair.generate_cs_multi_params(&mpk);
|
2019-07-05 14:57:03 -07:00
|
|
|
let wallet1 = vec! {pkc, wpk, bc, bm};
|
|
|
|
let commitment1 = comParams.commit(&wallet1, &r);
|
|
|
|
let wallet2 = vec! {pkc, wpkprime, bc2, bm2};
|
|
|
|
let commitment2 = comParams.commit(&wallet2, &rprime);
|
2019-07-07 14:15:36 -07:00
|
|
|
let blindPaymentToken = keypair.sign_blind(rng, &mpk, commitment1.clone());
|
|
|
|
let paymentToken = keypair.unblind(&r, &blindPaymentToken);
|
2019-07-03 16:05:27 -07:00
|
|
|
|
2019-07-12 08:01:40 -07:00
|
|
|
let proof = prove(rng, &comParams, r, wallet1, wallet2, rprime, &paymentToken, &mpk, &keypair);
|
2019-07-05 14:21:48 -07:00
|
|
|
|
|
|
|
assert_eq!(verify(proof, *epsilon, &commitment1, &commitment2, wpk, &comParams, &mpk, &keypair.public), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn nizk_proof_false_statements() {
|
|
|
|
let rng = &mut rand::thread_rng();
|
|
|
|
let pkc = Fr::rand(rng);
|
|
|
|
let wpk = Fr::rand(rng);
|
|
|
|
let wpkprime = Fr::rand(rng);
|
|
|
|
let bc = Fr::rand(rng);
|
|
|
|
let mut bc2 = bc.clone();
|
|
|
|
let bm = Fr::rand(rng);
|
|
|
|
let mut bm2 = bm.clone();
|
|
|
|
let epsilon = &Fr::rand(rng);
|
|
|
|
bc2.sub_assign(epsilon);
|
|
|
|
bm2.add_assign(epsilon);
|
|
|
|
let r = Fr::rand(rng);
|
|
|
|
let rprime = Fr::rand(rng);
|
|
|
|
|
2019-07-08 13:53:15 -07:00
|
|
|
let mpk = setup(rng);
|
|
|
|
let keypair = BlindKeyPair::<Bls12>::generate(rng, &mpk, 4);
|
|
|
|
let comParams = keypair.generate_cs_multi_params(&mpk);
|
2019-07-05 14:57:03 -07:00
|
|
|
let wallet1 = vec! {pkc, wpk, bc, bm};
|
|
|
|
let wallet2 = vec! {pkc, wpkprime, bc2, bm2};
|
2019-07-05 14:21:48 -07:00
|
|
|
|
|
|
|
let mut bc2Prime = bc.clone();
|
2019-07-05 14:57:03 -07:00
|
|
|
let wallet3 = vec! {pkc, wpkprime, bc2Prime, bm2};
|
2019-07-07 14:15:36 -07:00
|
|
|
let commitment1 = comParams.commit(&wallet1.clone(), &r);
|
2019-07-05 14:57:03 -07:00
|
|
|
let commitment2 = comParams.commit(&wallet3, &rprime);
|
2019-07-08 13:53:15 -07:00
|
|
|
let blindPaymentToken = keypair.sign_blind(rng, &mpk, commitment1.clone());
|
|
|
|
let paymentToken = keypair.unblind(&r, &blindPaymentToken);
|
2019-07-12 08:01:40 -07:00
|
|
|
let proof = prove(rng, &comParams, r, wallet1.clone(), wallet3, rprime, &paymentToken, &mpk, &keypair);
|
2019-07-05 14:21:48 -07:00
|
|
|
assert_eq!(verify(proof, *epsilon, &commitment1, &commitment2, wpk, &comParams, &mpk, &keypair.public), false);
|
|
|
|
|
|
|
|
let mut bm2Prime = bm.clone();
|
2019-07-05 14:57:03 -07:00
|
|
|
let wallet4 = vec! {pkc, wpkprime, bc2, bm2Prime};
|
|
|
|
let commitment2 = comParams.commit(&wallet4, &rprime);
|
2019-07-12 08:01:40 -07:00
|
|
|
let proof = prove(rng, &comParams, r, wallet1.clone(), wallet4, rprime, &paymentToken, &mpk, &keypair);
|
2019-07-05 14:21:48 -07:00
|
|
|
assert_eq!(verify(proof, *epsilon, &commitment1, &commitment2, wpk, &comParams, &mpk, &keypair.public), false);
|
|
|
|
|
2019-07-05 14:57:03 -07:00
|
|
|
let wallet5 = vec! {Fr::rand(rng), wpkprime, bc2, bm2};
|
|
|
|
let commitment2 = comParams.commit(&wallet5, &rprime);
|
2019-07-12 08:01:40 -07:00
|
|
|
let proof = prove(rng, &comParams, r, wallet1.clone(), wallet5, rprime, &paymentToken, &mpk, &keypair);
|
2019-07-05 14:21:48 -07:00
|
|
|
assert_eq!(verify(proof, *epsilon, &commitment1, &commitment2, wpk, &comParams, &mpk, &keypair.public), false);
|
2019-07-03 16:05:27 -07:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|