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

intermediary step with serializing data out to python

This commit is contained in:
Gabe Kaptchuk 2019-02-19 12:01:51 -05:00
parent 211d8e51ea
commit 574aa693eb
8 changed files with 681 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1 +1,3 @@
.idea/
target
Cargo.lock

10
Cargo.toml
View File

@ -15,11 +15,14 @@ rand_core = "0.2.1"
bn = { git = "https://github.com/ZcashFoundation/bn", branch = "master" }
bincode = "0.6.1"
sodiumoxide = "0.0.16"
serde = "1.0"
serde_derive = "1.0"
libc = "*"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
serde_with = "1.0"
time = "*"
rustc-serialize = "0.3"
secp256k1 = { git = "https://github.com/ZcashFoundation/rust-secp256k1", branch = "master", features = ["rand"] }
# secp256k1 = { git = "https://github.com/ZcashFoundation/rust-secp256k1", branch = "master", features = ["rand"] }
secp256k1 = { git = "https://github.com/ZcashFoundation/rust-secp256k1", branch = "master", features = ["rand", "serde"] }
curve25519-dalek = "1.0.0-pre.0"
merlin = "1.0.0"
bulletproofs = { git = "https://github.com/dalek-cryptography/bulletproofs", branch = "main" }
@ -31,5 +34,6 @@ default-features = false
features = ["rustc-serialize"]
[lib]
name = "libboltlib"
crate-type = ["lib", "cdylib"]

22
src/clproto.rs
View File

