Stable rust (#47)

* Support stable rust

Updated dependencies such that Rust stable 1.53 is now supported.
The optimised avx_2 option will NOT rust on stable because there's
still an unstable feature on subtle-ng. BUT this feature is actually
for doc generation and has been removed from Rust. As soon as subtle-ng
merges dalek-cryptography/subtle#85, avx2 will
probably be supported on stable as well.

The rand dep update breaks the benchmarks, but these will be fixed in
the next commit.

* Update benchmarks and fmt

* Update benchmark code to use new dependency APIs
* Run rust-fmt

Author: CjS77

Cargo.toml

@@ -7,18 +7,18 @@ categories = ["cryptography"]
 homepage = "https://tari.com"
 readme = "README.md"
 license = "BSD-3-Clause"
-version = "0.9.1"
+version = "0.10.0"
 edition = "2018"
 
 [dependencies]
 tari_utilities = "^0.3"
 base64 = "0.10.1"
 digest = "0.8.0"
-rand = "0.7.2"
+rand = { version = "0.8", default-features = false }
 clear_on_drop = "=0.2.4"
-curve25519-dalek = { version = "2" }
-bulletproofs = {version = "2.1.0" , package="tari_bulletproofs"}
-merlin = "2.0.0"
+curve25519-dalek = { package = "curve25519-dalek-ng", version = "4", default-features = false, features = ["u64_backend", "serde", "alloc"] }
+bulletproofs = {version = "4.0.0", package="tari_bulletproofs"}
+merlin = { version = "3", default-features = false }
 sha2 = "0.8.0"
 sha3 = "0.9"
 thiserror = "1.0.20"
@@ -33,16 +33,21 @@ libc = { version = "0.2", optional = true }
 wasm-bindgen = { version = "^0.2", features = ["serde-serialize"], optional = true }
 
 [dev-dependencies]
-criterion = "0.2"
+criterion = "0.3.4"
 bincode = "1.1.4"
 
 [build-dependencies]
 cbindgen = "0.17.0"
 
 [features]
-default = []
+default = ["no_cc"]
+# Note: avx2 still requires a nightly compiler as of 01/07/2021
+# The nightly compiler must be older than 2021-06-03 to avoid the
+# #![cfg_attr(feature = "nightly", feature(external_doc))]
+#                                          ^^^^^^^^^^^^ feature has been removed
+# feature error on subtle-ng
 avx2 = ["curve25519-dalek/avx2_backend", "bulletproofs/avx2_backend"]
-wasm = ["wasm-bindgen", "rand/wasm-bindgen", "rand/getrandom"]
+wasm = ["wasm-bindgen",  "rand/getrandom"]
 ffi = ["libc"]
 no_cc_nightly = ["clear_on_drop/nightly"]
 no_cc = ["clear_on_drop/no_cc"]

benches/range_proof.rs

@@ -20,7 +20,7 @@
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 // USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use criterion::{criterion_group, Criterion};
+use criterion::{criterion_group, BenchmarkId, Criterion};
 use rand::{thread_rng, Rng};
 use std::time::Duration;
 use tari_crypto::{
@@ -40,36 +40,31 @@ fn setup(n: usize) -> (DalekRangeProofService, RistrettoSecretKey, u64, Pedersen
     let prover = DalekRangeProofService::new(n, &base).unwrap();
     let k = RistrettoSecretKey::random(&mut rng);
     let n_max = 1u64 << (n as u64 - 1);
-    let v = rng.gen_range(1, n_max);
+    let v = rng.gen_range(1..n_max);
     let c = base.commit_value(&k, v);
     (prover, k, v, c)
 }
 
 pub fn generate_rangeproof(c: &mut Criterion) {
-    c.bench_function_over_inputs(
-        "Generate range proofs",
-        |b, range| {
-            let (prover, k, v, _) = setup(**range);
+    let mut group = c.benchmark_group("Generate and validate range proofs");
+    for input in &[8, 16, 32, 64] {
+        let parameter_str = format!("{} bytes", input);
+        // let proof = prover.construct_proof(&k, v).unwrap();
+        group.bench_with_input(BenchmarkId::new("construct_proof", &parameter_str), input, |b, n| {
+            let (prover, k, v, _) = setup(*n);
             b.iter(move || prover.construct_proof(&k, v).unwrap());
-        },
-        &[8, 16, 32, 64],
-    );
-}
-
-pub fn verify_rangeproof_valid(c: &mut Criterion) {
-    c.bench_function_over_inputs(
-        "Validate valid range proofs",
-        |b, range| {
-            let (prover, k, v, c) = setup(**range);
-            let proof = prover.construct_proof(&k, v).unwrap();
-            b.iter(move || assert!(prover.verify(&proof, &c)));
-        },
-        &[8, 16, 32, 64],
-    );
+        });
+        group.bench_with_input(BenchmarkId::new("validate_proof", &parameter_str), input, |b, n| {
+            let (verifier, k, v, c) = setup(*n);
+            let proof = verifier.construct_proof(&k, v).unwrap();
+            b.iter(move || assert!(verifier.verify(&proof, &c)));
+        });
+    }
+    group.finish();
 }
 
 criterion_group!(
 name = range_proofs;
 config = Criterion::default().warm_up_time(Duration::from_millis(1_500));
-targets = generate_rangeproof, verify_rangeproof_valid
+targets = generate_rangeproof
 );

rust-toolchain

@@ -1 +1 @@
-nightly-2020-09-11
+nightly-2021-06-01

rustfmt.toml

@@ -4,7 +4,7 @@ comment_width = 120
 format_strings = true
 hard_tabs = false
 imports_layout = "HorizontalVertical"
-merge_imports = true
+imports_granularity="Crate"
 match_block_trailing_comma = true
 max_width = 120
 newline_style = "Native"

src/ffi/keys.rs

@@ -66,8 +66,7 @@ pub unsafe extern "C" fn sign(
     msg: *const c_char,
     nonce: *mut KeyArray,
     signature: *mut KeyArray,
-) -> c_int
-{
+) -> c_int {
     if nonce.is_null() || signature.is_null() || priv_key.is_null() || msg.is_null() {
         return NULL_POINTER;
     }
@@ -98,8 +97,7 @@ pub unsafe extern "C" fn verify(
     pub_nonce: *mut KeyArray,
     signature: *mut KeyArray,
     err_code: *mut c_int,
-) -> bool
-{
+) -> bool {
     if pub_key.is_null() || msg.is_null() || pub_nonce.is_null() || signature.is_null() || err_code.is_null() {
         if !err_code.is_null() {
             *err_code = NULL_POINTER;
@@ -140,8 +138,7 @@ pub unsafe extern "C" fn commitment(
     value: *const KeyArray,
     spend_key: *const KeyArray,
     commitment: *mut KeyArray,
-) -> c_int
-{
+) -> c_int {
     if value.is_null() || spend_key.is_null() || spend_key.is_null() {
         return NULL_POINTER;
     }
@@ -168,8 +165,7 @@ pub unsafe extern "C" fn sign_comsig(
     public_nonce: *mut KeyArray,
     signature_u: *mut KeyArray,
     signature_v: *mut KeyArray,
-) -> c_int
-{
+) -> c_int {
     if secret_a.is_null() ||
         secret_x.is_null() ||
         msg.is_null() ||
@@ -214,8 +210,7 @@ pub unsafe extern "C" fn verify_comsig(
     signature_u: *const KeyArray,
     signature_v: *const KeyArray,
     err_code: *mut c_int,
-) -> bool
-{
+) -> bool {
     if commitment.is_null() || msg.is_null() || public_nonce.is_null() || signature_u.is_null() || signature_v.is_null()
     {
         *err_code = NULL_POINTER;

src/ristretto/dalek_range_proof.rs

@@ -110,8 +110,7 @@ impl RangeProofService for DalekRangeProofService {
         rewind_key: &RistrettoSecretKey,
         rewind_blinding_key: &RistrettoSecretKey,
         proof_message: &[u8; REWIND_USER_MESSAGE_LENGTH],
-    ) -> Result<Vec<u8>, RangeProofError>
-    {
+    ) -> Result<Vec<u8>, RangeProofError> {
         let mut pt = Transcript::new(b"tari");
         let mut full_proof_message = [0u8; REWIND_PROOF_MESSAGE_LENGTH];
         full_proof_message[0..REWIND_CHECK_MESSAGE.len()].clone_from_slice(REWIND_CHECK_MESSAGE);
@@ -141,8 +140,7 @@ impl RangeProofService for DalekRangeProofService {
         commitment: &PedersenCommitment,
         rewind_public_key: &RistrettoPublicKey,
         rewind_blinding_public_key: &RistrettoPublicKey,
-    ) -> Result<RewindResult, RangeProofError>
-    {
+    ) -> Result<RewindResult, RangeProofError> {
         let rp = DalekProof::from_bytes(&proof).map_err(|_| RangeProofError::InvalidProof)?;
 
         let mut pt = Transcript::new(b"tari");
@@ -176,8 +174,7 @@ impl RangeProofService for DalekRangeProofService {
         commitment: &PedersenCommitment,
         rewind_key: &RistrettoSecretKey,
         rewind_blinding_key: &RistrettoSecretKey,
-    ) -> Result<FullRewindResult<RistrettoSecretKey>, RangeProofError>
-    {
+    ) -> Result<FullRewindResult<RistrettoSecretKey>, RangeProofError> {
         let rp = DalekProof::from_bytes(&proof).map_err(|_| RangeProofError::InvalidProof)?;
 
         let mut pt = Transcript::new(b"tari");

src/ristretto/musig.rs

@@ -270,8 +270,7 @@ impl<D: Digest> RistrettoMuSig<D> {
         pub_key: &RistrettoPublicKey,
         secret: &RistrettoSecretKey,
         nonce: &RistrettoSecretKey,
-    ) -> Option<RistrettoSchnorr>
-    {
+    ) -> Option<RistrettoSchnorr> {
         let index = self.index_of(pub_key)?;
         let pub_nonce = self.get_public_nonce(index)?;
         let ai = self.get_musig_scalar(pub_key)?;
@@ -544,8 +543,7 @@ impl SignatureCollection {
         r_agg: &RistrettoPublicKey,
         p_agg: &RistrettoPublicKey,
         m: &MessageHashSlice,
-    ) -> RistrettoSecretKey
-    {
+    ) -> RistrettoSecretKey {
         let e = D::new()
             .chain(r_agg.as_bytes())
             .chain(p_agg.as_bytes())

src/ristretto/script_commitment.rs

@@ -135,8 +135,7 @@ impl ScriptCommitmentFactory {
         key: &RistrettoSecretKey,
         value: u64,
         script: &TariScript,
-    ) -> Result<ScriptCommitment, ScriptCommitmentError>
-    {
+    ) -> Result<ScriptCommitment, ScriptCommitmentError> {
         if D::output_size() < 32 {
             return Err(ScriptCommitmentError::InvalidDigestLength);
         }
@@ -166,8 +165,7 @@ impl ScriptCommitmentFactory {
         v: u64,
         script: &TariScript,
         commitment: &PedersenCommitment,
-    ) -> bool
-    {
+    ) -> bool {
         match self.commit_script::<D>(k, v, script) {
             Ok(sc) => commitment == &self.script_to_pedersen(&sc),
             _ => false,
@@ -179,8 +177,7 @@ impl ScriptCommitmentFactory {
         key: &RistrettoSecretKey,
         c: &PedersenCommitment,
         s: &TariScript,
-    ) -> Result<RistrettoSecretKey, ScriptCommitmentError>
-    {
+    ) -> Result<RistrettoSecretKey, ScriptCommitmentError> {
         let script_hash = s
             .as_hash::<D>()
             .map_err(|_| ScriptCommitmentError::InvalidDigestLength)?;

src/ristretto/utils.rs

@@ -41,8 +41,7 @@ pub struct SignatureSet {
 pub fn sign<D: Digest>(
     private_key: &RistrettoSecretKey,
     message: &[u8],
-) -> Result<SignatureSet, SchnorrSignatureError>
-{
+) -> Result<SignatureSet, SchnorrSignatureError> {
     let mut rng = rand::thread_rng();
     let (nonce, public_nonce) = RistrettoPublicKey::random_keypair(&mut rng);
     let message = D::new().chain(public_nonce.as_bytes()).chain(message).result().to_vec();

src/script/tari_script.rs

@@ -68,8 +68,7 @@ impl TariScript {
         &self,
         inputs: &ExecutionStack,
         context: &ScriptContext,
-    ) -> Result<StackItem, ScriptError>
-    {
+    ) -> Result<StackItem, ScriptError> {
         // Copy all inputs onto the stack
         let mut stack = inputs.clone();
 
@@ -186,8 +185,7 @@ impl TariScript {
         stack: &mut ExecutionStack,
         ctx: &ScriptContext,
         state: &mut ExecutionState,
-    ) -> Result<(), ScriptError>
-    {
+    ) -> Result<(), ScriptError> {
         use Opcode::*;
         use StackItem::*;
         match opcode {