From 18f836b51143f70517aaeaab42b95494d9c95a79 Mon Sep 17 00:00:00 2001 From: Johannes Hahn Date: Fri, 21 Mar 2025 12:34:09 +0100 Subject: [PATCH] Update dependencies and refactor random number generation to use `rng()` instead of `thread_rng()` --- Cargo.toml | 6 +- fuzz/Cargo.toml | 4 +- fuzz/fuzz_targets/fuzz_aggsig.rs | 4 +- src/aggsig.rs | 42 +- src/constants.rs | 4 + src/ecdh.rs | 10 +- src/ffi.rs | 646 +++++++++---------------------- src/key.rs | 53 ++- src/lib.rs | 69 ++-- src/macros.rs | 16 +- src/pedersen.rs | 114 +++--- 11 files changed, 351 insertions(+), 617 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6402e0e..4f130ee 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,7 +11,7 @@ repository = "https://github.com/mimblewimble/rust-secp256k1-zkp/" description = "Grin's fork with Zero-Knowledge extensions of Rust bindings for Pieter Wuille's `libsecp256k1` library. Implements ECDSA for the SECG elliptic curve group secp256k1 and related utilities." keywords = [ "crypto", "secp256k1", "grin", "bitcoin", "zero-knowledge" ] readme = "README.md" -edition = "2018" +edition = "2021" build = "build.rs" [build-dependencies] @@ -30,7 +30,7 @@ dev = ["clippy"] [dependencies] arrayvec = "0.7" clippy = {version = "0.0", optional = true} -rand = "0.5" +rand = "0.9.0" libc = "0.2" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" @@ -38,4 +38,4 @@ zeroize = { version = "1.1", features = ["zeroize_derive"] } [dev-dependencies] chrono = "0.4.5" -rand_core = "0.2" +rand_core = "0.9.3" diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml index b1c23b6..0a7c57e 100644 --- a/fuzz/Cargo.toml +++ b/fuzz/Cargo.toml @@ -4,13 +4,13 @@ name = "grin_secp256k1zkp-fuzz" version = "0.0.0" authors = ["Automatically generated"] publish = false -edition = "2018" +edition = "2021" [package.metadata] cargo-fuzz = true [dependencies] -libfuzzer-sys = "0.3" +libfuzzer-sys = "0.4.9" [dependencies.grin_secp256k1zkp] path = ".." diff --git a/fuzz/fuzz_targets/fuzz_aggsig.rs b/fuzz/fuzz_targets/fuzz_aggsig.rs index e5b681e..c3375c6 100644 --- a/fuzz/fuzz_targets/fuzz_aggsig.rs +++ b/fuzz/fuzz_targets/fuzz_aggsig.rs @@ -13,7 +13,7 @@ use secp256k1zkp::{ }; use secp256k1zkp::aggsig::AggSigContext; -use secp256k1zkp::rand::{Rng, thread_rng}; +use secp256k1zkp::rand::{Rng, rng}; fuzz_target!(|data: &[u8]| { let numkeys = 3; @@ -21,7 +21,7 @@ fuzz_target!(|data: &[u8]| { return (); } - let mut rng = thread_rng(); + let mut rng = rng(); let secp = Secp256k1::with_caps(ContextFlag::Full); let mut pks: Vec = Vec::with_capacity(numkeys); let mut keypairs: Vec<(SecretKey, PublicKey)> = Vec::with_capacity(numkeys); diff --git a/src/aggsig.rs b/src/aggsig.rs index d4227dd..62e8647 100644 --- a/src/aggsig.rs +++ b/src/aggsig.rs @@ -16,7 +16,7 @@ use libc::size_t; use crate::ffi; use crate::key::{PublicKey, SecretKey}; -use rand::{thread_rng, Rng}; +use rand::{rng, Rng}; use std::ptr; use crate::Secp256k1; use crate::{AggSigPartialSignature, Error, Message, Signature}; @@ -34,9 +34,9 @@ pub const ZERO_256: [u8; 32] = [ /// msg: the message to sign /// seckey: the secret key pub fn export_secnonce_single(secp: &Secp256k1) -> Result { - let mut return_key = SecretKey::new(&secp, &mut thread_rng()); + let mut return_key = SecretKey::new(&secp, &mut rng()); let mut seed = [0u8; 32]; - thread_rng().fill(&mut seed); + rng().fill(&mut seed); let retval = unsafe { ffi::secp256k1_aggsig_export_secnonce_single( secp.ctx, @@ -97,7 +97,7 @@ pub fn sign_single( ) -> Result { let mut retsig = Signature::from(ffi::Signature::new()); let mut seed = [0u8; 32]; - thread_rng().fill(&mut seed); + rng().fill(&mut seed); let secnonce = match secnonce { Some(n) => n.as_ptr(), @@ -302,7 +302,7 @@ impl AggSigContext { /// Creates new aggsig context with a new random seed pub fn new(secp: &Secp256k1, pubkeys: &Vec) -> AggSigContext { let mut seed = [0u8; 32]; - thread_rng().fill(&mut seed); + rng().fill(&mut seed); let pubkeys: Vec<*const ffi::PublicKey> = pubkeys.into_iter().map(|p| p.as_ptr()).collect(); let pubkeys = &pubkeys[..]; unsafe { @@ -431,7 +431,7 @@ mod tests { use crate::aggsig::subtract_partial_signature; use crate::ffi; use crate::key::{PublicKey, SecretKey}; - use rand::{thread_rng, Rng}; + use rand::{rng, Rng}; use crate::ContextFlag; use crate::{AggSigPartialSignature, Message, Signature}; @@ -441,7 +441,7 @@ use crate::ffi; let secp = Secp256k1::with_caps(ContextFlag::Full); let mut keypairs: Vec<(SecretKey, PublicKey)> = vec![]; for _ in 0..numkeys { - keypairs.push(secp.generate_keypair(&mut thread_rng()).unwrap()); + keypairs.push(secp.generate_keypair(&mut rng()).unwrap()); } let pks: Vec = keypairs.clone().into_iter().map(|(_, p)| p).collect(); println!( @@ -458,7 +458,7 @@ use crate::ffi; } let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); let mut partial_sigs: Vec = vec![]; for i in 0..numkeys { @@ -498,7 +498,7 @@ use crate::ffi; #[test] fn test_aggsig_single() { let secp = Secp256k1::with_caps(ContextFlag::Full); - let (sk, pk) = secp.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = secp.generate_keypair(&mut rng()).unwrap(); println!( "Performing aggsig single context with seckey, pubkey: {:?},{:?}", @@ -506,7 +506,7 @@ use crate::ffi; ); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); let sig = sign_single(&secp, &msg, &sk, None, None, None, None, None).unwrap(); @@ -519,7 +519,7 @@ use crate::ffi; assert!(result == true); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); println!( "Verifying aggsig single: {:?}, msg: {:?}, pk:{:?}", @@ -531,9 +531,9 @@ use crate::ffi; // test optional extra key let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk_extra, pk_extra) = secp.generate_keypair(&mut thread_rng()).unwrap(); + let (sk_extra, pk_extra) = secp.generate_keypair(&mut rng()).unwrap(); let sig = sign_single(&secp, &msg, &sk, None, Some(&sk_extra), None, None, None).unwrap(); let result = verify_single(&secp, &sig, &msg, None, &pk, None, Some(&pk_extra), false); assert!(result == true); @@ -548,9 +548,9 @@ use crate::ffi; let mut pub_keys: Vec = vec![]; for _ in 0..100 { - let (sk, pk) = secp.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = secp.generate_keypair(&mut rng()).unwrap(); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); let sig = sign_single(&secp, &msg, &sk, None, None, None, Some(&pk), None).unwrap(); @@ -571,7 +571,7 @@ use crate::ffi; #[test] fn test_aggsig_fuzz() { let secp = Secp256k1::with_caps(ContextFlag::Full); - let (sk, pk) = secp.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = secp.generate_keypair(&mut rng()).unwrap(); println!( "Performing aggsig single context with seckey, pubkey: {:?},{:?}", @@ -579,7 +579,7 @@ use crate::ffi; ); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); let sig = sign_single(&secp, &msg, &sk, None, None, None, None, None).unwrap(); @@ -677,7 +677,7 @@ use crate::ffi; assert!(result == false); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); if sign_single( &secp, @@ -699,8 +699,8 @@ use crate::ffi; for _ in 0..20 { let secp = Secp256k1::with_caps(ContextFlag::Full); // Generate keys for sender, receiver - let (sk1, pk1) = secp.generate_keypair(&mut thread_rng()).unwrap(); - let (sk2, pk2) = secp.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, pk1) = secp.generate_keypair(&mut rng()).unwrap(); + let (sk2, pk2) = secp.generate_keypair(&mut rng()).unwrap(); // Generate nonces for sender, receiver let secnonce_1 = export_secnonce_single(&secp).unwrap(); @@ -716,7 +716,7 @@ use crate::ffi; // Random message let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); // Add public keys (for storing in e) diff --git a/src/constants.rs b/src/constants.rs index c9a2c5f..08c8bf2 100644 --- a/src/constants.rs +++ b/src/constants.rs @@ -53,8 +53,10 @@ pub const PEDERSEN_COMMITMENT_SIZE_INTERNAL: usize = 64; /// The size of a single Bullet proof pub const SINGLE_BULLET_PROOF_SIZE: usize = 675; +/// The size of a single Bullet proof #[cfg(feature = "bullet-proof-sizing")] pub const MAX_PROOF_SIZE: usize = SINGLE_BULLET_PROOF_SIZE; + /// The max size of a range proof #[cfg(not(feature = "bullet-proof-sizing"))] pub const MAX_PROOF_SIZE: usize = 5134; @@ -62,6 +64,8 @@ pub const MAX_PROOF_SIZE: usize = 5134; /// The maximum size of a message embedded in a range proof #[cfg(not(feature = "bullet-proof-sizing"))] pub const PROOF_MSG_SIZE: usize = 2048; + +/// The maximum size of a message embedded in a range proof #[cfg(feature = "bullet-proof-sizing")] pub const PROOF_MSG_SIZE: usize = 2048; diff --git a/src/ecdh.rs b/src/ecdh.rs index 0b01113..28e69a4 100644 --- a/src/ecdh.rs +++ b/src/ecdh.rs @@ -92,15 +92,15 @@ impl ops::Index for SharedSecret { #[cfg(test)] mod tests { - use rand::thread_rng; + use rand::rng; use super::SharedSecret; use super::super::Secp256k1; #[test] fn ecdh() { let s = Secp256k1::with_caps(crate::ContextFlag::SignOnly); - let (sk1, pk1) = s.generate_keypair(&mut thread_rng()).unwrap(); - let (sk2, pk2) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, pk1) = s.generate_keypair(&mut rng()).unwrap(); + let (sk2, pk2) = s.generate_keypair(&mut rng()).unwrap(); let sec1 = SharedSecret::new(&s, &pk1, &sk2); let sec2 = SharedSecret::new(&s, &pk2, &sk1); @@ -112,7 +112,7 @@ mod tests { #[cfg(all(test, feature = "unstable"))] mod benches { - use rand::thread_rng; + use rand::rng; use test::{Bencher, black_box}; use super::SharedSecret; @@ -121,7 +121,7 @@ mod benches { #[bench] pub fn bench_ecdh(bh: &mut Bencher) { let s = Secp256k1::with_caps(::ContextFlag::SignOnly); - let (sk, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = s.generate_keypair(&mut rng()).unwrap(); let s = Secp256k1::new(); bh.iter( || { diff --git a/src/ffi.rs b/src/ffi.rs index 60f2534..35fcdd6 100644 --- a/src/ffi.rs +++ b/src/ffi.rs @@ -84,7 +84,7 @@ impl PublicKey { /// Create a new (zeroed) public key usable for the FFI interface pub fn new() -> PublicKey { PublicKey([0; 64]) } /// Create a new (uninitialized) public key usable for the FFI interface - pub unsafe fn blank() -> PublicKey { mem::MaybeUninit::uninit().assume_init() } + pub unsafe fn blank() -> PublicKey { mem::MaybeUninit::zeroed().assume_init() } } /// Library-internal representation of a Secp256k1 signature @@ -114,21 +114,21 @@ impl Signature { /// Create a signature from raw data pub fn from_data(data: [u8; 64]) -> Signature { Signature(data) } /// Create a new (uninitialized) signature usable for the FFI interface - pub unsafe fn blank() -> Signature { mem::MaybeUninit::uninit().assume_init() } + pub unsafe fn blank() -> Signature { mem::MaybeUninit::zeroed().assume_init() } } impl RecoverableSignature { /// Create a new (zeroed) signature usable for the FFI interface pub fn new() -> RecoverableSignature { RecoverableSignature([0; 65]) } /// Create a new (uninitialized) signature usable for the FFI interface - pub unsafe fn blank() -> RecoverableSignature { mem::MaybeUninit::uninit().assume_init() } + pub unsafe fn blank() -> RecoverableSignature { mem::MaybeUninit::zeroed().assume_init() } } impl AggSigPartialSignature { /// Create a new (zeroed) aggsig partial signature usable for the FFI interface pub fn new() -> AggSigPartialSignature { AggSigPartialSignature([0; 32]) } /// Create a new (uninitialized) signature usable for the FFI interface - pub unsafe fn blank() -> AggSigPartialSignature { mem::MaybeUninit::uninit().assume_init() } + pub unsafe fn blank() -> AggSigPartialSignature { mem::MaybeUninit::zeroed().assume_init() } } /// Library-internal representation of an ECDH shared secret @@ -141,477 +141,207 @@ impl SharedSecret { /// Create a new (zeroed) signature usable for the FFI interface pub fn new() -> SharedSecret { SharedSecret([0; 32]) } /// Create a new (uninitialized) signature usable for the FFI interface - pub unsafe fn blank() -> SharedSecret { mem::MaybeUninit::uninit().assume_init() } + pub unsafe fn blank() -> SharedSecret { mem::MaybeUninit::zeroed().assume_init() } } extern "C" { - pub static secp256k1_nonce_function_rfc6979: NonceFn; + /// Default nonce function + pub static secp256k1_nonce_function_rfc6979: NonceFn; + + /// Default nonce function pub static secp256k1_nonce_function_default: NonceFn; - // Contexts + /// Creates a new context. pub fn secp256k1_context_create(flags: c_uint) -> *mut Context; + /// Clones an existing context. pub fn secp256k1_context_clone(cx: *mut Context) -> *mut Context; + /// Destroys a context. pub fn secp256k1_context_destroy(cx: *mut Context); - pub fn secp256k1_context_randomize(cx: *mut Context, - seed32: *const c_uchar) - -> c_int; - // Scratch space - pub fn secp256k1_scratch_space_create(cx: *mut Context, - max_size: size_t) - -> *mut ScratchSpace; + /// Randomizes a context. + pub fn secp256k1_context_randomize(cx: *mut Context, seed32: *const c_uchar) -> c_int; + /// Creates a new scratch space. + pub fn secp256k1_scratch_space_create(cx: *mut Context, max_size: size_t) -> *mut ScratchSpace; + + /// Destroys a scratch space. pub fn secp256k1_scratch_space_destroy(sp: *mut ScratchSpace); - // Generator - pub fn secp256k1_generator_generate(cx: *const Context, - gen: *mut Generator, - seed32: *const c_uchar) - -> c_int; - - // TODO secp256k1_context_set_illegal_callback - // TODO secp256k1_context_set_error_callback - // (Actually, I don't really want these exposed; if either of these - // are ever triggered it indicates a bug in rust-secp256k1, since - // one goal is to use Rust's type system to eliminate all possible - // bad inputs.) - - // Pubkeys - pub fn secp256k1_ec_pubkey_parse(cx: *const Context, pk: *mut PublicKey, - input: *const c_uchar, in_len: size_t) - -> c_int; - - pub fn secp256k1_ec_pubkey_serialize(cx: *const Context, output: *const c_uchar, - out_len: *mut size_t, pk: *const PublicKey, - compressed: c_uint) - -> c_int; - - // Signatures - pub fn secp256k1_ecdsa_signature_parse_der(cx: *const Context, sig: *mut Signature, - input: *const c_uchar, in_len: size_t) - -> c_int; - - pub fn secp256k1_ecdsa_signature_parse_compact(cx: *const Context, sig: *mut Signature, - input64: *const c_uchar) - -> c_int; - - pub fn ecdsa_signature_parse_der_lax(cx: *const Context, sig: *mut Signature, - input: *const c_uchar, in_len: size_t) - -> c_int; - - pub fn secp256k1_ecdsa_signature_serialize_der(cx: *const Context, output: *const c_uchar, - out_len: *mut size_t, sig: *const Signature) - -> c_int; - - pub fn secp256k1_ecdsa_signature_serialize_compact(cx: *const Context, output64: *const c_uchar, - sig: *const Signature) - -> c_int; - - pub fn secp256k1_ecdsa_recoverable_signature_parse_compact(cx: *const Context, sig: *mut RecoverableSignature, - input64: *const c_uchar, recid: c_int) - -> c_int; - - pub fn secp256k1_ecdsa_recoverable_signature_serialize_compact(cx: *const Context, output64: *const c_uchar, - recid: *mut c_int, sig: *const RecoverableSignature) - -> c_int; - - pub fn secp256k1_ecdsa_recoverable_signature_convert(cx: *const Context, sig: *mut Signature, - input: *const RecoverableSignature) - -> c_int; - - pub fn secp256k1_ecdsa_signature_normalize(cx: *const Context, out_sig: *mut Signature, - in_sig: *const Signature) - -> c_int; - - // ECDSA - pub fn secp256k1_ecdsa_verify(cx: *const Context, - sig: *const Signature, - msg32: *const c_uchar, - pk: *const PublicKey) - -> c_int; - - pub fn secp256k1_ecdsa_sign(cx: *const Context, - sig: *mut Signature, - msg32: *const c_uchar, - sk: *const c_uchar, - noncefn: NonceFn, - noncedata: *const c_void) - -> c_int; - - pub fn secp256k1_ecdsa_sign_recoverable(cx: *const Context, - sig: *mut RecoverableSignature, - msg32: *const c_uchar, - sk: *const c_uchar, - noncefn: NonceFn, - noncedata: *const c_void) - -> c_int; - - pub fn secp256k1_ecdsa_recover(cx: *const Context, - pk: *mut PublicKey, - sig: *const RecoverableSignature, - msg32: *const c_uchar) - -> c_int; - // AGGSIG (Schnorr) Multisig - pub fn secp256k1_aggsig_context_create(cx: *const Context, - pks: *const PublicKey, - n_pks: size_t, - seed32: *const c_uchar) - -> *mut AggSigContext; + /// Generates a generator. + pub fn secp256k1_generator_generate(cx: *const Context, gen: *mut Generator, seed32: *const c_uchar) -> c_int; + + /// Parses a public key. + pub fn secp256k1_ec_pubkey_parse(cx: *const Context, pk: *mut PublicKey, input: *const c_uchar, in_len: size_t) -> c_int; + + /// Serializes a public key. + pub fn secp256k1_ec_pubkey_serialize(cx: *const Context, output: *const c_uchar, out_len: *mut size_t, pk: *const PublicKey, compressed: c_uint) -> c_int; + + /// Parses a DER-encoded ECDSA signature. + pub fn secp256k1_ecdsa_signature_parse_der(cx: *const Context, sig: *mut Signature, input: *const c_uchar, in_len: size_t) -> c_int; + + /// Parses a compact ECDSA signature. + pub fn secp256k1_ecdsa_signature_parse_compact(cx: *const Context, sig: *mut Signature, input64: *const c_uchar) -> c_int; + + /// Parses a DER-encoded ECDSA signature with lax rules. + pub fn ecdsa_signature_parse_der_lax(cx: *const Context, sig: *mut Signature, input: *const c_uchar, in_len: size_t) -> c_int; + + /// Serializes an ECDSA signature in DER format. + pub fn secp256k1_ecdsa_signature_serialize_der(cx: *const Context, output: *const c_uchar, out_len: *mut size_t, sig: *const Signature) -> c_int; + + /// Serializes an ECDSA signature in compact format. + pub fn secp256k1_ecdsa_signature_serialize_compact(cx: *const Context, output64: *const c_uchar, sig: *const Signature) -> c_int; + + /// Parses a compact recoverable ECDSA signature. + pub fn secp256k1_ecdsa_recoverable_signature_parse_compact(cx: *const Context, sig: *mut RecoverableSignature, input64: *const c_uchar, recid: c_int) -> c_int; + + /// Serializes a recoverable ECDSA signature in compact format. + pub fn secp256k1_ecdsa_recoverable_signature_serialize_compact(cx: *const Context, output64: *const c_uchar, recid: *mut c_int, sig: *const RecoverableSignature) -> c_int; + + /// Converts a recoverable ECDSA signature to a normal signature. + pub fn secp256k1_ecdsa_recoverable_signature_convert(cx: *const Context, sig: *mut Signature, input: *const RecoverableSignature) -> c_int; + + /// Normalizes an ECDSA signature. + pub fn secp256k1_ecdsa_signature_normalize(cx: *const Context, out_sig: *mut Signature, in_sig: *const Signature) -> c_int; + + /// Verifies an ECDSA signature. + pub fn secp256k1_ecdsa_verify(cx: *const Context, sig: *const Signature, msg32: *const c_uchar, pk: *const PublicKey) -> c_int; + /// Signs a message with ECDSA. + pub fn secp256k1_ecdsa_sign(cx: *const Context, sig: *mut Signature, msg32: *const c_uchar, sk: *const c_uchar, noncefn: NonceFn, noncedata: *const c_void) -> c_int; + + /// Signs a message with a recoverable ECDSA signature. + pub fn secp256k1_ecdsa_sign_recoverable(cx: *const Context, sig: *mut RecoverableSignature, msg32: *const c_uchar, sk: *const c_uchar, noncefn: NonceFn, noncedata: *const c_void) -> c_int; + + /// Recovers a public key from a recoverable ECDSA signature. + pub fn secp256k1_ecdsa_recover(cx: *const Context, pk: *mut PublicKey, sig: *const RecoverableSignature, msg32: *const c_uchar) -> c_int; + + /// Creates an aggregated signature context. + pub fn secp256k1_aggsig_context_create(cx: *const Context, pks: *const PublicKey, n_pks: size_t, seed32: *const c_uchar) -> *mut AggSigContext; + + /// Destroys an aggregated signature context. pub fn secp256k1_aggsig_context_destroy(aggctx: *mut AggSigContext); - pub fn secp256k1_aggsig_generate_nonce(cx: *const Context, - aggctx: *mut AggSigContext, - index: size_t) - -> c_int; - - pub fn secp256k1_aggsig_partial_sign(cx: *const Context, - aggctx: *mut AggSigContext, - sig: *mut AggSigPartialSignature, - msghash32: *const c_uchar, - seckey32: *const c_uchar, - index: size_t) - -> c_int; - - pub fn secp256k1_aggsig_combine_signatures(cx: *const Context, - aggctx: *mut AggSigContext, - sig64: *mut Signature, - partial: *const AggSigPartialSignature, - index: size_t) - -> c_int; - - pub fn secp256k1_aggsig_build_scratch_and_verify(cx: *const Context, - sig64: *const Signature, - msg32: *const c_uchar, - pks: *const PublicKey, - n_pubkeys: size_t) - -> c_int; - - // AGGSIG (single sig or single-signer Schnorr) - pub fn secp256k1_aggsig_export_secnonce_single(cx: *const Context, - secnonce32: *mut c_uchar, - seed32: *const c_uchar) - -> c_int; - - pub fn secp256k1_aggsig_sign_single(cx: *const Context, - sig: *mut Signature, - msg32: *const c_uchar, - seckey32: *const c_uchar, - secnonce32: *const c_uchar, - extra32: *const c_uchar, - pubnonce_for_e: *const PublicKey, - pubnonce_total: *const PublicKey, - pubkey_for_e: *const PublicKey, - seed32: *const c_uchar) - -> c_int; - - pub fn secp256k1_aggsig_verify_single(cx: *const Context, - sig: *const Signature, - msg32: *const c_uchar, - pubnonce: *const PublicKey, - pk: *const PublicKey, - pk_total: *const PublicKey, - extra_pubkey: *const PublicKey, - is_partial: c_uint) - -> c_int; - - pub fn secp256k1_schnorrsig_verify_batch(cx: *const Context, - scratch: *mut ScratchSpace, - sig: *const *const c_uchar, - msg32: *const *const c_uchar, - pk: *const *const PublicKey, - n_sigs: size_t) - -> c_int; - - pub fn secp256k1_aggsig_add_signatures_single(cx: *const Context, - ret_sig: *mut Signature, - sigs: *const *const c_uchar, - num_sigs: size_t, - pubnonce_total: *const PublicKey) - -> c_int; - - pub fn secp256k1_aggsig_subtract_partial_signature(cx: *const Context, - ret_partsig: *mut Signature, - ret_partsig_alt: *mut Signature, - sig: *const Signature, - part_sig: *const Signature) - -> c_int; - - // EC - pub fn secp256k1_ec_seckey_verify(cx: *const Context, - sk: *const c_uchar) -> c_int; - - pub fn secp256k1_ec_pubkey_create(cx: *const Context, pk: *mut PublicKey, - sk: *const c_uchar) -> c_int; - -//TODO secp256k1_ec_privkey_export -//TODO secp256k1_ec_privkey_import - - pub fn secp256k1_ec_privkey_tweak_add(cx: *const Context, - sk: *mut c_uchar, - tweak: *const c_uchar) - -> c_int; - - pub fn secp256k1_ec_pubkey_tweak_add(cx: *const Context, - pk: *mut PublicKey, - tweak: *const c_uchar) - -> c_int; - - pub fn secp256k1_ec_privkey_tweak_mul(cx: *const Context, - sk: *mut c_uchar, - tweak: *const c_uchar) - -> c_int; - - pub fn secp256k1_ec_pubkey_tweak_mul(cx: *const Context, - pk: *mut PublicKey, - tweak: *const c_uchar) - -> c_int; - - pub fn secp256k1_ec_pubkey_combine(cx: *const Context, - out: *mut PublicKey, - ins: *const *const PublicKey, - n: c_int) - -> c_int; - - pub fn secp256k1_ec_privkey_tweak_inv(cx: *const Context, - sk: *mut c_uchar) - -> c_int; - - pub fn secp256k1_ec_privkey_tweak_neg(cx: *const Context, - sk: *mut c_uchar) - -> c_int; - - pub fn secp256k1_ecdh(cx: *const Context, - out: *mut SharedSecret, - point: *const PublicKey, - scalar: *const c_uchar) - -> c_int; - - // Parse a 33-byte commitment into 64 byte internal commitment object - pub fn secp256k1_pedersen_commitment_parse(cx: *const Context, - commit: *mut c_uchar, - input: *const c_uchar) - -> c_int; - - // Serialize a 64-byte commit object into a 33 byte serialized byte sequence - pub fn secp256k1_pedersen_commitment_serialize(cx: *const Context, - output: *mut c_uchar, - commit: *const c_uchar) - -> c_int; - - - // Generates a pedersen commitment: *commit = blind * G + value * G2. - // The commitment is 33 bytes, the blinding factor is 32 bytes. - pub fn secp256k1_pedersen_commit( - ctx: *const Context, - commit: *mut c_uchar, - blind: *const c_uchar, - value: u64, - value_gen: *const c_uchar, - blind_gen: *const c_uchar - ) -> c_int; - - // Generates a pedersen commitment: *commit = blind * G + value * G2. - // The commitment is 33 bytes, the blinding factor and the value are 32 bytes. - pub fn secp256k1_pedersen_blind_commit( - ctx: *const Context, - commit: *mut c_uchar, - blind: *const c_uchar, - value: *const c_uchar, - value_gen: *const c_uchar, - blind_gen: *const c_uchar - ) -> c_int; - - // Get the public key of a pedersen commitment - pub fn secp256k1_pedersen_commitment_to_pubkey( - cx: *const Context, pk: *mut PublicKey, - commit: *const c_uchar) -> c_int; - - // Get a pedersen commitment from a pubkey - pub fn secp256k1_pubkey_to_pedersen_commitment( - cx: *const Context, commit: *mut c_uchar, - pk: *const PublicKey) -> c_int; - - // Takes a list of n pointers to 32 byte blinding values, the first negs - // of which are treated with positive sign and the rest negative, then - // calculates an additional blinding value that adds to zero. - pub fn secp256k1_pedersen_blind_sum( - ctx: *const Context, - blind_out: *const c_uchar, - blinds: *const *const c_uchar, - n: size_t, - npositive: size_t - ) -> c_int; - - // Takes two list of 64-byte commitments and sums the first set, subtracts - // the second and returns the resulting commitment. - pub fn secp256k1_pedersen_commit_sum( - ctx: *const Context, - commit_out: *const c_uchar, - commits: *const *const c_uchar, - pcnt: size_t, - ncommits: *const *const c_uchar, - ncnt: size_t - ) -> c_int; - - // Calculate blinding factor for switch commitment x + H(xG+vH | xJ) - pub fn secp256k1_blind_switch( - ctx: *const Context, - blind_switch: *mut c_uchar, - blind: *const c_uchar, - value: u64, - value_gen: *const c_uchar, - blind_gen: *const c_uchar, - switch_pubkey: *const c_uchar - ) -> c_int; - - // Takes two list of 64-byte commitments and sums the first set and - // subtracts the second and verifies that they sum to 0. - pub fn secp256k1_pedersen_verify_tally(ctx: *const Context, - commits: *const *const c_uchar, - pcnt: size_t, - ncommits: *const *const c_uchar, - ncnt: size_t - ) -> c_int; - - pub fn secp256k1_rangeproof_info( - ctx: *const Context, - exp: *mut c_int, - mantissa: *mut c_int, - min_value: *mut u64, - max_value: *mut u64, - proof: *const c_uchar, - plen: size_t - ) -> c_int; - - pub fn secp256k1_rangeproof_rewind( - ctx: *const Context, - blind_out: *mut c_uchar, - value_out: *mut u64, - message_out: *mut c_uchar, - outlen: *mut size_t, - nonce: *const c_uchar, - min_value: *mut u64, - max_value: *mut u64, - commit: *const c_uchar, - proof: *const c_uchar, - plen: size_t, - extra_commit: *const c_uchar, - extra_commit_len: size_t, - gen: *const c_uchar - ) -> c_int; - - pub fn secp256k1_rangeproof_verify( - ctx: *const Context, - min_value: &mut u64, - max_value: &mut u64, - commit: *const c_uchar, - proof: *const c_uchar, - plen: size_t, - extra_commit: *const c_uchar, - extra_commit_len: size_t, - gen: *const c_uchar - ) -> c_int; - - pub fn secp256k1_rangeproof_sign( - ctx: *const Context, - proof: *mut c_uchar, - plen: *mut size_t, - min_value: u64, - commit: *const c_uchar, - blind: *const c_uchar, - nonce: *const c_uchar, - exp: c_int, - min_bits: c_int, - value: u64, - message: *const c_uchar, - msg_len: size_t, - extra_commit: *const c_uchar, - extra_commit_len: size_t, - gen: *const c_uchar - ) -> c_int; - - pub fn secp256k1_bulletproof_generators_create( - ctx: *const Context, - blinding_gen: *const c_uchar, - n: size_t, - ) -> *mut BulletproofGenerators; - - pub fn secp256k1_bulletproof_generators_destroy( - ctx: *const Context, - gen: *mut BulletproofGenerators, - ); - - pub fn secp256k1_bulletproof_rangeproof_prove( - ctx: *const Context, - scratch: *mut ScratchSpace, - gens: *const BulletproofGenerators, - proof: *mut c_uchar, - plen: *mut size_t, - tau_x: *mut c_uchar, - t_one: *mut PublicKey, - t_two: *mut PublicKey, - value: *const u64, - min_value: *const u64, - blind: *const *const c_uchar, - commits: *const *const c_uchar, - n_commits: size_t, - value_gen: *const c_uchar, - nbits: size_t, - nonce: *const c_uchar, - private_nonce: *const c_uchar, - extra_commit: *const c_uchar, - extra_commit_len: size_t, - message: *const c_uchar, - ) -> c_int; - - pub fn secp256k1_bulletproof_rangeproof_verify( - ctx: *const Context, - scratch: *mut ScratchSpace, - gens: *const BulletproofGenerators, - proof: *const c_uchar, - plen: size_t, - min_value: *const u64, - commit: *const c_uchar, - n_commits: size_t, - nbits: size_t, - value_gen: *const c_uchar, - extra_commit: *const c_uchar, - extra_commit_len: size_t - ) -> c_int; - - pub fn secp256k1_bulletproof_rangeproof_verify_multi( - ctx: *const Context, - scratch: *mut ScratchSpace, - gens: *const BulletproofGenerators, - proofs: *const *const c_uchar, - n_proofs: size_t, - plen: size_t, - min_value: *const *const u64, - commits: *const *const c_uchar, - n_commits: size_t, - nbits: size_t, - value_gen: *const c_uchar, - extra_commit: *const *const c_uchar, - extra_commit_len: *const size_t - ) -> c_int; - - pub fn secp256k1_bulletproof_rangeproof_rewind( - ctx: *const Context, - value: *mut u64, - blind: *mut c_uchar, - proof: *const c_uchar, - plen: size_t, - min_value: u64, - commit: *const c_uchar, - value_gen: *const c_uchar, - nonce: *const c_uchar, - extra_commit: *const c_uchar, - extra_commit_len: size_t, - message: *mut c_uchar, - ) -> c_int; + /// Generates a nonce for an aggregated signature. + pub fn secp256k1_aggsig_generate_nonce(cx: *const Context, aggctx: *mut AggSigContext, index: size_t) -> c_int; + + /// Generates a partial signature for an aggregated signature. + pub fn secp256k1_aggsig_partial_sign(cx: *const Context, aggctx: *mut AggSigContext, sig: *mut AggSigPartialSignature, msghash32: *const c_uchar, seckey32: *const c_uchar, index: size_t) -> c_int; + + /// Combines partial signatures into a final signature. + pub fn secp256k1_aggsig_combine_signatures(cx: *const Context, aggctx: *mut AggSigContext, sig64: *mut Signature, partial: *const AggSigPartialSignature, index: size_t) -> c_int; + + /// Builds scratch space and verifies an aggregated signature. + pub fn secp256k1_aggsig_build_scratch_and_verify(cx: *const Context, sig64: *const Signature, msg32: *const c_uchar, pks: *const PublicKey, n_pubkeys: size_t) -> c_int; + + /// Exports a secret nonce for a single aggregated signature. + pub fn secp256k1_aggsig_export_secnonce_single(cx: *const Context, secnonce32: *mut c_uchar, seed32: *const c_uchar) -> c_int; + + /// Signs a single aggregated signature. + pub fn secp256k1_aggsig_sign_single(cx: *const Context, sig: *mut Signature, msg32: *const c_uchar, seckey32: *const c_uchar, secnonce32: *const c_uchar, extra32: *const c_uchar, pubnonce_for_e: *const PublicKey, pubnonce_total: *const PublicKey, pubkey_for_e: *const PublicKey, seed32: *const c_uchar) -> c_int; + + /// Verifies a single aggregated signature. + pub fn secp256k1_aggsig_verify_single(cx: *const Context, sig: *const Signature, msg32: *const c_uchar, pubnonce: *const PublicKey, pk: *const PublicKey, pk_total: *const PublicKey, extra_pubkey: *const PublicKey, is_partial: c_uint) -> c_int; + + /// Verifies a batch of Schnorr signatures. + pub fn secp256k1_schnorrsig_verify_batch(cx: *const Context, scratch: *mut ScratchSpace, sig: *const *const c_uchar, msg32: *const *const c_uchar, pk: *const *const PublicKey, n_sigs: size_t) -> c_int; + + /// Adds signatures for a single aggregated signature. + pub fn secp256k1_aggsig_add_signatures_single(cx: *const Context, ret_sig: *mut Signature, sigs: *const *const c_uchar, num_sigs: size_t, pubnonce_total: *const PublicKey) -> c_int; + + /// Subtracts a partial signature from another signature. + pub fn secp256k1_aggsig_subtract_partial_signature(cx: *const Context, ret_partsig: *mut Signature, ret_partsig_alt: *mut Signature, sig: *const Signature, part_sig: *const Signature) -> c_int; + + /// Verifies a secret key. + pub fn secp256k1_ec_seckey_verify(cx: *const Context, sk: *const c_uchar) -> c_int; + + /// Creates a public key from a secret key. + pub fn secp256k1_ec_pubkey_create(cx: *const Context, pk: *mut PublicKey, sk: *const c_uchar) -> c_int; + + /// Adds a tweak to a secret key. + pub fn secp256k1_ec_privkey_tweak_add(cx: *const Context, sk: *mut c_uchar, tweak: *const c_uchar) -> c_int; + + /// Adds a tweak to a public key. + pub fn secp256k1_ec_pubkey_tweak_add(cx: *const Context, pk: *mut PublicKey, tweak: *const c_uchar) -> c_int; + + /// Multiplies a secret key by a tweak. + pub fn secp256k1_ec_privkey_tweak_mul(cx: *const Context, sk: *mut c_uchar, tweak: *const c_uchar) -> c_int; + + /// Multiplies a public key by a tweak. + pub fn secp256k1_ec_pubkey_tweak_mul(cx: *const Context, pk: *mut PublicKey, tweak: *const c_uchar) -> c_int; + + /// Combines multiple public keys into one. + pub fn secp256k1_ec_pubkey_combine(cx: *const Context, out: *mut PublicKey, ins: *const *const PublicKey, n: c_int) -> c_int; + + /// Inverts a secret key. + pub fn secp256k1_ec_privkey_tweak_inv(cx: *const Context, sk: *mut c_uchar) -> c_int; + + /// Negates a secret key. + pub fn secp256k1_ec_privkey_tweak_neg(cx: *const Context, sk: *mut c_uchar) -> c_int; + + /// Computes an ECDH shared secret. + pub fn secp256k1_ecdh(cx: *const Context, out: *mut SharedSecret, point: *const PublicKey, scalar: *const c_uchar) -> c_int; + + /// Parses a Pedersen commitment. + pub fn secp256k1_pedersen_commitment_parse(cx: *const Context, commit: *mut c_uchar, input: *const c_uchar) -> c_int; + + /// Serializes a Pedersen commitment. + pub fn secp256k1_pedersen_commitment_serialize(cx: *const Context, output: *mut c_uchar, commit: *const c_uchar) -> c_int; + + /// Generates a Pedersen commitment. + pub fn secp256k1_pedersen_commit(cx: *const Context, commit: *mut c_uchar, blind: *const c_uchar, value: u64, value_gen: *const c_uchar, blind_gen: *const c_uchar) -> c_int; + + /// Generates a Pedersen commitment with a blind value. + pub fn secp256k1_pedersen_blind_commit(cx: *const Context, commit: *mut c_uchar, blind: *const c_uchar, value: *const c_uchar, value_gen: *const c_uchar, blind_gen: *const c_uchar) -> c_int; + + /// Converts a Pedersen commitment to a public key. + pub fn secp256k1_pedersen_commitment_to_pubkey(cx: *const Context, pk: *mut PublicKey, commit: *const c_uchar) -> c_int; + + /// Converts a public key to a Pedersen commitment. + pub fn secp256k1_pubkey_to_pedersen_commitment(cx: *const Context, commit: *mut c_uchar, pk: *const PublicKey) -> c_int; + + /// Computes a sum of Pedersen blinding factors. + pub fn secp256k1_pedersen_blind_sum(cx: *const Context, blind_out: *const c_uchar, blinds: *const *const c_uchar, n: size_t, npositive: size_t) -> c_int; + + /// Computes a sum of Pedersen commitments. + pub fn secp256k1_pedersen_commit_sum(cx: *const Context, commit_out: *const c_uchar, commits: *const *const c_uchar, pcnt: size_t, ncommits: *const *const c_uchar, ncnt: size_t) -> c_int; + + /// Calculates a blinding factor for a switch commitment. + pub fn secp256k1_blind_switch(cx: *const Context, blind_switch: *mut c_uchar, blind: *const c_uchar, value: u64, value_gen: *const c_uchar, blind_gen: *const c_uchar, switch_pubkey: *const c_uchar) -> c_int; + + /// Verifies a tally of Pedersen commitments. + pub fn secp256k1_pedersen_verify_tally(cx: *const Context, commits: *const *const c_uchar, pcnt: size_t, ncommits: *const *const c_uchar, ncnt: size_t) -> c_int; + + /// Retrieves information about a range proof. + pub fn secp256k1_rangeproof_info(cx: *const Context, exp: *mut c_int, mantissa: *mut c_int, min_value: *mut u64, max_value: *mut u64, proof: *const c_uchar, plen: size_t) -> c_int; + + /// Rewinds a range proof. + pub fn secp256k1_rangeproof_rewind(cx: *const Context, blind_out: *mut c_uchar, value_out: *mut u64, message_out: *mut c_uchar, outlen: *mut size_t, nonce: *const c_uchar, min_value: *mut u64, max_value: *mut u64, commit: *const c_uchar, proof: *const c_uchar, plen: size_t, extra_commit: *const c_uchar, extra_commit_len: size_t, gen: *const c_uchar) -> c_int; + + /// Verifies a range proof. + pub fn secp256k1_rangeproof_verify(cx: *const Context, min_value: &mut u64, max_value: &mut u64, commit: *const c_uchar, proof: *const c_uchar, plen: size_t, extra_commit: *const c_uchar, extra_commit_len: size_t, gen: *const c_uchar) -> c_int; + + /// Signs a range proof. + pub fn secp256k1_rangeproof_sign(cx: *const Context, proof: *mut c_uchar, plen: *mut size_t, min_value: u64, commit: *const c_uchar, blind: *const c_uchar, nonce: *const c_uchar, exp: c_int, min_bits: c_int, value: u64, message: *const c_uchar, msg_len: size_t, extra_commit: *const c_uchar, extra_commit_len: size_t, gen: *const c_uchar) -> c_int; + + /// Creates bulletproof generators. + pub fn secp256k1_bulletproof_generators_create(ctx: *const Context, blinding_gen: *const c_uchar, n: size_t) -> *mut BulletproofGenerators; + + /// Destroys bulletproof generators. + pub fn secp256k1_bulletproof_generators_destroy(ctx: *const Context, gen: *mut BulletproofGenerators); + + /// Proves a bulletproof range proof. + pub fn secp256k1_bulletproof_rangeproof_prove(ctx: *const Context, scratch: *mut ScratchSpace, gens: *const BulletproofGenerators, proof: *mut c_uchar, plen: *mut size_t, tau_x: *mut c_uchar, t_one: *mut PublicKey, t_two: *mut PublicKey, value: *const u64, min_value: *const u64, blind: *const *const c_uchar, commits: *const *const c_uchar, n_commits: size_t, value_gen: *const c_uchar, nbits: size_t, nonce: *const c_uchar, private_nonce: *const c_uchar, extra_commit: *const c_uchar, extra_commit_len: size_t, message: *const c_uchar) -> c_int; + + /// Verifies a bulletproof range proof. + pub fn secp256k1_bulletproof_rangeproof_verify(ctx: *const Context, scratch: *mut ScratchSpace, gens: *const BulletproofGenerators, proof: *const c_uchar, plen: size_t, min_value: *const u64, commit: *const c_uchar, n_commits: size_t, nbits: size_t, value_gen: *const c_uchar, extra_commit: *const c_uchar, extra_commit_len: size_t) -> c_int; + + /// Verifies multiple bulletproof range proofs. + pub fn secp256k1_bulletproof_rangeproof_verify_multi(ctx: *const Context, scratch: *mut ScratchSpace, gens: *const BulletproofGenerators, proofs: *const *const c_uchar, n_proofs: size_t, plen: size_t, min_value: *const *const u64, commits: *const *const c_uchar, n_commits: size_t, nbits: size_t, value_gen: *const c_uchar, extra_commit: *const *const c_uchar, extra_commit_len: *const size_t) -> c_int; + + /// Rewinds a bulletproof range proof. + pub fn secp256k1_bulletproof_rangeproof_rewind(ctx: *const Context, value: *mut u64, blind: *mut c_uchar, proof: *const c_uchar, plen: size_t, min_value: u64, commit: *const c_uchar, value_gen: *const c_uchar, nonce: *const c_uchar, extra_commit: *const c_uchar, extra_commit_len: size_t, message: *mut c_uchar) -> c_int; } diff --git a/src/key.rs b/src/key.rs index 6dd0fc4..09dc316 100644 --- a/src/key.rs +++ b/src/key.rs @@ -314,9 +314,8 @@ impl<'de> Deserialize<'de> for PublicKey { debug_assert!(constants::UNCOMPRESSED_PUBLIC_KEY_SIZE >= constants::COMPRESSED_PUBLIC_KEY_SIZE); let s = Secp256k1::with_caps(crate::ContextFlag::None); - unsafe { - use std::mem; - let mut ret: [u8; constants::UNCOMPRESSED_PUBLIC_KEY_SIZE] = mem::MaybeUninit::uninit().assume_init(); + + let mut ret: [u8; constants::UNCOMPRESSED_PUBLIC_KEY_SIZE] = [0; constants::UNCOMPRESSED_PUBLIC_KEY_SIZE]; let mut read_len = 0; while read_len < constants::UNCOMPRESSED_PUBLIC_KEY_SIZE { @@ -342,7 +341,7 @@ impl<'de> Deserialize<'de> for PublicKey { ), _ => Err(de::Error::invalid_length(read_len, &self)), } - } + } fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { @@ -373,7 +372,7 @@ mod test { use super::{PublicKey, SecretKey}; use super::super::constants; - use rand::{Error, RngCore, thread_rng}; + use rand::{RngCore, rng}; use self::rand_core::impls; use std::slice::from_raw_parts; @@ -436,7 +435,7 @@ mod test { fn keypair_slice_round_trip() { let s = Secp256k1::new(); - let (sk1, pk1) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, pk1) = s.generate_keypair(&mut rng()).unwrap(); assert_eq!(SecretKey::from_slice(&s, &sk1[..]), Ok(sk1)); assert_eq!(PublicKey::from_slice(&s, &pk1.serialize_vec(&s, true)[..]), Ok(pk1)); assert_eq!(PublicKey::from_slice(&s, &pk1.serialize_vec(&s, false)[..]), Ok(pk1)); @@ -466,7 +465,7 @@ mod test { #[test] fn test_pubkey_from_slice_bad_context() { let s = Secp256k1::without_caps(); - let sk = SecretKey::new(&s, &mut thread_rng()); + let sk = SecretKey::new(&s, &mut rng()); assert_eq!(PublicKey::from_secret_key(&s, &sk), Err(IncapableContext)); let s = Secp256k1::with_caps(ContextFlag::VerifyOnly); @@ -482,7 +481,7 @@ mod test { #[test] fn test_add_exp_bad_context() { let s = Secp256k1::with_caps(ContextFlag::Full); - let (sk, mut pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, mut pk) = s.generate_keypair(&mut rng()).unwrap(); assert!(pk.add_exp_assign(&s, &sk).is_ok()); @@ -555,7 +554,7 @@ mod test { fn test_serialize_serde() { let s = Secp256k1::new(); for _ in 0..500 { - let (sk, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = s.generate_keypair(&mut rng()).unwrap(); round_trip_serde!(sk); round_trip_serde!(pk); } @@ -582,9 +581,9 @@ mod test { data[31] = self.0; self.0 -= 1; } - fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> { + /*fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> { Ok(self.fill_bytes(dest)) - } + }*/ } let s = Secp256k1::new(); @@ -625,7 +624,7 @@ mod test { fn fill_bytes(&mut self, dest: &mut [u8]) { impls::fill_bytes_via_next(self, dest) } - fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), Error> { unimplemented!() } + //fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), Error> { unimplemented!() } } let s = Secp256k1::new(); @@ -649,7 +648,7 @@ mod test { fn fill_bytes(&mut self, dest: &mut [u8]) { impls::fill_bytes_via_next(self, dest) } - fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), Error> { unimplemented!() } + //fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), Error> { unimplemented!() } } let s = Secp256k1::new(); @@ -664,8 +663,8 @@ mod test { fn test_addition() { let s = Secp256k1::new(); - let (mut sk1, mut pk1) = s.generate_keypair(&mut thread_rng()).unwrap(); - let (mut sk2, mut pk2) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (mut sk1, mut pk1) = s.generate_keypair(&mut rng()).unwrap(); + let (mut sk2, mut pk2) = s.generate_keypair(&mut rng()).unwrap(); assert_eq!(PublicKey::from_secret_key(&s, &sk1).unwrap(), pk1); assert!(sk1.add_assign(&s, &sk2).is_ok()); @@ -682,8 +681,8 @@ mod test { fn test_multiplication() { let s = Secp256k1::new(); - let (mut sk1, mut pk1) = s.generate_keypair(&mut thread_rng()).unwrap(); - let (mut sk2, mut pk2) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (mut sk1, mut pk1) = s.generate_keypair(&mut rng()).unwrap(); + let (mut sk2, mut pk2) = s.generate_keypair(&mut rng()).unwrap(); assert_eq!(PublicKey::from_secret_key(&s, &sk1).unwrap(), pk1); assert!(sk1.mul_assign(&s, &sk2).is_ok()); @@ -700,8 +699,8 @@ mod test { fn test_pk_combination() { let s = Secp256k1::new(); - let (sk1, mut pk1) = s.generate_keypair(&mut thread_rng()).unwrap(); - let (sk2, mut pk2) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, mut pk1) = s.generate_keypair(&mut rng()).unwrap(); + let (sk2, mut pk2) = s.generate_keypair(&mut rng()).unwrap(); let combined_pk = PublicKey::from_combination(&s, vec![&pk1,&pk2]).unwrap(); @@ -725,13 +724,13 @@ mod test { one_inv.inv_assign(&s).unwrap(); assert_eq!(one_inv, one); - let (sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = sk1.clone(); sk2.inv_assign(&s).unwrap(); sk2.inv_assign(&s).unwrap(); assert_eq!(sk2, sk1); - let (sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = sk1.clone(); sk2.inv_assign(&s).unwrap(); sk2.mul_assign(&s, &sk1).unwrap(); @@ -742,18 +741,18 @@ mod test { fn test_negate() { let s = Secp256k1::new(); - let (sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = sk1.clone(); sk2.neg_assign(&s).unwrap(); assert!(sk2.add_assign(&s, &sk1).is_err()); - let (sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = sk1.clone(); sk2.neg_assign(&s).unwrap(); sk2.neg_assign(&s).unwrap(); assert_eq!(sk2, sk1); - let (mut sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (mut sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = sk1.clone(); sk1.neg_assign(&s).unwrap(); let sk1_clone = sk1.clone(); @@ -769,14 +768,14 @@ mod test { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]).unwrap(); - let (mut sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (mut sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = one.clone(); sk2.neg_assign(&s).unwrap(); sk2.mul_assign(&s, &sk1).unwrap(); sk1.neg_assign(&s).unwrap(); assert_eq!(sk2, sk1); - let (mut sk1, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (mut sk1, _) = s.generate_keypair(&mut rng()).unwrap(); let mut sk2: SecretKey = sk1.clone(); sk1.neg_assign(&s).unwrap(); sk1.inv_assign(&s).unwrap(); @@ -801,7 +800,7 @@ mod test { let mut set = HashSet::new(); const COUNT : usize = 1024; let count = (0..COUNT).map(|_| { - let (_, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (_, pk) = s.generate_keypair(&mut rng()).unwrap(); let hash = hash(&pk); assert!(!set.contains(&hash)); set.insert(hash); diff --git a/src/lib.rs b/src/lib.rs index 9f527b4..3bfc18a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,9 +259,8 @@ impl<'de> serde::Deserialize<'de> for Signature { where A: de::SeqAccess<'de> { let s = Secp256k1::with_caps(crate::ContextFlag::None); - unsafe { - use std::mem; - let mut ret: [u8; constants::COMPACT_SIGNATURE_SIZE] = mem::MaybeUninit::uninit().assume_init(); + + let mut ret: [u8; constants::COMPACT_SIGNATURE_SIZE] = [0; constants::COMPACT_SIGNATURE_SIZE]; for i in 0..constants::COMPACT_SIGNATURE_SIZE { ret[i] = match a.next_element()? { @@ -280,7 +279,7 @@ impl<'de> serde::Deserialize<'de> for Signature { _ => de::Error::custom(&e.to_string()), } ) - } + } fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { @@ -706,7 +705,7 @@ impl Secp256k1 { #[cfg(test)] mod tests { - use rand::{Rng, thread_rng}; + use rand::{Rng, rng}; use crate::key::{SecretKey, PublicKey}; use super::constants; use super::{Secp256k1, Signature, RecoverableSignature, Message, RecoveryId, ContextFlag}; @@ -734,15 +733,15 @@ mod tests { let full = Secp256k1::with_caps(ContextFlag::Full); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); // Try key generation - assert_eq!(none.generate_keypair(&mut thread_rng()), Err(IncapableContext)); - assert_eq!(vrfy.generate_keypair(&mut thread_rng()), Err(IncapableContext)); - assert!(sign.generate_keypair(&mut thread_rng()).is_ok()); - assert!(full.generate_keypair(&mut thread_rng()).is_ok()); - let (sk, pk) = full.generate_keypair(&mut thread_rng()).unwrap(); + assert_eq!(none.generate_keypair(&mut rng()), Err(IncapableContext)); + assert_eq!(vrfy.generate_keypair(&mut rng()), Err(IncapableContext)); + assert!(sign.generate_keypair(&mut rng()).is_ok()); + assert!(full.generate_keypair(&mut rng()).is_ok()); + let (sk, pk) = full.generate_keypair(&mut rng()).unwrap(); // Try signing assert_eq!(none.sign(&msg, &sk), Err(IncapableContext)); @@ -794,7 +793,7 @@ mod tests { let sig = RecoverableSignature::from_compact(&s, &[1; 64], RecoveryId(0)).unwrap(); let pk = PublicKey::new(); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); assert_eq!(s.verify(&msg, &sig.to_standard(&s), &pk), Err(InvalidPublicKey)); @@ -803,7 +802,7 @@ mod tests { #[test] fn sign() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); let one = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]; @@ -826,14 +825,14 @@ mod tests { #[test] fn signature_serialize_roundtrip() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); let mut msg = [0; 32]; for _ in 0..100 { - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, _) = s.generate_keypair(&mut rng()).unwrap(); let sig1 = s.sign(&msg, &sk).unwrap(); let der = sig1.serialize_der(&s); let sig2 = Signature::from_der(&s, &der[..]).unwrap(); @@ -874,14 +873,14 @@ mod tests { #[test] fn sign_and_verify() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); let mut msg = [0; 32]; for _ in 0..100 { - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = s.generate_keypair(&mut rng()).unwrap(); let sig = s.sign(&msg, &sk).unwrap(); assert_eq!(s.verify(&msg, &sig, &pk), Ok(())); } @@ -890,7 +889,7 @@ mod tests { #[test] fn sign_and_verify_extreme() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); // Wild keys: 1, CURVE_ORDER - 1 // Wild msgs: 0, 1, CURVE_ORDER - 1, CURVE_ORDER @@ -920,19 +919,19 @@ mod tests { #[test] fn sign_and_verify_fail() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = s.generate_keypair(&mut rng()).unwrap(); let sigr = s.sign_recoverable(&msg, &sk).unwrap(); let sig = sigr.to_standard(&s); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); assert_eq!(s.verify(&msg, &sig, &pk), Err(IncorrectSignature)); @@ -943,13 +942,13 @@ mod tests { #[test] fn sign_with_recovery() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = s.generate_keypair(&mut rng()).unwrap(); let sig = s.sign_recoverable(&msg, &sk).unwrap(); @@ -959,7 +958,7 @@ mod tests { #[test] fn bad_recovery() { let mut s = Secp256k1::new(); - s.randomize(&mut thread_rng()); + s.randomize(&mut rng()); let msg = Message::from_slice(&[0x55; 32]).unwrap(); @@ -1067,7 +1066,7 @@ mod tests { #[cfg(all(test, feature = "unstable"))] mod benches { - use rand::{Rng, thread_rng}; + use rand::{Rng, rng}; use test::{Bencher, black_box}; use super::{Secp256k1, Message}; @@ -1092,9 +1091,9 @@ mod benches { pub fn bench_sign(bh: &mut Bencher) { let s = Secp256k1::new(); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, _) = s.generate_keypair(&mut rng()).unwrap(); bh.iter(|| { let sig = s.sign(&msg, &sk).unwrap(); @@ -1106,9 +1105,9 @@ mod benches { pub fn bench_verify(bh: &mut Bencher) { let s = Secp256k1::new(); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, pk) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, pk) = s.generate_keypair(&mut rng()).unwrap(); let sig = s.sign(&msg, &sk).unwrap(); bh.iter(|| { @@ -1121,9 +1120,9 @@ mod benches { pub fn bench_recover(bh: &mut Bencher) { let s = Secp256k1::new(); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); - let (sk, _) = s.generate_keypair(&mut thread_rng()).unwrap(); + let (sk, _) = s.generate_keypair(&mut rng()).unwrap(); let sig = s.sign_recoverable(&msg, &sk).unwrap(); bh.iter(|| { diff --git a/src/macros.rs b/src/macros.rs index 9e2eefe..bad9bbb 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -75,11 +75,11 @@ macro_rules! impl_array_newtype { unsafe { use std::ptr::copy_nonoverlapping; use std::mem; - let mut ret: $thing = mem::MaybeUninit::uninit().assume_init(); + let mut ret = mem::MaybeUninit::<$thing>::uninit(); copy_nonoverlapping(self.as_ptr(), - ret.as_mut_ptr(), + (*ret.as_mut_ptr()).as_mut_ptr(), mem::size_of::<$thing>()); - ret + ret.assume_init() } } } @@ -160,9 +160,11 @@ macro_rules! impl_array_newtype { fn visit_seq(self, mut a: A) -> Result<$thing, A::Error> where A: ::serde::de::SeqAccess<'de> { - unsafe { - use std::mem; - let mut ret: [$ty; $len] = mem::MaybeUninit::uninit().assume_init(); + + + let mut ret: [$ty; $len] = [0; $len]; + + for i in 0..$len { ret[i] = match a.next_element()? { Some(c) => c, @@ -174,7 +176,7 @@ macro_rules! impl_array_newtype { return Err(::serde::de::Error::invalid_length($len + 1, &self)); } Ok($thing(ret)) - } + } fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { diff --git a/src/pedersen.rs b/src/pedersen.rs index 979750e..9506729 100644 --- a/src/pedersen.rs +++ b/src/pedersen.rs @@ -32,7 +32,7 @@ use crate::aggsig::ZERO_256; use crate::constants; use crate::ffi; use crate::key::{self, PublicKey, SecretKey}; -use rand::{thread_rng, Rng}; +use rand::{rng, Rng}; use serde::{de, ser}; const MAX_WIDTH: usize = 1 << 20; @@ -69,7 +69,7 @@ impl_pretty_debug!(CommitmentInternal); impl CommitmentInternal { /// Uninitialized commitment, use with caution pub unsafe fn blank() -> CommitmentInternal { - mem::MaybeUninit::uninit().assume_init() + mem::MaybeUninit::zeroed().assume_init() } } @@ -92,7 +92,7 @@ impl Commitment { /// Uninitialized commitment, use with caution unsafe fn blank() -> Commitment { - mem::MaybeUninit::uninit().assume_init() + mem::MaybeUninit::zeroed().assume_init() } /// Creates from a pubkey @@ -160,8 +160,8 @@ impl<'di> de::Visitor<'di> for Visitor { where V: de::SeqAccess<'di>, { - unsafe { - let mut ret: [u8; constants::MAX_PROOF_SIZE] = mem::MaybeUninit::uninit().assume_init(); + + let mut ret: [u8; constants::MAX_PROOF_SIZE] = [0; constants::MAX_PROOF_SIZE]; let mut i = 0; while let Some(val) = v.next_element()? { ret[i] = val; @@ -171,7 +171,7 @@ impl<'di> de::Visitor<'di> for Visitor { proof: ret, plen: i, }) - } + } } @@ -505,7 +505,7 @@ impl Secp256k1 { let mut neg = map_vec!(negative, |n| n.as_ptr()); let mut all = map_vec!(positive, |p| p.as_ptr()); all.append(&mut neg); - let mut ret: [u8; 32] = unsafe { mem::MaybeUninit::uninit().assume_init() }; + let mut ret: [u8; 32] = [0; 32]; unsafe { assert_eq!( ffi::secp256k1_pedersen_blind_sum( @@ -527,7 +527,7 @@ impl Secp256k1 { if self.caps != ContextFlag::Commit { return Err(Error::IncapableContext); } - let mut ret: [u8; 32] = unsafe { mem::MaybeUninit::uninit().assume_init() }; + let mut ret: [u8; 32] = [0; 32]; unsafe { assert_eq!( ffi::secp256k1_blind_switch( @@ -548,7 +548,7 @@ impl Secp256k1 { /// Convenience function for generating a random nonce for a range proof. /// We will need the nonce later if we want to rewind the range proof. pub fn nonce(&self) -> [u8; 32] { - thread_rng().gen::<[u8; 32]>() + rng().random::<[u8; 32]>() } /// Produces a range proof for the provided value, using min and max @@ -658,8 +658,8 @@ impl Secp256k1 { nonce: SecretKey, ) -> ProofInfo { let mut value: u64 = 0; - let mut blind: [u8; 32] = unsafe { mem::MaybeUninit::uninit().assume_init() }; - let mut message: [u8; constants::PROOF_MSG_SIZE] = unsafe { mem::MaybeUninit::uninit().assume_init() }; + let mut blind: [u8; 32] = [0; 32]; + let mut message: [u8; constants::PROOF_MSG_SIZE] = [0; constants::PROOF_MSG_SIZE]; let mut mlen: usize = constants::PROOF_MSG_SIZE; let mut min: u64 = 0; let mut max: u64 = 0; @@ -1129,7 +1129,7 @@ mod tests { use crate::ContextFlag; use crate::constants; - use rand::{thread_rng, Rng}; + use rand::{rng, Rng}; use crate::pedersen::tests::chrono::prelude::*; @@ -1215,8 +1215,8 @@ mod tests { secp.commit(value, blinding).unwrap() } - let blind_pos = SecretKey::new(&secp, &mut thread_rng()); - let blind_neg = SecretKey::new(&secp, &mut thread_rng()); + let blind_pos = SecretKey::new(&secp, &mut rng()); + let blind_neg = SecretKey::new(&secp, &mut rng()); // now construct blinding factor to net out appropriately let blind_sum = secp.blind_sum(vec![blind_pos.clone()], vec![blind_neg.clone()]).unwrap(); @@ -1239,8 +1239,8 @@ mod tests { let pos_value = 101; let neg_value = 75; - let blind_pos = secp.blind_switch(pos_value, SecretKey::new(&secp, &mut thread_rng())).unwrap(); - let blind_neg = secp.blind_switch(neg_value, SecretKey::new(&secp, &mut thread_rng())).unwrap(); + let blind_pos = secp.blind_switch(pos_value, SecretKey::new(&secp, &mut rng())).unwrap(); + let blind_neg = secp.blind_switch(neg_value, SecretKey::new(&secp, &mut rng())).unwrap(); // now construct blinding factor to net out appropriately let blind_sum = secp.blind_sum(vec![blind_pos.clone()], vec![blind_neg.clone()]).unwrap(); @@ -1257,7 +1257,7 @@ mod tests { // provide an api to extract a public key from a commitment fn test_to_pubkey() { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let commit = secp.commit(5, blinding).unwrap(); let pubkey = commit.to_pubkey(&secp); match pubkey { @@ -1274,7 +1274,7 @@ mod tests { fn test_from_pubkey() { for _ in 0..100 { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let commit = secp.commit(1, blinding).unwrap(); let pubkey = commit.to_pubkey(&secp); let p = match pubkey { @@ -1307,11 +1307,11 @@ mod tests { #[test] fn test_sign_with_pubkey_from_commitment() { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let commit = secp.commit(0u64, blinding.clone()).unwrap(); let mut msg = [0u8; 32]; - thread_rng().fill(&mut msg); + rng().fill(&mut msg); let msg = Message::from_slice(&msg).unwrap(); let sig = secp.sign(&msg, &blinding).unwrap(); @@ -1335,8 +1335,8 @@ mod tests { secp.commit(value, blinding).unwrap() } - let blind_a = SecretKey::new(&secp, &mut thread_rng()); - let blind_b = SecretKey::new(&secp, &mut thread_rng()); + let blind_a = SecretKey::new(&secp, &mut rng()); + let blind_b = SecretKey::new(&secp, &mut rng()); let commit_a = commit(3, blind_a.clone()); let commit_b = commit(2, blind_b.clone()); @@ -1359,7 +1359,7 @@ mod tests { #[test] fn test_blind_commit() { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let rng = &mut thread_rng(); + let rng = &mut rng(); let value: u64 = 1; let blind = SecretKey::new(&secp, rng); let blind2 = ONE_KEY; @@ -1369,8 +1369,8 @@ mod tests { assert_ne!(secp.commit(value, blind.clone()).unwrap(), secp.commit_blind(blind2, blind.clone()).unwrap()); let blind = SecretKey::new(&secp, rng); let mut blind2 = ZERO_KEY; - blind2.0[30] = rng.gen::(); - blind2.0[31] = rng.gen::(); + blind2.0[30] = rng.random::(); + blind2.0[31] = rng.random::(); let value: u64 = blind2[30] as u64*256 + blind2[31] as u64; assert_eq!(secp.commit(value, blind.clone()).unwrap(), secp.commit_blind(blind2, blind.clone()).unwrap()); } @@ -1378,7 +1378,7 @@ mod tests { #[test] fn test_range_proof() { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let commit = secp.commit(7, blinding.clone()).unwrap(); let msg = ProofMessage::empty(); let range_proof = secp.range_proof(0, 7, blinding.clone(), commit, msg.clone()); @@ -1398,7 +1398,7 @@ mod tests { assert_eq!(proof_info.value, 7); // check we cannot rewind a range proof without the original nonce - let bad_nonce = SecretKey::new(&secp, &mut thread_rng()); + let bad_nonce = SecretKey::new(&secp, &mut rng()); let bad_info = secp.rewind_range_proof(commit, range_proof, bad_nonce); assert_eq!(bad_info.success, false); assert_eq!(bad_info.value, 0); @@ -1417,7 +1417,7 @@ mod tests { fn test_bullet_proof_single() { // Test Bulletproofs without message let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let value = 12345678; let commit = secp.commit(value, blinding.clone()).unwrap(); let bullet_proof = secp.bullet_proof(value, blinding.clone(), blinding.clone(), blinding.clone(), None, None); @@ -1443,7 +1443,7 @@ mod tests { // wrong blinding let value = 12345678; let commit = secp.commit(value, blinding).unwrap(); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let bullet_proof = secp.bullet_proof(value, blinding.clone(), blinding.clone(), blinding.clone(), None, None); if !secp .verify_bullet_proof(commit, bullet_proof, None) @@ -1454,7 +1454,7 @@ mod tests { // Commit to some extra data in the bulletproof let extra_data = [0u8; 32].to_vec(); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let value = 12345678; let commit = secp.commit(value, blinding.clone()).unwrap(); let bullet_proof = @@ -1479,9 +1479,9 @@ mod tests { // Ensure rewinding works - let blinding = SecretKey::new(&secp, &mut thread_rng()); - let rewind_nonce = SecretKey::new(&secp, &mut thread_rng()); - let private_nonce = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); + let rewind_nonce = SecretKey::new(&secp, &mut rng()); + let private_nonce = SecretKey::new(&secp, &mut rng()); let value = 12345678; let commit = secp.commit(value, blinding.clone()).unwrap(); @@ -1556,8 +1556,8 @@ mod tests { let common_nonce = nonce; - let private_nonce_a = SecretKey::new(&secp, &mut thread_rng()); - let private_nonce_b = SecretKey::new(&secp, &mut thread_rng()); + let private_nonce_a = SecretKey::new(&secp, &mut rng()); + let private_nonce_b = SecretKey::new(&secp, &mut rng()); // 1st step on party A: generate t_one and t_two, and sends to party B let mut t_one_a = PublicKey::new(); @@ -1605,7 +1605,7 @@ mod tests { let mut t_two_sum = PublicKey::from_combination(&secp, pubkeys.clone()).unwrap(); // 2nd step on party A: use t_one_sum and t_two_sum to generate tau_x, and sent to party B. - let mut tau_x_a = SecretKey::new(&secp, &mut thread_rng()); + let mut tau_x_a = SecretKey::new(&secp, &mut rng()); secp.bullet_proof_multisig( value, blinding_a.clone(), @@ -1621,7 +1621,7 @@ mod tests { ); // 2nd step on party B: use t_one_sum and t_two_sum to generate tau_x, and send to party A. - let mut tau_x_b = SecretKey::new(&secp, &mut thread_rng()); + let mut tau_x_b = SecretKey::new(&secp, &mut rng()); secp.bullet_proof_multisig( value, blinding_b.clone(), @@ -1666,12 +1666,12 @@ mod tests { let secp = Secp256k1::with_caps(ContextFlag::Commit); let value: u64 = 12345678; - let common_nonce = SecretKey::new(&secp, &mut thread_rng()); + let common_nonce = SecretKey::new(&secp, &mut rng()); - let blinding_a = SecretKey::new(&secp, &mut thread_rng()); + let blinding_a = SecretKey::new(&secp, &mut rng()); let partial_commit_a = secp.commit(value, blinding_a.clone()).unwrap(); - let blinding_b = SecretKey::new(&secp, &mut thread_rng()); + let blinding_b = SecretKey::new(&secp, &mut rng()); let partial_commit_b = secp.commit(0, blinding_b.clone()).unwrap(); // 1. Test Bulletproofs multisig without message @@ -1704,7 +1704,7 @@ mod tests { } // 3. wrong blinding - let wrong_blinding = SecretKey::new(&secp, &mut thread_rng()); + let wrong_blinding = SecretKey::new(&secp, &mut rng()); let (_, proof_range) = multisig_bp( value, common_nonce.clone(), @@ -1739,7 +1739,7 @@ mod tests { // Ensure rewinding works /* let mut extra_data = [0u8; 32]; - thread_rng().fill(&mut extra_data); + rng().fill(&mut extra_data); let (bullet_proof, _) = multisig_bp( value, @@ -1815,8 +1815,8 @@ mod tests { #[test] fn rewind_empty_message() { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); - let nonce = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); + let nonce = SecretKey::new(&secp, &mut rng()); let value = ::max_value() - 1; let commit = secp.commit(value, blinding.clone()).unwrap(); @@ -1835,8 +1835,8 @@ mod tests { #[test] fn rewind_message() { let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); - let nonce = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); + let nonce = SecretKey::new(&secp, &mut rng()); let value = ::max_value() - 1; let commit = secp.commit(value, blinding.clone()).unwrap(); @@ -1849,7 +1849,7 @@ mod tests { assert_eq!(blinding, proof_info.blinding); // Using a different private nonce should prevent rewind of blinding factor - let private_nonce = SecretKey::new(&secp, &mut thread_rng()); + let private_nonce = SecretKey::new(&secp, &mut rng()); let bullet_proof = secp.bullet_proof(value, blinding.clone(), nonce.clone(), private_nonce.clone(), None, None); let proof_info = secp .rewind_bullet_proof(commit, nonce, None, bullet_proof) @@ -1864,7 +1864,7 @@ mod tests { let nano_to_millis = 1.0 / 1_000_000.0; let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); let value = 12345678; let increments = vec![1, 2, 5, 10, 100, 200]; @@ -1878,21 +1878,21 @@ mod tests { } println!("--------"); println!("Comparing {} Proofs", v); - let start = Utc::now().timestamp_nanos(); + let start = Utc::now().timestamp_nanos_opt().unwrap(); for i in 0..v { let proof_range = secp .verify_bullet_proof(commits[i].clone(), proofs[i].clone(), None) .unwrap(); assert_eq!(proof_range.min, 0); } - let fin = Utc::now().timestamp_nanos(); - let dur_ms = (fin - start) as f64 * nano_to_millis; + let fin = Utc::now().timestamp_nanos_opt().unwrap(); + let dur_ms: f64 = (fin - start) as f64 * nano_to_millis; println!("{} proofs single validated in {}ms", v, dur_ms); - let start = Utc::now().timestamp_nanos(); + let start = Utc::now().timestamp_nanos_opt().unwrap(); let proof_range = secp.verify_bullet_proof_multi(commits.clone(), proofs.clone(), None); assert!(!proof_range.is_err()); - let fin = Utc::now().timestamp_nanos(); + let fin = Utc::now().timestamp_nanos_opt().unwrap(); let dur_ms = (fin - start) as f64 * nano_to_millis; println!("{} proofs batch validated in {}ms", v, dur_ms); } @@ -1904,10 +1904,10 @@ mod tests { let mut proofs: Vec = vec![]; let secp = Secp256k1::with_caps(ContextFlag::Commit); - let blinding = SecretKey::new(&secp, &mut thread_rng()); - let rewind_nonce = SecretKey::new(&secp, &mut thread_rng()); - let private_nonce = SecretKey::new(&secp, &mut thread_rng()); - let wrong_blinding = SecretKey::new(&secp, &mut thread_rng()); + let blinding = SecretKey::new(&secp, &mut rng()); + let rewind_nonce = SecretKey::new(&secp, &mut rng()); + let private_nonce = SecretKey::new(&secp, &mut rng()); + let wrong_blinding = SecretKey::new(&secp, &mut rng()); let value = 12345678; let wrong_commit = secp.commit(value, wrong_blinding).unwrap();