Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Ser deser more opts #54

Merged
merged 7 commits into from
Jun 17, 2021
Merged

Ser deser more opts #54

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
6479eb6
More options when serializing/deserializing: updated Rust part, Rust …
DanieleDiBenedetto Jun 11, 2021
3d53cfa
Fixed Java part
DanieleDiBenedetto Jun 14, 2021
c1397cf
Restored ci script
DanieleDiBenedetto Jun 14, 2021
9b34141
Slight modifications of serialization/deserialization interfaces
DanieleDiBenedetto Jun 14, 2021
4934855
Merge branch 'development_tmp' into ser_deser_more_opts
DanieleDiBenedetto Jun 17, 2021
238b01b
Updated dependencies
DanieleDiBenedetto Jun 17, 2021
d9a8d2d
Fix automerge error
DanieleDiBenedetto Jun 17, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions api/Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,10 +7,10 @@ edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
algebra = {version = "0.1.0", features = ["tweedle"], git = "https://github.com/HorizenOfficial/ginger-lib.git", branch = "development_tmp"}
primitives = {version = "0.1.0", features = ["tweedle", "merkle_tree"], git = "https://github.com/HorizenOfficial/ginger-lib.git", branch = "development_tmp"}
algebra = {version = "0.1.0", features = ["tweedle"], git = "https://github.com/HorizenOfficial/ginger-lib.git", branch = "misc_changes"}
primitives = {version = "0.1.0", features = ["tweedle", "merkle_tree"], git = "https://github.com/HorizenOfficial/ginger-lib.git", branch = "misc_changes"}

cctp_primitives = { git = "https://github.com/HorizenOfficial/zendoo-cctp-lib.git", branch = "cert_sc_id" }
cctp_primitives = { git = "https://github.com/HorizenOfficial/zendoo-cctp-lib.git", branch = "proofs_idx" }

