zecfoundation
/
libbolt
mirror of https://github.com/ZcashFoundation/libbolt.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

remove old code

This commit is contained in:
J. Ayo Akinyele 2018-07-25 22:59:47 -04:00
parent 48005fffe0
commit 76227f2d46
2 changed files with 4 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
bin/bolt.rs
View File

@ -44,137 +44,8 @@ macro_rules! measure_ret_mut {
fn main() {
let rng = &mut rand::thread_rng();
// Test the CL sigs
// CL sig tests
let mpk = clsigs::setup_d();
let l = 3;
let c_keypair = clsigs::keygen_d(&mpk, l);
let m_keypair = clsigs::keygen_d(&mpk, l);
//println!("{}", keypair.pk);
let mut m1 : Vec<Fr> = Vec::new();
let mut m2 : Vec<Fr> = Vec::new();
let mut m3 : Vec<Fr> = Vec::new();
for _i in 0 .. l+1 {
m1.push(Fr::random(rng));
m2.push(Fr::random(rng));
m3.push(Fr::random(rng));
}
let signature = clsigs::sign_d(&mpk, &m_keypair.sk, &m1);
//println!("{}", signature);
println!("Checking CL sig verification...");
let (res1, verify1) = measure!(clsigs::verify_d(&mpk, &m_keypair.pk, &m1, &signature));
assert!(res1 == true);
println!("{} seconds for verifying valid signatures.", verify1);
let (res2, verify2) = measure!(clsigs::verify_d(&mpk, &m_keypair.pk, &m2, &signature));
assert!(res2 == false);
println!("{} seconds for verifying invalid signatures.", verify2);
let (res3, verify3) = measure!(clsigs::verify_d(&mpk, &c_keypair.pk, &m1, &signature));
assert!(res3 == false);
println!("Invalid sig - verify time 3: {}", verify3);
let (res4, verify4) = measure!(clsigs::verify_d(&mpk, &m_keypair.pk, &m3, &signature));
assert!(res4 == false);
println!("Invalid sig - verify time 4: {}", verify4);
// let s1 = signature.hash("prefix type1");
// let s2 = signature.hash("prefix type2");
// let p1 = "Hash of signature 1: ";
// libbolt::debug_elem_in_hex(p1, &s1);
// let p2 = "Hash of signature 2: ";
// libbolt::debug_elem_in_hex(p2, &s2);
//
// let mut schnorr = secp256k1::Secp256k1::new();
// schnorr.randomize(rng);
// let (wsk, wpk) = schnorr.generate_keypair(rng).unwrap();
//
// let balance = 100;
// let r = Fr::random(rng);
// let cid = Fr::random(rng);
// let refund_message1 = libbolt::RefundMessage::new(String::from("refundUnsigned"), wpk, balance, Some(r), None);
// let rm1 = refund_message1.hash();
// println!("RefundMessage => {}", refund_message1.msgtype);
// for i in 0 .. rm1.len() {
// let p = format!("rm1[{}] = ", i);
// libbolt::debug_elem_in_hex(&p, &rm1[i]);
// }
//
// let refund_message2 = libbolt::RefundMessage::new(String::from("refundToken"), wpk, balance+15, None, Some(signature));
// let rm2 = refund_message2.hash();
// println!("RefundMessage (token) => {}", refund_message2.msgtype);
// for i in 0 .. rm2.len() {
// let p = format!("rm2[{}] = ", i);
// libbolt::debug_elem_in_hex(&p, &rm2[i]);
// }
// println!("******************************************");
// let b = m_keypair.pk.Z2.len();
// let mut bases: Vec<G2> = Vec::new();
// bases.push(mpk.g2);
// for i in 0 .. b {
// bases.push(m_keypair.pk.Z2[i]);
// }
//
// // generate sample commitment
// //let mut m: Vec<Fr> = Vec::new();
// let mut C = mpk.g2 * m1[0];
// for i in 0 .. b {
// //println!("index: {}", i);
// C = C + (m_keypair.pk.Z2[i] * m1[i+1]);
// }
// let msg = "Sample Commit output:";
// libbolt::debug_g2_in_hex(msg, &C);
//
// let cm_csp = commit_scheme::setup(b, m_keypair.pk.Z2.clone(), mpk.g2.clone());
// let r = m1[0];
// let w_com = commit_scheme::commit(&cm_csp, &m1, r);
//
// assert!(commit_scheme::decommit(&cm_csp, &w_com, &m1));
//
// //let msg = "Commmit Scheme output:";
// //libbolt::debug_g2_in_hex(msg, &w_com.c);
//
// //assert_eq!(C, w_com.c);
// println!("Commitment scheme consistent!!");
// let proof = clsigs::bs_gen_nizk_proof(&m1, &cm_csp.pub_bases, w_com.c);
// // old -> let proof = clsigs::bs_gen_nizk_proof(&m1, &bases, C);
//
// let int_sig = clsigs::bs_check_proof_and_gen_signature(&mpk, &m_keypair.sk, &proof);
//
// println!("Generated signature interactively!");
//
//
// let proof = clsigs::bs_gen_nizk_proof(&m1, &bases, C);
//
// let int_sig = clsigs::bs_check_proof_and_gen_signature(&mpk, &m_keypair.sk, &proof);
//
// println!("Generated signature interactively!");
// // int_sig = interactively generated signature
// assert!(clsigs::verify_d(&mpk, &m_keypair.pk, &m1, &int_sig) == true);
//
// println!("Verified interactively produced signature!");
//
// let blind_sigs = clsigs::prover_generate_blinded_sig(&int_sig);
// let common_params1 = clsigs::gen_common_params(&mpk, &m_keypair.pk, &int_sig);
// println!("Verified blind signature directly!");
//
// let proof_vs = clsigs::vs_gen_nizk_proof(&m1, &common_params1, common_params1.vs);
// assert!(clsigs::vs_verify_blind_sig(&mpk, &m_keypair.pk, &proof_vs, &blind_sigs));
//
// println!("Verified blind signature (via NIZK)!");
println!("******************************************");
// libbolt tests below
// libbolt tests below
//println!("[1a] libbolt - setup bidirecitonal scheme params");
let (pp, setup_time1) = measure!(bidirectional::setup(false));

18
src/lib.rs
View File

@ -32,8 +32,6 @@ use bincode::rustc_serialize::{encode, decode};
use sodiumoxide::randombytes;
use sodiumoxide::crypto::hash::sha512;
use std::collections::HashMap;
use time::PreciseTime;
//use rand::{rngs::OsRng, Rng};
use curve25519_dalek::scalar::Scalar;
use bulletproofs::ProofTranscript;
use bulletproofs::RangeProof;
@ -47,12 +45,7 @@ pub mod commit_scheme;
pub mod clproto;
const E_MIN: i32 = 1;
const E_MAX: i32 = 255;
//pub fn hash_string(s: &str) -> String {
// let digest = sha256::hash(s.as_bytes());
// format!("{:X}", HexSlice::new(&digest))
//}
const E_MAX: i32 = 255; // TODO: should be 2^32 - 1
pub fn debug_elem_in_hex(prefix: &str, r: &Fr) {
let encoded: Vec<u8> = encode(&r, Infinite).unwrap();
@ -471,7 +464,6 @@ pub mod unidirectional {
ck_vec.push(ck);
}
// TODO: get bidirectional setup
let w_com = commit_scheme::commit(&cm_pk, &msg.hash(), r);
let t_c = ChannelToken { w_com: w_com, pk: keypair.pk };
let csk_c = CustSecretKey { sk: keypair.sk, k1: k1, k2: k2, r: r, balance: b0_customer, ck_vec: ck_vec };
@ -501,7 +493,6 @@ pub mod unidirectional {
/////////////////////////////// Bidirectional ////////////////////////////////
pub mod bidirectional {
use std::fmt;
use PreciseTime;
use rand::{rngs::OsRng, Rng};
use rand_core::RngCore;
use bn::{Group, Fr, G1, G2, Gt};
@ -657,10 +648,9 @@ pub mod bidirectional {
}
pub fn setup(_extra_verify: bool) -> PublicParams {
// TODO: provide option for generating CRS parameters
// TODO: provide option for using CRS parameters?
let cl_mpk = clsigs::setup_d();
let l = 4;
// let nizk = "nizk proof system";
let n = 32; // bitsize: 32-bit (0, 2^32-1)
let num_rand_values = 1;
let generators = Generators::new(PedersenGenerators::default(), n, num_rand_values);
@ -670,8 +660,6 @@ pub mod bidirectional {
}
pub fn keygen(pp: &PublicParams) -> clsigs::KeyPairD {
// TODO: figure out what we need from public params to generate keys
println!("Run Keygen...");
let keypair = clsigs::keygen_d(&pp.cl_mpk, pp.l);
return keypair;
}
@ -1275,7 +1263,7 @@ mod tests {
payment_increment: i32) {
// let's test the pay protocol
assert!(bidirectional::pay_by_customer_phase1_precompute(&pp, &cust_data.T, &merch_keys.pk, &mut cust_data.csk));
let s = PreciseTime::now();
let (t_c, new_wallet, pay_proof) = bidirectional::pay_by_customer_phase1(&pp, &cust_data.T, // channel token
&merch_keys.pk, // merchant pub key
&cust_data.csk, // wallet