@ -1,5 +1,7 @@
// clproto.rs
extern crate serde;
use serialization_wrappers;
use std::fmt;
use std::str;
use rand::{thread_rng, Rng};
@ -15,12 +17,18 @@ use bincode::SizeLimit::Infinite;
use bincode::rustc_serialize::encode;
use clsigs::{PublicParams, SignatureD, PublicKeyD, SecretKeyD, hash_g2_to_fr, hash_gt_to_fr};
#[derive(Clone)]
use serde::Serialize;
#[derive(Clone, Serialize)]
pub struct ProofCV {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
pub T: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
pub C: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
pub s: Vec<Fr>,
pub num_secrets: usize,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
pub pub_bases: Vec<G2>
}
@ -125,19 +133,27 @@ pub fn prover_generate_blinded_sig(sig: &SignatureD) -> SignatureD {
return bsig;
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct CommonParams {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
vx: Gt,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
vxy: Gt,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
vxyi: Vec<Gt>,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
pub vs: Gt
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct ProofVS {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
T: Gt,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
A: Gt,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
s: Vec<Fr>,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
pub_bases: Vec<Gt>
}

44
src/clsigs.rs
View File

@ -1,4 +1,5 @@
// clsigs.rs
extern crate serde;
use std::fmt;
use std::str;
@ -13,15 +14,24 @@ use bincode::SizeLimit::Infinite;
use bincode::rustc_serialize::encode;
use sodiumoxide::crypto::hash::sha512;
use sodiumoxide::randombytes;
use serialization_wrappers;
use serde_with;
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
pub struct PublicParams {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_one")]
pub g1: G1,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
pub g2: G2
}
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct PublicKey {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_one")]
X: G1,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_one")]
Y: G1
}
@ -43,9 +53,11 @@ impl fmt::Display for PublicKey {
}
}
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Serialize)]
pub struct SecretKey {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_fr")]
x: Fr,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_fr")]
y: Fr
}
@ -60,16 +72,19 @@ impl SecretKey {
}
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct KeyPair {
pub sk: SecretKey,
pub pk: PublicKey
}
#[derive(Serialize)]
pub struct Signature {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
a: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
b: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
c: G2
}
@ -137,34 +152,47 @@ pub fn verify_a(mpk: &PublicParams, pk: &PublicKey, m: Fr, sig: &Signature) -> b
}
// scheme D - for a vector of messages
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct PublicKeyD {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_one")]
pub X: G1,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_one")]
pub Y: G1,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec", deserialize_with = "serialization_wrappers::deserialize_g_one_vec")]
pub Z: Vec<G1>,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec", deserialize_with = "serialization_wrappers::deserialize_g_two_vec")]
pub Z2: Vec<G2>,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec", deserialize_with = "serialization_wrappers::deserialize_g_one_vec")]
pub W: Vec<G1>
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct SecretKeyD {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_fr")]
pub x: Fr,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_fr")]
pub y: Fr,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec", deserialize_with = "serialization_wrappers::deserialize_fr_vec")]
pub z: Vec<Fr>
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct KeyPairD {
pub sk: SecretKeyD,
pub pk: PublicKeyD
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct SignatureD {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
pub a: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec", deserialize_with = "serialization_wrappers::deserialize_g_two_vec")]
pub A: Vec<G2>,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
pub b: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec", deserialize_with = "serialization_wrappers::deserialize_g_two_vec")]
pub B: Vec<G2>,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
pub c: G2
}

16
src/commit_scheme.rs
View File

@ -1,5 +1,7 @@
// commit_schemes.rs
extern crate serde;
use serialization_wrappers;
use std::fmt;
use rand::{thread_rng, Rng};
use bn::{Group, Fr, G1, G2};
@ -9,20 +11,27 @@ use bincode::SizeLimit::Infinite;
use bincode::rustc_serialize::encode;
use sodiumoxide::crypto::hash::sha512;
#[derive(Copy, Clone)]
use serde::{Serialize};
#[derive(Copy, Clone, Serialize)]
pub struct PublicKey {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
g: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
h: G2
}
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Serialize)]
pub struct Commitment {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
pub c: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
pub r: Fr
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct CSParams {
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
pub pub_bases: Vec<G2>
}
@ -44,7 +53,6 @@ impl fmt::Display for PublicKey {
}
}
impl fmt::Display for Commitment {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let c_vec: Vec<u8> = encode(&self.c, Infinite).unwrap();

229
src/lib.rs
View File

@ -25,6 +25,12 @@ extern crate bulletproofs;
extern crate curve25519_dalek;
extern crate sha2;
extern crate serde;
extern crate serde_with;
extern crate libc;
use std::fmt;
use std::str;
use bn::{Group, Fr, G1, G2, Gt};
@ -39,12 +45,15 @@ use curve25519_dalek::scalar::Scalar;
use merlin::Transcript;
use bulletproofs::{BulletproofGens, PedersenGens, RangeProof};
use serde::{Serialize, Deserialize};
pub mod prf;
pub mod sym;
pub mod ote;
pub mod clsigs;
pub mod commit_scheme;
pub mod clproto;
pub mod serialization_wrappers;
const E_MIN: i32 = 1;
const E_MAX: i32 = 255; // TODO: should be 2^32 - 1
@ -591,6 +600,10 @@ pub mod bidirectional {
use bincode::rustc_serialize::encode;
use bincode::SizeLimit::Infinite;
use serialization_wrappers;
use serde::{Serialize, Deserialize};
fn print_secret_vector(x: &Vec<Fr>) {
for i in 0 .. x.len() {
let msg = format!("x[{}] => ", i);
@ -605,15 +618,24 @@ pub mod bidirectional {
}
}
#[derive(Serialize, Deserialize)]
pub struct TestPublicParams {
pub cl_mpk: clsigs::PublicParams,
pub range_proof_bits: usize
}
#[derive(Serialize, Deserialize)]
pub struct PublicParams {
cl_mpk: clsigs::PublicParams,
l: usize, // messages for commitment
#[serde(serialize_with = "serialization_wrappers::serialize_bullet_proof", deserialize_with = "serialization_wrappers::deserialize_bullet_proof" )]
bp_gens: bulletproofs::BulletproofGens,
range_proof_bits: usize,
extra_verify: bool // extra verification for certain points in the establish/pay protocol
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct ChannelToken {
w_com: commit_scheme::Commitment,
pk: clsigs::PublicKeyD,
@ -621,62 +643,77 @@ pub mod bidirectional {
}
// proof of wallet signature, blind signature on wallet and common params for NIZK
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct CustomerWalletProof {
proof_cv: clproto::ProofCV, // proof of knowledge of committed values
proof_vs: clproto::ProofVS, // proof of knowledge of valid signature
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
bal_com: G2, // old balance commitment
blind_sig: clsigs::SignatureD, // a blind signature
common_params: clproto::CommonParams, // common params for NIZK
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct CustomerWallet {
sk: clsigs::SecretKeyD, // the secret key for the signature scheme (Is it possible to make this a generic field?)
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
cid: Fr, // channel Id
wpk: secp256k1::PublicKey, // signature verification key
// #[serde(serialize_with = "serialization_wrappers::serialize_secp256k1_secret_key")]
#[serde(skip)]
wsk: secp256k1::SecretKey, // signature signing key
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
h_wpk: Fr,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable")]
r: Fr, // random coins for commitment scheme
pub balance: i32, // the balance for the user
merchant_balance: i32,
#[serde(skip)]
signature: Option<clsigs::SignatureD>,
// proof of signature on wallet contents in zero-knowledge
#[serde(skip)]
proof: Option<CustomerWalletProof>,
#[serde(skip)]
refund_token: Option<clsigs::SignatureD>
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct MerchSecretKey {
sk: clsigs::SecretKeyD, // merchant signing key
pub balance: i32
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct InitCustomerData {
pub channel_token: ChannelToken,
pub csk: CustomerWallet,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
pub bases: Vec<G2>,
}
#[derive(Clone)]
#[derive(Clone, Serialize)]
pub struct InitMerchantData {
pub channel_token: clsigs::PublicKeyD,
pub csk: MerchSecretKey,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_vec")]
pub bases: Vec<G2>
}
// part of channel state
#[derive(Clone, Serialize)]
pub struct PubKeyMap {
wpk: secp256k1::PublicKey,
revoke_token: Option<secp256k1::Signature>
}
#[derive(Clone, Serialize, Deserialize)]
pub struct ChannelState {
keys: HashMap<String, PubKeyMap>,
R: i32,
tx_fee: i32,
pub name: String,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_fr")]
pub cid: Fr,
pub pay_init: bool,
pub channel_established: bool,
@ -1362,7 +1399,7 @@ pub mod bidirectional {
assert!(update_merchant_state(state, &wpk, Some(*rv_token)));
}
let mut s = secp256k1::Secp256k1::new();
let ser_rv_token = rv_token.serialize_compact(&s);
let ser_rv_token = rv_token.serialize_compact();
let rm = RevokedMessage::new(String::from("revoked"), wpk, Some(ser_rv_token));
// sign the revoked message
let signature = clsigs::sign_d(&pp.cl_mpk, &m_data.csk.sk, &rm.hash());
@ -1449,6 +1486,184 @@ pub mod bidirectional {
}
}
#[no_mangle]
pub mod ffishim {
extern crate libc;
use bidirectional;
use clsigs;
use serde::{Serialize};
use libc::{c_char};
use std::ffi::{CStr, CString};
use std::str;
use std::mem;
// fn deserialer_helper<T>(serialized: *mut c_char) -> T
// where
// T: Deserialize,
// {
// let bytes = unsafe { CStr::from_ptr(serialized).to_bytes() };
// let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
// serde_json::from_str(&name).unwrap()
// }
#[no_mangle]
pub extern fn ffishim_bidirectional_setup(extra_verify: u32) -> *mut c_char {
let mut ev = false;
if extra_verify > 1 {
ev = true;
}
let pp = bidirectional::setup(ev);
let ser = serde_json::to_string(&pp).unwrap();
// println!("ser = {:?}", ser);
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_channelstate_new(channel_name: String, third_party_support: u32) -> *mut c_char {
println!("channel_name = {:?}", channel_name);
let mut tps = false;
if third_party_support > 1 {
tps = true;
}
let channel = bidirectional::ChannelState::new(channel_name, tps);
let ser = serde_json::to_string(&channel).unwrap();
println!("ser = {:?}", ser);
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_teststruct() -> *mut c_char {
let cl_mpk_instance = clsigs::setup_d();
let test = bidirectional::TestPublicParams {
cl_mpk: cl_mpk_instance,
range_proof_bits: 52
};
let ser = serde_json::to_string(&test).unwrap();
// println!("ser = {:?}", ser);
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_teststruct_in(serialized_pp: *mut c_char) -> *mut c_char {
let bytes = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
let object: bidirectional::TestPublicParams = serde_json::from_str(&name).unwrap();
serialized_pp
}
#[no_mangle]
pub extern fn ffishim_bidirectional_keygen(serialized_pp: *mut c_char) -> *mut c_char {
let bytes = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
// println!("ser_in = {:?}", &name);
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name).unwrap();
let keypair = bidirectional::keygen(&deserialized_pp);
let ser = serde_json::to_string(&keypair).unwrap();
// println!("ser = {:?}", &ser);
let cser = CString::new(ser).unwrap();
// println!("ser = {:?}", &cser);
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_init_merchant(serialized_pp: *mut c_char, balance_merchant: i32, serialized_merchant_keypair: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
let init_merchant_data = bidirectional::init_merchant(&deserialized_pp, balance_merchant, &deserialized_merchant_keypair);
let ser = serde_json::to_string(&init_merchant_data).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
// TODO DOCUMENT CHANGE --> PUBLIC KEY TO THE FULL KEY PAIR
#[no_mangle]
pub extern fn ffishim_bidirectional_generate_commit_setup(serialized_pp: *mut c_char, serialized_merchant_keypair: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
let cm_csp = bidirectional::generate_commit_setup(&deserialized_pp, &deserialized_merchant_keypair.pk);
let ser = serde_json::to_string(&cm_csp).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
// let (mut cust_data, initc_time) = measure_ret_mut!(bidirectional::init_customer(&pp, &channel, b0_cust, b0_merch, &cm_csp, &cust_keypair));
#[no_mangle]
pub extern fn ffishim_bidirectional_init_customer(serialized_pp: *mut c_char, serializd_channel: *mut c_char, balance_customer: u32, balance_merchant: u32, serialized_commitment_setup: *mut c_char, serialized_customer_keypair: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel token
let bytes_channel = unsafe { CStr::from_ptr(serializd_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
// Deserialize the commitment setup
let bytes_commitment_setup = unsafe { CStr::from_ptr(serialized_commitment_setup).to_bytes() };
let name_commitment_setup: &str = str::from_utf8(bytes_commitment_setup).unwrap(); // make sure the bytes are UTF-8
let deserialized_ccommitment_setup: commit_scheme::CSParams = serde_json::from_str(&name_commitment_setup).unwrap();
// Deserialize the client keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_customer_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_customer_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
let cust_data = bidirectional::init_customer(&deserialized_pp, &deserialized_channel_state, balance_customer, balance_merchant, &deserialized_ccommitment_setup, &deserialized_customer_keypair);
let ser = serde_json::to_string(&cust_data).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
// #[no_mangle]
// pub extern fn ffishim_bidirectional_establish_customer_phase1(serialized_pp: *mut c_char, serialized_customer_data: *mut c_char, &merch_data.bases) -> *mut c_char {
// }
// #[no_mangle]
// pub extern fn ffishim_bidirectional_establish_merchant_phase2(serialized_pp: *mut c_char, serializd_channel: *mut c_char, &merch_data, &proof1) -> *mut c_char {
// }
// #[no_mangle]
// pub extern fn ffishim_bidirectional_establish_customer_final(serialized_pp: *mut c_char, &merch_keypair.pk, &mut cust_data.csk, serialized_wallet_sig: *mut c_char) -> *mut c_char {
// }
}
#[cfg(all(test, feature = "unstable"))]
mod benches {
use rand::{Rng, thread_rng};

76
src/main.py Normal file
View File

@ -0,0 +1,76 @@
from ctypes import cdll
from sys import platform
import sys, ctypes
from ctypes import c_void_p, c_uint8
if platform == 'darwin':
prefix = 'lib'
ext = 'dylib'
elif platform == 'win32':
prefix = ''
ext = 'dll'
else:
prefix = 'lib'
ext = 'so'
libbolt = cdll.LoadLibrary('target/debug/{}libboltlib.{}'.format(prefix, ext))
# lib.getathing.argtypes = (c_uint8, )
# libbolt.ffishim_bidirectional_teststruct.restype = c_void_p
# # lib.freeathing.argtypes = (c_void_p, )
# bi = libbolt.ffishim_bidirectional_teststruct
# a_thing = bi()
# print(ctypes.cast(a_thing, ctypes.c_char_p).value.decode('utf-8'))
# libbolt.ffishim_bidirectional_teststruct_in.argtypes = (c_void_p, )
# libbolt.ffishim_bidirectional_teststruct_in.restype = c_void_p
# infn = libbolt.ffishim_bidirectional_teststruct_in
# a_second_thing = infn(a_thing)
# print(ctypes.cast(a_thing, ctypes.c_char_p).value.decode('utf-8'))
# libbolt.ffishim_bidirectional_setup.argtypes
libbolt.ffishim_bidirectional_setup.restype = c_void_p
libbolt.ffishim_bidirectional_keygen.argtypes = (c_void_p, )
libbolt.ffishim_bidirectional_keygen.restype = c_void_p
libbolt.ffishim_bidirectional_init_merchant.argtypes = (c_void_p, c_uint8, c_void_p)
libbolt.ffishim_bidirectional_init_merchant.restype = c_void_p
libbolt.ffishim_bidirectional_generate_commit_setup.argtypes = (c_void_p, c_void_p)
libbolt.ffishim_bidirectional_generate_commit_setup.restype = c_void_p
bidirectional_setup = libbolt.ffishim_bidirectional_setup
bidirectional_keygen = libbolt.ffishim_bidirectional_keygen
bidirectional_init_merchant = libbolt.ffishim_bidirectional_init_merchant
bidirectional_generate_commit_setup = libbolt.ffishim_bidirectional_generate_commit_setup
pp = bidirectional_setup()
keys = bidirectional_keygen(pp)
channel_token = bidirectional_init_merchant(pp, 5, keys)
commit_setup = bidirectional_generate_commit_setup(pp, keys)
print(pp)
print(keys)
print(channel_token)
print(commit_setup)
print(ctypes.cast(pp, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(keys, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(channel_token, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(commit_setup, ctypes.c_char_p).value.decode('utf-8'))

307
src/serialization_wrappers.rs Normal file
View File

@ -0,0 +1,307 @@
use bincode::SizeLimit::Infinite;
use bincode::rustc_serialize::{encode,decode};
use bn::{Group, Fr, G1, G2, Gt};
use bulletproofs::{BulletproofGens, PedersenGens, RangeProof};
use secp256k1;
use std::fmt;
// use serde-rustc-serialize-interop;
use serde::{Serialize, Serializer, ser::SerializeSeq, ser::SerializeStruct, Deserialize, Deserializer, de::Visitor, de::Error, de::SeqAccess};
pub fn serialize_generic_encodable<T, S>(object: &T, serializer: S) -> Result<S::Ok, S::Error>
where
T: rustc_serialize::Encodable,
S: Serializer,
{
let v = encode(&object, Infinite).unwrap();
serializer.serialize_bytes(&v)
}
struct GOneVisitor;
impl<'de> Visitor<'de> for GOneVisitor {
type Value = G1;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of bytes representing an element of G1")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
if let Ok(Some(b)) = tmp {
// println!("Byte = {:?}", b);
bytes.push(b)
} else {
break;
}
}
Ok(decode(&bytes[..]).unwrap())
}
}
struct GTwoVisitor;
impl<'de> Visitor<'de> for GTwoVisitor {
type Value = G2;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of bytes representing an element of G2")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
if let Ok(Some(b)) = tmp {
// println!("Byte = {:?}", b);
bytes.push(b)
} else {
break;
}
}
Ok(decode(&bytes[..]).unwrap())
}
}
struct FieldVisitor;
impl<'de> Visitor<'de> for FieldVisitor {
type Value = Fr;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of bytes representing an element of G2")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
if let Ok(Some(b)) = tmp {
// println!("Byte = {:?}", b);
bytes.push(b)
} else {
break;
}
}
Ok(decode(&bytes[..]).unwrap())
}
}
pub fn deserialize_g_one<'de, D>(deserializer: D) -> Result<G1, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(GOneVisitor);
Ok(a.unwrap())
}
pub fn deserialize_g_two<'de, D>(deserializer: D) -> Result<G2, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(GTwoVisitor);
Ok(a.unwrap())
}
pub fn deserialize_fr<'de, D>(deserializer: D) -> Result<Fr, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(FieldVisitor);
Ok(a.unwrap())
}
pub fn serialize_generic_encodable_vec<T, S>(object: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
T: rustc_serialize::Encodable,
{
let mut seq = serializer.serialize_seq(Some(object.len()))?;
for e in object {
let v = encode(&e, Infinite).unwrap();
seq.serialize_element(&v);
// for i in v {
// seq.serialize_element(&i)?;
// }
}
seq.end()
}
struct G1VecVisitor;
impl<'de> Visitor<'de> for G1VecVisitor {
type Value = Vec<G1>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of G1")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
// println!("Hi G1VecVisitor");
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
if let Ok(Some(b)) = tmp {
// println!("Byte = {:?}", b);
vec.push(decode(&b[..]).unwrap());
} else {
break;
}
}
Ok(vec)
}
}
struct G2VecVisitor;
impl<'de> Visitor<'de> for G2VecVisitor {
type Value = Vec<G2>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of G2")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
// println!("Hi G2VecVisitor");
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
if let Ok(Some(b)) = tmp {
// println!("Byte = {:?}", b);
vec.push(decode(&b[..]).unwrap());
} else {
break;
}
}
Ok(vec)
}
}
struct FrVecVisitor;
impl<'de> Visitor<'de> for FrVecVisitor {
type Value = Vec<Fr>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of Fr")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
// println!("Hi FrVecVisitor");
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
// println!("tmp = {:?}", tmp);
if let Ok(Some(b)) = tmp {
// println!("Byte = {:?}", b);
vec.push(decode(&b[..]).unwrap());
} else {
break;
}
}
Ok(vec)
}
}
pub fn deserialize_g_one_vec<'de, D>(deserializer: D) -> Result<Vec<G1>, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(G1VecVisitor);
Ok(a.unwrap())
}
pub fn deserialize_g_two_vec<'de, D>(deserializer: D) -> Result<Vec<G2>, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(G2VecVisitor);
Ok(a.unwrap())
}
pub fn deserialize_fr_vec<'de, D>(deserializer: D) -> Result<Vec<Fr>, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(FrVecVisitor);
Ok(a.unwrap())
}
pub fn serialize_bullet_proof<S>(bp_gens: &bulletproofs::BulletproofGens, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut state = serializer.serialize_seq(Some(2))?;
state.serialize_element(&bp_gens.gens_capacity)?;
state.serialize_element(&bp_gens.party_capacity)?;
state.end()
}
struct BulletProofVisitor;
impl<'de> Visitor<'de> for BulletProofVisitor {
type Value = BulletproofGens;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of usize for a BulletproofGens")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut g_capacity: usize = 0;
let mut p_capacity: usize = 0;
let tmp = seq.next_element::<usize>();
if let Ok(Some(b)) = tmp {
g_capacity = b;
}
let tmp = seq.next_element::<usize>();
if let Ok(Some(b)) = tmp {
p_capacity = b;
}
Ok(BulletproofGens::new(g_capacity, p_capacity))
}
}
pub fn deserialize_bullet_proof<'de, D>(deserializer: D) -> Result<bulletproofs::BulletproofGens, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(BulletProofVisitor);
Ok(a.unwrap())
}