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

cleanup of warnings and imports

This commit is contained in:
Gijs Van Laer 2019-10-18 11:07:03 -04:00
parent e749ec22fa
commit 75bb446cdf
14 changed files with 94 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -12,7 +12,6 @@ license = "MIT License"
[dependencies]
rand = "0.6"
rand_core = "0.4.0"
rand_xorshift = "0.1"
ff = { git = "https://github.com/boltlabs-inc/ff", branch = "master" }
pairing = { git = "https://github.com/boltlabs-inc/pairing", branch = "master", features = ["serde"] }
libc = "*"

9
Makefile
View File

@ -46,5 +46,14 @@ gotests:
cargo +nightly build --release
go test go/libbolt.go go/libbolt_test.go
alltests:
cargo +nightly clean
cargo +nightly update
cargo +nightly build --release
cargo +nightly test --release #-- --nocapture
python py/libbolt.py
python py/libbolt_tests.py
go test go/libbolt.go go/libbolt_test.go
clean:
cargo +nightly clean

23
examples/bolt_test.rs
View File

@ -10,7 +10,6 @@ use bolt::bidirectional;
use std::time::Instant;
use pairing::bls12_381::{Bls12};
use bolt::handle_bolt_result;
use bolt::util::hash_pubkey_to_fr;
macro_rules! measure_one_arg {
($x: expr) => {
@ -35,21 +34,21 @@ macro_rules! measure_two_arg {
}
macro_rules! measure_ret_mut {
($x: expr) => {
{
let s = Instant::now();
let mut handle = $x;
let e = s.elapsed();
(handle, s.as_millis())
};
}
}
//macro_rules! measure_ret_mut {
// ($x: expr) => {
// {
// let s = Instant::now();
// let mut handle = $x;
// let e = s.elapsed();
// (handle, s.as_millis())
// };
// }
//}
fn main() {
println!("******************************************");
let mut channel_state = bidirectional::ChannelState::<Bls12>::new(String::from("Channel A -> B"), false);
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let b0_customer = 150;
let b0_merchant = 10;

28
src/ccs08.rs
View File

@ -163,14 +163,6 @@ impl<E: Engine> SecretParamsUL<E> {
r1 && r2
}
fn compute_challenge(&self, proof: &ProofUL<E>) -> E::Fr {
let mut a = Vec::<E::Fqk>::with_capacity(self.pubParams.l as usize);
for sigProof in proof.sigProofs.clone() {
a.push(sigProof.a);
}
hash::<E>(a, vec!(proof.D.clone()))
}
fn verify_part2(&self, proof: &ProofUL<E>, challenge: E::Fr) -> bool {
let mut r2 = true;
for i in 0..self.pubParams.l as usize {
@ -363,8 +355,8 @@ impl<E: Engine> RPSecretParams<E> {
let logb = (b as f32).log2();
let loglogb = logb.log2();
if loglogb > 0.0 {
let mut u = (logb / loglogb) as i64;
u = 57; //TODO: optimize u?
// let mut u = (logb / loglogb) as i64;
let u = 57; //TODO: optimize u?
let l = (b as f64).log(u as f64).ceil() as i64;
let secParamsOut = SecretParamsUL::<E>::setup_ul(rng, u, l, csParams.clone());
@ -504,7 +496,7 @@ mod tests {
let modx = Fr::from_str(&(10.to_string())).unwrap();
let C = csParams.commit(&vec!(modx), &fr.clone());
let proof = secParams.pubParams.prove_ul(rng, 10, fr, C, 1, vec!{});
let ch = secParams.compute_challenge(&proof);
let ch = compute_challenge(secParams.pubParams.clone(), &proof);
assert_eq!(secParams.verify_part1(&proof, ch, 1), true);
}
@ -517,7 +509,7 @@ mod tests {
let modx = Fr::from_str(&(10.to_string())).unwrap();
let C = csParams.commit(&vec!(modx), &fr.clone());
let proof = secParams.pubParams.prove_ul(rng, 10, fr, C, 1, vec!{});
let ch = secParams.compute_challenge(&proof);
let ch = compute_challenge(secParams.pubParams.clone(), &proof);
assert_eq!(secParams.verify_part2(&proof, ch), true);
}
@ -530,7 +522,7 @@ mod tests {
let modx = Fr::from_str(&(10.to_string())).unwrap();
let C = csParams.commit(&vec!(modx), &fr.clone());
let proof = secParams.pubParams.prove_ul(rng, 10, fr, C, 1, vec!{});
let ch = secParams.compute_challenge(&proof);
let ch = compute_challenge(secParams.pubParams.clone(), &proof);
assert_eq!(secParams.verify_ul(&proof, ch, 1), true);
}
@ -545,7 +537,7 @@ mod tests {
let fr2 = Fr::rand(rng);
let C = csParams.commit(&vec!(fr1, modx, fr2), &fr.clone());
let proof = secParams.pubParams.prove_ul(rng, 10, fr, C, 2, vec!{fr1, fr2});
let ch = secParams.compute_challenge(&proof);
let ch = compute_challenge(secParams.pubParams.clone(), &proof);
assert_eq!(secParams.verify_ul(&proof, ch, 2), true);
}
@ -712,4 +704,12 @@ mod tests {
assert_ne!(hash::<Bls12>(a.clone(), vec!(D2.clone())), hash::<Bls12>(a.clone(), vec!(D.clone())));
assert_ne!(hash::<Bls12>(a2.clone(), vec!(D2.clone())), hash::<Bls12>(a.clone(), vec!(D.clone())))
}
fn compute_challenge<E: Engine>(pubParams: ParamsUL<E>, proof: &ProofUL<E>) -> E::Fr {
let mut a = Vec::<E::Fqk>::with_capacity(pubParams.l as usize);
for sigProof in proof.sigProofs.clone() {
a.push(sigProof.a);
}
hash::<E>(a, vec!(proof.D.clone()))
}
}

39
src/channels.rs
View File

@ -10,17 +10,13 @@ extern crate pairing;
extern crate rand;
use super::*;
use pairing::{Engine, CurveProjective};
use pairing::bls12_381::Bls12;
use ff::PrimeField;
use cl::{BlindKeyPair, KeyPair, Signature, PublicParams, setup};
use ped92::{CSParams, Commitment, CSMultiParams, CommitmentProof};
use util::{hash_pubkey_to_fr, convert_int_to_fr, hash_to_fr, RevokedMessage, hash_to_slice};
use pairing::Engine;
use cl::{BlindKeyPair, Signature};
use ped92::{Commitment, CSMultiParams, CommitmentProof};
use util::{hash_pubkey_to_fr, hash_to_fr, RevokedMessage, hash_to_slice};
use rand::Rng;
use std::collections::HashMap;
use std::fmt::Display;
use serde::{Serialize, Deserialize};
use std::ptr::hash;
use nizk::{NIZKPublicParams, NIZKSecretParams, NIZKProof};
use wallet::Wallet;
use std::error::Error;
@ -160,14 +156,14 @@ impl<E: Engine> ChannelState<E> {
///
/// keygen - takes as input public parameters and generates a digital signature keypair
///
pub fn keygen<R: Rng>(&mut self, csprng: &mut R, id: String) -> cl::BlindKeyPair<E> {
pub fn keygen<R: Rng>(&mut self, csprng: &mut R, _id: String) -> cl::BlindKeyPair<E> {
let cp = self.cp.as_ref();
let keypair = BlindKeyPair::<E>::generate(csprng, &cp.unwrap().pub_params.mpk, cp.unwrap().l);
// print the keypair as well
return keypair;
}
pub fn load_params(&mut self, cp: &ChannelParams<E>) {
pub fn load_params(&mut self, _cp: &ChannelParams<E>) {
// load external params
}
@ -432,8 +428,7 @@ impl<E: Engine> CustomerState<E> {
impl<E: Engine> fmt::Display for CustomerState<E> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut content = String::new();
content = format!("id = {}\n", &self.name);
let mut content = format!("id = {}\n", &self.name);
content = format!("{}pk = {}\n", content, &self.pk_c);
content = format!("{}sk = {}\n", content, &self.sk_c);
content = format!("{}cust-bal = {}\n", content, &self.cust_balance);
@ -513,7 +508,7 @@ impl<E: Engine> MerchantState<E> {
}, ch)
}
pub fn init<R: Rng>(&mut self, csprng: &mut R, channel: &mut ChannelState<E>) -> ChannelToken<E> {
pub fn init(&mut self, channel: &mut ChannelState<E>) -> ChannelToken<E> {
let cp = channel.cp.as_ref().unwrap(); // if not set, then panic!
let mpk = cp.pub_params.mpk.clone();
let cl_pk = self.keypair.get_public_key(&mpk);
@ -615,16 +610,12 @@ impl<E: Engine> MerchantState<E> {
#[cfg(test)]
mod tests {
use super::*;
use ff::Rand;
use pairing::bls12_381::Bls12;
use rand::SeedableRng;
use rand_xorshift::XorShiftRng;
#[test]
fn channel_util_works() {
let mut channel = ChannelState::<Bls12>::new(String::from("Channel A <-> B"), false);
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let b0_cust = 100;
let b0_merch = 20;
@ -634,7 +625,7 @@ mod tests {
let (mut merch_state, mut channel) = MerchantState::<Bls12>::new(rng, &mut channel, String::from("Merchant B"));
// initialize the merchant wallet with the balance
let mut channel_token = merch_state.init(rng, &mut channel);
let mut channel_token = merch_state.init(&mut channel);
// retrieve commitment setup params (using merchant long lived pk params)
// initialize on the customer side with balance: b0_cust
@ -688,18 +679,14 @@ mod tests {
#[should_panic(expected = "pk_c is not initialized yet")]
fn compute_channel_id_panics() {
let mut channel = ChannelState::<Bls12>::new(String::from("Channel A <-> B"), false);
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let b0_cust = 100;
let b0_merch = 20;
// each party executes the init algorithm on the agreed initial challenge balance
// in order to derive the channel tokens
// initialize on the merchant side with balance: b0_merch
let (mut merch_state, mut channel) = MerchantState::<Bls12>::new(rng, &mut channel, String::from("Merchant B"));
// initialize the merchant wallet with the balance
let mut channel_token = merch_state.init(rng, &mut channel);
let channel_token = merch_state.init(&mut channel);
let channelId = channel_token.compute_channel_id();
let _channelId = channel_token.compute_channel_id();
}
}

31
src/cl.rs
View File

@ -5,14 +5,11 @@ extern crate rand;
use super::*;
use pairing::{CurveProjective, Engine};
use ff::{PrimeField, ScalarEngine};
use ff::PrimeField;
use rand::Rng;
use ped92::{Commitment, CSMultiParams};
use std::fmt::LowerHex;
use serde::{Serialize, Deserialize};
use serde::ser::{Serializer, SerializeStruct, SerializeSeq};
use util;
use ccs08;
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct PublicParams<E: Engine> {
@ -291,9 +288,8 @@ impl<E: Engine> BlindPublicKey<E> {
let l = self.Y2.len();
//println!("verify - m.len = {}, l = {}", message.len(), l);
assert!(message.len() <= l + 1);
let mut last_elem = l;
last_elem = match l == message.len() {
let last_elem = match l == message.len() {
true => message.len() - 1,
false => l
};
@ -531,10 +527,7 @@ mod tests {
use super::*;
use ff::Rand;
use pairing::bls12_381::{Bls12, Fr, G1, G2};
use rand::SeedableRng;
use rand_xorshift::XorShiftRng;
use ped92::CSMultiParams;
use pairing::bls12_381::{Bls12, Fr};
#[test]
fn sign_and_verify() {
@ -552,7 +545,7 @@ mod tests {
let mut message1: Vec<Fr> = Vec::new();
let mut message2: Vec<Fr> = Vec::new();
for i in 0..l {
for _i in 0..l {
message1.push(Fr::rand(&mut rng));
message2.push(Fr::rand(&mut rng));
}
@ -576,7 +569,7 @@ mod tests {
let mut message1: Vec<Fr> = Vec::new();
let mut message2: Vec<Fr> = Vec::new();
for i in 0..l {
for _i in 0..l {
message1.push(Fr::rand(&mut rng));
message2.push(Fr::rand(&mut rng));
}
@ -610,7 +603,7 @@ mod tests {
let mut message1: Vec<Fr> = Vec::new();
for i in 0..l {
for _i in 0..l {
message1.push(Fr::rand(&mut rng));
}
@ -632,12 +625,10 @@ mod tests {
let mpk = setup(&mut rng);
let keypair = BlindKeyPair::<Bls12>::generate(&mut rng, &mpk, l);
let public_key = keypair.get_public_key(&mpk);
let mut message1: Vec<Fr> = Vec::new();
let mut message2: Vec<Fr> = Vec::new();
for i in 0..l {
for _i in 0..l {
message1.push(Fr::rand(&mut rng));
message2.push(Fr::rand(&mut rng));
}
@ -667,11 +658,9 @@ mod tests {
let mpk = setup(&mut rng);
let keypair = BlindKeyPair::<Bls12>::generate(&mut rng, &mpk, l);
let public_key = keypair.get_public_key(&mpk);
let mut message1: Vec<Fr> = Vec::new();
for i in 0..l {
for _i in 0..l {
message1.push(Fr::rand(&mut rng));
}
@ -695,7 +684,7 @@ mod tests {
let serialized = serde_json::to_vec(&mpk).unwrap();
//println!("serialized = {:?}", serialized.len());
let mpk_des: PublicParams<Bls12> = serde_json::from_slice(&serialized).unwrap();
let _mpk_des: PublicParams<Bls12> = serde_json::from_slice(&serialized).unwrap();
//println!("{}", mpk_des);
//println!("SK => {}", &keypair.secret);
@ -710,7 +699,7 @@ mod tests {
let pk_serialized = serde_json::to_vec(&keypair.public).unwrap();
//println!("pk_serialized = {:?}", pk_serialized.len());
let pk_des: PublicKey<Bls12> = serde_json::from_slice(&pk_serialized).unwrap();
let _pk_des: PublicKey<Bls12> = serde_json::from_slice(&pk_serialized).unwrap();
//assert_eq!(pk_des, keypair.public);
//println!("{}", &blindkeypair.public);

6
src/ffishim.rs
View File

@ -3,7 +3,7 @@ pub mod ffishim {
extern crate libc;
use bidirectional;
use ff::{Rand, ScalarEngine};
use ff::ScalarEngine;
use pairing::bls12_381::Bls12;
use serde::Deserialize;
@ -11,9 +11,7 @@ pub mod ffishim {
use libc::c_char;
use std::ffi::{CStr, CString};
use std::str;
use channels::{ChannelcloseM, ResultBoltType, BoltError};
use util::hash_pubkey_to_fr;
use std::str::FromStr;
// use channels::{ChannelcloseM, ResultBoltType, BoltError};
fn error_message(s: String) -> *mut c_char {
let ser = ["{\'error\':\'", &s, "\'}"].concat();

72
src/lib.rs
View File

@ -34,7 +34,6 @@ extern crate serde_with;
extern crate libc;
#[cfg(test)]
extern crate rand_xorshift;
extern crate core;
pub mod cl;
@ -52,7 +51,6 @@ use std::collections::HashMap;
use ff::{Rand, Field};
use serde::{Serialize, Deserialize};
use serde::de::{Deserializer, Unexpected, Error};
////////////////////////////////// Utilities //////////////////////////////////
@ -174,7 +172,7 @@ pub mod bidirectional {
let merch_name = String::from(name);
let (mut merch_state, mut channel_state) = MerchantState::<E>::new(csprng, channel_state, merch_name);
// initialize the merchant state
let channel_token = merch_state.init(csprng, &mut channel_state);
let channel_token = merch_state.init(&mut channel_state);
return (channel_token, merch_state, channel_state.clone());
}
@ -523,16 +521,13 @@ mod benches {
#[cfg(test)]
mod tests {
use super::*;
use ff::Rand;
use pairing::bls12_381::Bls12;
use rand::Rng;
use channels::ChannelState;
use util::hash_pubkey_to_fr;
fn setup_new_channel_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
init_cust_bal: i64, init_merch_bal: i64)
-> (bidirectional::ChannelToken<Bls12>, bidirectional::MerchantState<Bls12>, bidirectional::CustomerState<Bls12>, bidirectional::ChannelState<Bls12>) {
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let merch_name = "Bob";
let cust_name = "Alice";
@ -542,7 +537,7 @@ mod tests {
// each party executes the init algorithm on the agreed initial challenge balance
// in order to derive the channel tokens
// initialize on the merchant side with balance: b0_merch
let (mut channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, channel_state, merch_name);
let (mut channel_token, merch_state, channel_state) = bidirectional::init_merchant(rng, channel_state, merch_name);
// initialize on the customer side with balance: b0_cust
let cust_state = bidirectional::init_customer(rng, &mut channel_token, b0_cust, b0_merch, cust_name);
@ -556,7 +551,7 @@ mod tests {
merch_balance: i64,
merch_state: &mut bidirectional::MerchantState<Bls12>,
cust_state: &mut bidirectional::CustomerState<Bls12>) {
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
// lets establish the channel
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, channel_token, cust_state);
@ -582,11 +577,10 @@ mod tests {
}
fn execute_payment_protocol_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
channel_token: &mut bidirectional::ChannelToken<Bls12>,
merch_state: &mut bidirectional::MerchantState<Bls12>,
cust_state: &mut bidirectional::CustomerState<Bls12>,
payment_increment: i64) {
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let (payment, new_cust_state) = bidirectional::generate_payment_proof(rng, channel_state, &cust_state, payment_increment);
@ -606,12 +600,10 @@ mod tests {
fn bidirectional_payment_basics_work() {
// just bidirectional case (w/o third party)
let mut channel_state = bidirectional::ChannelState::<Bls12>::new(String::from("Channel A -> B"), false);
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let total_owed = 40;
let b0_customer = 90;
let b0_merchant = 20;
let payment_increment = 20;
let (mut channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob");
@ -669,7 +661,6 @@ mod tests {
let payment_increment = 20;
let mut channel_state = bidirectional::ChannelState::<Bls12>::new(String::from("Channel A -> B"), false);
let mut rng = &mut rand::thread_rng();
// set fee for channel
let fee = 5;
@ -685,8 +676,8 @@ mod tests {
{
// make multiple payments in a loop
let num_payments = total_owed / payment_increment;
for i in 0..num_payments {
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, payment_increment);
for _i in 0..num_payments {
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, payment_increment);
}
{
@ -713,7 +704,6 @@ mod tests {
let payment_increment = -20;
let mut channel_state = bidirectional::ChannelState::<Bls12>::new(String::from("Channel A -> B"), false);
let mut rng = &mut rand::thread_rng();
let (mut channel_token, mut merch_state, mut cust_state, mut channel_state) = setup_new_channel_helper(&mut channel_state, b0_customer, b0_merchant);
@ -722,7 +712,7 @@ mod tests {
assert!(channel_state.channel_established);
{
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, payment_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, payment_increment);
{
// scope localizes the immutable borrow here (for debug purposes only)
@ -735,7 +725,7 @@ mod tests {
#[test]
fn bidirectional_merchant_close_detects_double_spends() {
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let b0_customer = rng.gen_range(100, 1000);
let b0_merchant = 10;
@ -751,17 +741,17 @@ mod tests {
assert!(channel_state.channel_established);
// let's make a few payments then exit channel (will post an old channel state
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
// let's close then move state forward
let old_cust_close_msg = bidirectional::customer_close(&channel_state, &cust_state);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
let cur_cust_close_msg = bidirectional::customer_close(&channel_state, &cust_state);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
let _cur_cust_close_msg = bidirectional::customer_close(&channel_state, &cust_state);
let merch_close_result = bidirectional::merchant_close(&channel_state,
&channel_token,
@ -780,7 +770,7 @@ mod tests {
#[test]
#[should_panic]
fn bidirectional_merchant_close_works() {
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let b0_customer = rng.gen_range(100, 1000);
let b0_merchant = 10;
@ -796,13 +786,13 @@ mod tests {
assert!(channel_state.channel_established);
// let's make a few payments then exit channel (will post an old channel state
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, pay_increment);
execute_payment_protocol_helper(&mut channel_state, &mut merch_state, &mut cust_state, pay_increment);
let cust_close_msg = bidirectional::customer_close(&channel_state, &cust_state);
@ -810,7 +800,7 @@ mod tests {
&channel_token,
&cust_close_msg,
&merch_state);
let merch_close_msg = match merch_close_result {
let _merch_close_msg = match merch_close_result {
Ok(n) => n.unwrap(),
Err(err) => panic!("Merchant close msg: {}", err)
};
@ -820,7 +810,7 @@ mod tests {
#[test]
fn intermediary_payment_basics_works() {
println!("Intermediary test...");
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let b0_alice = rng.gen_range(100, 1000);
let b0_bob = rng.gen_range(100, 1000);
@ -882,31 +872,31 @@ mod tests {
#[test]
fn serialization_tests() {
let mut channel_state = bidirectional::ChannelState::<Bls12>::new(String::from("Channel A -> B"), false);
let mut rng = &mut rand::thread_rng();
let rng = &mut rand::thread_rng();
let serialized = serde_json::to_string(&channel_state).unwrap();
println!("new channel state len: {}", &serialized.len());
let chan_state: bidirectional::ChannelState<Bls12> = serde_json::from_str(&serialized).unwrap();
let _chan_state: bidirectional::ChannelState<Bls12> = serde_json::from_str(&serialized).unwrap();
let (mut channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant A");
let (mut channel_token, _merch_state, _channel_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant A");
let b0_cust = 100;
let b0_merch = 10;
let cust_state = bidirectional::init_customer(rng, &mut channel_token, b0_cust, b0_merch, "Customer A");
let serlalized_ct = serde_json::to_string(&channel_token).unwrap();
let serialized_ct = serde_json::to_string(&channel_token).unwrap();
println!("serialized ct: {:?}", &serlalized_ct);
println!("serialized ct: {:?}", &serialized_ct);
let des_ct: bidirectional::ChannelToken<Bls12> = serde_json::from_str(&serlalized_ct).unwrap();
let _des_ct: bidirectional::ChannelToken<Bls12> = serde_json::from_str(&serialized_ct).unwrap();
//println!("des_ct: {}", &des_ct);
let serlalized_cw = serde_json::to_string(&cust_state).unwrap();
let serialized_cw = serde_json::to_string(&cust_state).unwrap();
println!("serialized cw: {:?}", &serlalized_cw);
println!("serialized cw: {:?}", &serialized_cw);
let des_cw: bidirectional::CustomerState<Bls12> = serde_json::from_str(&serlalized_cw).unwrap();
let _des_cw: bidirectional::CustomerState<Bls12> = serde_json::from_str(&serialized_cw).unwrap();
}
}

4
src/nizk.rs
View File

@ -3,14 +3,13 @@ extern crate rand;
use super::*;
use rand::Rng;
use cl::{Signature, PublicParams, setup, BlindKeyPair, SignatureProof, PublicKey, BlindPublicKey};
use cl::{Signature, PublicParams, setup, BlindKeyPair, SignatureProof, BlindPublicKey};
use ped92::{Commitment, CSMultiParams, CommitmentProof};
use pairing::{Engine, CurveProjective};
use wallet::Wallet;
use ccs08::{SecretParamsUL, ParamsUL, ProofUL};
use serde::{Serialize, Deserialize};
use util;
use std::borrow::BorrowMut;
/// NIZKProof is the object that represents the NIZK Proof of Knowledge during the payment and closing protocol
#[derive(Clone, Serialize, Deserialize)]
@ -219,7 +218,6 @@ mod tests {
use super::*;
use pairing::bls12_381::{Bls12, Fr};
use util::convert_int_to_fr;
use rand::thread_rng;
use ff::PrimeField;
#[test]

61
src/ote.rs
View File

@ -1,61 +0,0 @@
/*
One-time encryption - keyspace of the OTE is also the range of the pseudo-random function
*/
use std::fmt;
use bn::{Group, Fr, G1};
use rand;
pub struct OTMessage {
pub m1: G1,
pub m2: G1
}
pub struct OTCiphertext {
c1: G1,
c2: G1
}
pub fn keygen() -> G1 {
let rng = &mut rand::thread_rng();
let k = G1::random(rng);
return k;
}
// encryption scheme can be implemented by encoding the plaintext as an element in a cyclic group G
// and multiplying by a random group element.
pub fn otenc(k: G1, m: &OTMessage) -> OTCiphertext {
let c1 = k + m.m1;
let c2 = k + m.m2;
assert!(c1 != c2);
return OTCiphertext { c1: c1, c2: c2 };
}
pub fn otdec(k: G1, c: &OTCiphertext) -> OTMessage {
let x = c.c1 - k;
let y = c.c2 - k;
return OTMessage { m1: x, m2: y};
}
#[cfg(test)]
mod tests {
use super::*;
use rand::{Rng, thread_rng};
use bn::{G1, Group};
#[test]
#[ignore]
fn one_time_enc_dec_works() {
let rng = &mut rand::thread_rng();
// Test the OTE scheme
let k = keygen();
let x = G1::random(rng);
let y = G1::random(rng);
let m = OTMessage { m1: x, m2: y };
let c = otenc(k, &m);
let orig_m = otdec(k, &c);
assert!(m.m1 == orig_m.m1 && m.m2 == orig_m.m2);
}
}

3
src/ped92.rs
View File

@ -6,7 +6,6 @@ use std::fmt;
use util::is_vec_g1_equal;
use serde::{Serialize, Deserialize};
use util;
use std::borrow::BorrowMut;
#[derive(Clone)]
pub struct CSParams<E: Engine> {
@ -346,7 +345,7 @@ mod tests {
let serialized = serde_json::to_string(&csp).unwrap();
let csp_des: CSMultiParams<Bls12> = serde_json::from_str(&serialized).unwrap();
let _csp_des: CSMultiParams<Bls12> = serde_json::from_str(&serialized).unwrap();
}
#[test]

47
src/prf.rs
View File

@ -1,47 +0,0 @@
/*
Pseudo-random Function (PRF) using Dodis-Yampolskiy PRF to support proofs of knowledge.
Properties:
- strong pr-image resistance
*/
use rand;
use bn::{Group, Fr, G1};
pub struct PRFKey {
s: Fr,
g: G1
}
// initialize the PRF with a seed and an optional generator
pub fn init_prf(s: Fr, gen: Option<G1>) -> PRFKey {
let rng = &mut rand::thread_rng();
let g = gen.unwrap_or(G1::random(rng));
return PRFKey { s: s, g: g };
}
// compute the PRF given the key and an input
pub fn compute(key: &PRFKey, x: Fr) -> G1 {
let r = key.s + x;
return key.g * r.inverse().unwrap();
}
#[cfg(test)]
mod tests {
use super::*;
use rand::{Rng, thread_rng};
use bn::{Fr, G1, Group};
#[test]
#[ignore]
fn prf_works() {
let rng = &mut rand::thread_rng();
let s = Fr::random(rng);
let key = init_prf(s, None);
let x = Fr::random(rng);
let y = compute(&key, x);
let z = compute(&key, x + Fr::from_str("1").unwrap());
// confirm that PRF(k, x) != PRF(k, x+1)
assert!(y != z);
}
}

99
src/sym.rs
View File

@ -1,99 +0,0 @@
/*
Symmetric Key Encryption Scheme.
*/
use std::fmt;
use sodiumoxide;
use sodiumoxide::init;
use sodiumoxide::crypto::secretbox;
pub struct SymCT {
nonce: secretbox::Nonce,
ciphertext: Vec<u8>
}
impl fmt::Display for SymCT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut y_s = String::new();
for y in self.ciphertext.iter() {
y_s = format!("{}{:x}", y_s, y);
}
write!(f, "CT : (ct=0x{})", y_s)
}
}
#[derive(Clone)]
pub struct SymKey {
key: secretbox::Key,
l: i32
}
pub fn init_mod() {
sodiumoxide::init();
}
pub fn keygen(l: i32) -> SymKey {
// TODO: make sure key is a l-bit key
return SymKey { key: secretbox::gen_key(), l: l };
}
pub fn encrypt(key: &SymKey, plaintext: &String) -> SymCT {
let nonce = secretbox::gen_nonce();
let pt = plaintext.as_bytes();
let ct = secretbox::seal(pt, &nonce, &key.key);
return SymCT { nonce: nonce, ciphertext: ct };
}
pub fn decrypt(key: &SymKey, ciphertext: &SymCT) -> String {
let nonce = ciphertext.nonce;
let pt = secretbox::open(&ciphertext.ciphertext, &nonce, &key.key).unwrap();
let plaintext = String::from_utf8(pt).expect("Found invalid UTF-8");
return plaintext;
}
#[cfg(test)]
mod tests {
use super::*;
use rand::{Rng, thread_rng};
#[test]
#[ignore]
fn symenc_dec_works() {
init_mod();
// SymKeyEnc tests
// TODO: figure out how to apply this to secretbox
let l = 128;
let key1 = keygen(l);
// println!("key: {:?}", key);
let pt1 = String::from("hello world");
let ciphertext = encrypt(&key1, &pt1);
//println!("{}", ciphertext);
let pt2 = decrypt(&key1, &ciphertext);
//println!("Recovered plaintext: {}", pt2);
assert!(pt1 == pt2);
}
#[test]
#[should_panic]
#[ignore]
fn symenc_dec_should_fail() {
init_mod();
// SymKeyEnc tests
// TODO: figure out how to apply this to secretbox
let l = 128;
let key1 = keygen(l);
let key2 = keygen(l);
let pt1 = String::from("hello world");
let ciphertext = encrypt(&key1, &pt1);
let pt3 = decrypt(&key2, &ciphertext);
// should fail and panic
}
}

7
src/util.rs
View File

@ -1,9 +1,7 @@
use super::*;
use pairing::Engine;
use ff::{PrimeField};
use rand::Rng;
use secp256k1::{Signature, PublicKey};
use sha2::{Sha512, Sha256, Digest};
use sha2::Digest;
pub fn is_vec_fr_equal<E: Engine>(a: &Vec<E::Fr>, b: &Vec<E::Fr>) -> bool {
(a.len() == b.len()) &&
@ -152,9 +150,8 @@ impl RevokedMessage {
#[cfg(test)]
mod tests {
use super::*;
use pairing::bls12_381::{Bls12, G2, Fr};
use pairing::bls12_381::{Bls12, G2};
use pairing::CurveProjective;
use ff::Field;
#[test]
fn hash_g2_to_fr_works() {