#ouroboros = {path = "../ouroboros"}
demo-circuit = {path = "../demo-circuit"}
Expand Down
101 changes: 57 additions & 44 deletions api/src/cctp_calls.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -148,6 +148,8 @@ pub fn create_naive_threshold_sig_proof(
proving_key_path: &Path,
enforce_membership: bool,
zk: bool,
compressed_pk: bool,
compress_proof: bool,
) -> Result<(Vec<u8>, u64), Error> {

//Get max pks
Expand Down Expand Up @@ -191,11 +193,11 @@ pub fn create_naive_threshold_sig_proof(
*end_cumulative_sc_tx_comm_tree_root, mr_bt, ft_min_amount, btr_fee, max_pks,
);

let pk: ZendooProverKey = if enforce_membership {
read_from_file_checked(proving_key_path)
} else {
read_from_file(proving_key_path)
}?;
let pk: ZendooProverKey = read_from_file(
proving_key_path,
Some(enforce_membership),
Some(compressed_pk)
)?;

let proof = match pk {
ZendooProverKey::Darlin(_) => unimplemented!(),
Expand All @@ -209,7 +211,7 @@ pub fn create_naive_threshold_sig_proof(
zk,
if zk { Some(rng) } else { None },
)?;
serialize_to_buffer(&ZendooProof::CoboundaryMarlin(MarlinProof(proof)))?
serialize_to_buffer(&ZendooProof::CoboundaryMarlin(MarlinProof(proof)), Some(compress_proof))?
},
};
Ok((proof, valid_signatures))
Expand All @@ -227,8 +229,10 @@ pub fn verify_naive_threshold_sig_proof(
valid_sigs: u64,
proof: Vec<u8>,
check_proof: bool,
compressed_proof: bool,
vk_path: &Path,
check_vk: bool
check_vk: bool,
compressed_vk: bool,
) -> Result<bool, Error>
{
let bt_list_opt = if bt_list.len() > 0 {
Expand All @@ -251,25 +255,26 @@ pub fn verify_naive_threshold_sig_proof(

// Check that the proving system type of the vk and proof are the same, before
// deserializing them all
let vk_ps_type = read_from_file::<ProvingSystem>(vk_path)?;
let proof_ps_type = deserialize_from_buffer::<ProvingSystem>(&proof[..1])?;
let vk_ps_type = read_from_file::<ProvingSystem>(
vk_path,
None,
None,
)?;

let proof_ps_type = deserialize_from_buffer::<ProvingSystem>(
&proof[..1],
None,
None,
)?;

if vk_ps_type != proof_ps_type {
Err(ProvingSystemError::ProvingSystemMismatch)?
}

// Deserialize proof and vk
let vk: ZendooVerifierKey = if check_vk {
read_from_file_checked(vk_path)
} else {
read_from_file(vk_path)
}?;
let vk: ZendooVerifierKey = read_from_file(vk_path, Some(check_vk), Some(compressed_vk))?;

let proof: ZendooProof = if check_proof {
deserialize_from_buffer_checked(proof.as_slice())
} else {
deserialize_from_buffer(proof.as_slice())
}?;
let proof: ZendooProof = deserialize_from_buffer(proof.as_slice(), Some(check_proof), Some(compressed_proof))?;

// Verify proof
let rng = &mut OsRng;
Expand Down Expand Up @@ -401,7 +406,9 @@ mod test {
circ,
ProvingSystem::CoboundaryMarlin,
pk_path,
vk_path
vk_path,
Some(true),
Some(true)
).unwrap();
println!("generate_parameters finished");

Expand All @@ -413,7 +420,7 @@ mod test {
let keypair = schnorr_generate_key();
pks.push(keypair.0);
sks.push(keypair.1);
println!("sk: {:?}", into_i8(serialize_to_buffer(&keypair.1).unwrap()));
println!("sk: {:?}", into_i8(serialize_to_buffer(&keypair.1, None).unwrap()));
}
println!("pks / sks finished");

Expand All @@ -422,15 +429,15 @@ mod test {
sigs.push(None);
sigs.push(Some(schnorr_sign(&msg, &sks[2], &pks[2]).unwrap()));

println!("sk: {:?}", into_i8(serialize_to_buffer(&sks[0]).unwrap()));
println!("sk: {:?}", into_i8(serialize_to_buffer(&sks[2]).unwrap()));
println!("sk: {:?}", into_i8(serialize_to_buffer(&sks[1]).unwrap()));
println!("sk: {:?}", into_i8(serialize_to_buffer(&sks[0], None).unwrap()));
println!("sk: {:?}", into_i8(serialize_to_buffer(&sks[2], None).unwrap()));
println!("sk: {:?}", into_i8(serialize_to_buffer(&sks[1], None).unwrap()));

println!("sig: {:?}", into_i8(serialize_to_buffer(&sigs[0]).unwrap()));
println!("sig: {:?}", into_i8(serialize_to_buffer(&sigs[2]).unwrap()));
println!("sig: {:?}", into_i8(serialize_to_buffer(&sigs[0], None).unwrap()));
println!("sig: {:?}", into_i8(serialize_to_buffer(&sigs[2], None).unwrap()));

let constant = compute_pks_threshold_hash(pks.as_slice(), threshold).unwrap();
println!("Constant u8: {:?}", serialize_to_buffer(&constant).unwrap());
println!("Constant u8: {:?}", serialize_to_buffer(&constant, None).unwrap());

//Create and serialize proof
let (proof, quality) = create_naive_threshold_sig_proof(
Expand All @@ -446,8 +453,10 @@ mod test {
pk_path,
false,
false,
true,
true
).unwrap();
write_to_file(&proof, proof_path).unwrap();
write_to_file(&proof, proof_path, Some(true)).unwrap();

//Verify proof
assert!(verify_naive_threshold_sig_proof(
Expand All @@ -461,8 +470,10 @@ mod test {
quality,
proof.clone(),
true,
true,
vk_path,
true,
true,
).unwrap());


Expand All @@ -478,8 +489,10 @@ mod test {
quality - 1,
proof,
true,
true,
vk_path,
true,
true,
).unwrap());
}

Expand Down Expand Up @@ -539,24 +552,24 @@ mod test {
assert!(schnorr_verify_public_key(&pk)); //Verify pk

//Serialize/deserialize pk
let pk_serialized = serialize_to_buffer(&pk).unwrap();
let pk_serialized = serialize_to_buffer(&pk, Some(true)).unwrap();
assert_eq!(pk_serialized.len(), SCHNORR_PK_SIZE);
let pk_deserialized: SchnorrPk = deserialize_from_buffer_checked(&pk_serialized).unwrap();
let pk_deserialized: SchnorrPk = deserialize_from_buffer(&pk_serialized, Some(true), Some(true)).unwrap();
assert_eq!(pk, pk_deserialized);

//Serialize/deserialize sk
let sk_serialized = serialize_to_buffer(&sk).unwrap();
let sk_serialized = serialize_to_buffer(&sk, None).unwrap();
assert_eq!(sk_serialized.len(), SCHNORR_SK_SIZE);
let sk_deserialized = deserialize_from_buffer(&sk_serialized).unwrap();
let sk_deserialized = deserialize_from_buffer(&sk_serialized, None, None).unwrap();
assert_eq!(sk, sk_deserialized);

let sig = schnorr_sign(&msg, &sk, &pk).unwrap(); //Sign msg
assert!(is_valid(&sig));

//Serialize/deserialize sig
let sig_serialized = serialize_to_buffer(&sig).unwrap();
let sig_serialized = serialize_to_buffer(&sig, None).unwrap();
assert_eq!(sig_serialized.len(), SCHNORR_SIG_SIZE);
let sig_deserialized = deserialize_from_buffer(&sig_serialized).unwrap();
let sig_deserialized = deserialize_from_buffer(&sig_serialized, Some(true), None).unwrap();
assert_eq!(sig, sig_deserialized);

assert!(schnorr_verify_signature(&msg, &pk, &sig).unwrap()); //Verify sig
Expand All @@ -576,29 +589,29 @@ mod test {
assert!(vrf_verify_public_key(&pk)); //Verify pk

//Serialize/deserialize pk
let pk_serialized = serialize_to_buffer(&pk).unwrap();
let pk_serialized = serialize_to_buffer(&pk, Some(true)).unwrap();
assert_eq!(pk_serialized.len(), VRF_PK_SIZE);
let pk_deserialized: VRFPk = deserialize_from_buffer_checked(&pk_serialized).unwrap();
let pk_deserialized: VRFPk = deserialize_from_buffer(&pk_serialized, Some(true), Some(true)).unwrap();
assert_eq!(pk, pk_deserialized);

//Serialize/deserialize sk
let sk_serialized = serialize_to_buffer(&sk).unwrap();
let sk_serialized = serialize_to_buffer(&sk, None).unwrap();
assert_eq!(sk_serialized.len(), VRF_SK_SIZE);
let sk_deserialized = deserialize_from_buffer(&sk_serialized).unwrap();
let sk_deserialized = deserialize_from_buffer(&sk_serialized, None, None).unwrap();
assert_eq!(sk, sk_deserialized);

let (vrf_proof, vrf_out) = vrf_prove(&msg, &sk, &pk).unwrap(); //Create vrf proof for msg
assert!(is_valid(&vrf_proof));

//Serialize/deserialize vrf proof
let proof_serialized = serialize_to_buffer(&vrf_proof).unwrap();
let proof_serialized = serialize_to_buffer(&vrf_proof, Some(true)).unwrap();
assert_eq!(proof_serialized.len(), VRF_PROOF_SIZE);
let proof_deserialized = deserialize_from_buffer_checked(&proof_serialized).unwrap();
let proof_deserialized = deserialize_from_buffer(&proof_serialized, Some(true), Some(true)).unwrap();
assert_eq!(vrf_proof, proof_deserialized);

//Serialize/deserialize vrf out (i.e. a field element)
let vrf_out_serialized = serialize_to_buffer(&vrf_out).unwrap();
let vrf_out_deserialized = deserialize_from_buffer(&vrf_out_serialized).unwrap();
let vrf_out_serialized = serialize_to_buffer(&vrf_out, None).unwrap();
let vrf_out_deserialized = deserialize_from_buffer(&vrf_out_serialized, None, None).unwrap();
assert_eq!(vrf_out, vrf_out_deserialized);

let vrf_out_dup = vrf_proof_to_hash(&msg, &pk, &vrf_proof).unwrap(); //Verify vrf proof and get vrf out for msg
Expand Down Expand Up @@ -660,8 +673,8 @@ mod test {
}

// Serialization/deserialization test
let path_serialized = serialize_to_buffer(&path).unwrap();
let path_deserialized: GingerMHTPath = deserialize_from_buffer(&path_serialized).unwrap();
let path_serialized = serialize_to_buffer(&path, None).unwrap();
let path_deserialized: GingerMHTPath = deserialize_from_buffer(&path_serialized, Some(true), None).unwrap();
assert_eq!(path, path_deserialized);
}
}
Expand Down
Loading