From 830d92cd8f20481a047100a2c2684279e96a1200 Mon Sep 17 00:00:00 2001 From: Romain Ruetschi Date: Thu, 9 Jul 2020 23:27:49 +0200 Subject: [PATCH] Fix clippy warnings --- Cargo.toml | 32 ++++++++++++++--------------- src/tests.rs | 57 +++++++++++++++++++++++++--------------------------- 2 files changed, 43 insertions(+), 46 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index ffaac8f..2860fd0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,25 +1,25 @@ [package] -name = "lamport_sigs" -version = "0.7.1-pre" -authors = ["Frederic Jacobs "] -description = "Implementation of the Lamport one-time signature scheme." -license = "BSD-3-Clause" +name = "lamport_sigs" +version = "0.7.1-pre" +authors = ["Frederic Jacobs "] +description = "Implementation of the Lamport one-time signature scheme." +license = "BSD-3-Clause" documentation = "https://spinresearch.github.io/lamport_sigs.rs/lamport_sigs/index.html" -homepage = "https://github.com/SpinResearch/lamport_sigs.rs" -repository = "https://github.com/SpinResearch/lamport_sigs.rs" -keywords = ["lamport", "signature-scheme"] -categories = ["cryptography", "algorithms"] -readme = "README.md" +homepage = "https://github.com/SpinResearch/lamport_sigs.rs" +repository = "https://github.com/SpinResearch/lamport_sigs.rs" +keywords = ["lamport", "signature-scheme"] +categories = ["cryptography", "algorithms"] +readme = "README.md" [dependencies] ring = "^0.16.1" [package.metadata.release] -sign-commit = true -upload-doc = true -doc-branch = "gh-pages" +sign-commit = true +upload-doc = true +doc-branch = "gh-pages" pre-release-commit-message = "Release version {{version}}." pro-release-commit-message = "Start next development iteration {{version}}." -tag-message = "Release version {{version}}." -doc-commit-message = "Update documentation." -dev-version-ext = "pre" +tag-message = "Release version {{version}}." +doc-commit-message = "Update documentation." +dev-version-ext = "pre" diff --git a/src/tests.rs b/src/tests.rs index 3fbe53b..e1887d7 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -3,30 +3,27 @@ use ring::digest::{Algorithm, SHA256, SHA512}; use PrivateKey; use PublicKey; -#[allow(non_upper_case_globals)] -static digest_256: &'static Algorithm = &SHA256; - -#[allow(non_upper_case_globals)] -static digest_512: &'static Algorithm = &SHA512; +static DIGEST_256: &Algorithm = &SHA256; +static DIGEST_512: &Algorithm = &SHA512; #[cfg(test)] #[test] fn test_public_key_length_256() { - let pk = PrivateKey::new(digest_256); + let pk = PrivateKey::new(DIGEST_256); assert!(pk.public_key().one_values.len() == 256 && pk.public_key().zero_values.len() == 256); } #[test] fn test_public_key_length_512() { - let pk = PrivateKey::new(digest_512); + let pk = PrivateKey::new(DIGEST_512); assert!(pk.public_key().one_values.len() == 512 && pk.public_key().zero_values.len() == 512); } #[test] fn test_distinctive_successive_keygen() { - let mut past_buff = PrivateKey::new(digest_512); + let mut past_buff = PrivateKey::new(DIGEST_512); for _ in 0..100 { - let buffer = PrivateKey::new(digest_512); + let buffer = PrivateKey::new(DIGEST_512); assert!(past_buff != buffer); past_buff = buffer; } @@ -34,8 +31,8 @@ fn test_distinctive_successive_keygen() { #[test] fn test_sign_verif() { - let mut priv_key = PrivateKey::new(digest_512); - let data = "Hello World".as_bytes(); + let mut priv_key = PrivateKey::new(DIGEST_512); + let data = b"Hello World"; let signature = priv_key.sign(data).unwrap(); let pub_key = priv_key.public_key(); @@ -45,8 +42,8 @@ fn test_sign_verif() { #[test] fn test_sign_verif_sig_wrong_size() { - let mut priv_key = PrivateKey::new(digest_512); - let data = "Hello World".as_bytes(); + let mut priv_key = PrivateKey::new(DIGEST_512); + let data = b"Hello World"; let mut too_short = priv_key.sign(data).unwrap(); let extra = too_short.pop(); @@ -54,8 +51,8 @@ fn test_sign_verif_sig_wrong_size() { assert!(!pub_key.verify_signature(&too_short, data)); - let mut priv_key = PrivateKey::new(digest_512); - let data = "Hello World".as_bytes(); + let mut priv_key = PrivateKey::new(DIGEST_512); + let data = b"Hello World"; let mut too_long = priv_key.sign(data).unwrap(); too_long.extend(extra); @@ -64,20 +61,20 @@ fn test_sign_verif_sig_wrong_size() { #[test] fn test_sign_verif_fail() { - let mut priv_key = PrivateKey::new(digest_512); - let data = "Hello Word".as_bytes(); + let mut priv_key = PrivateKey::new(DIGEST_512); + let data = b"Hello Word"; let signature = priv_key.sign(data).unwrap(); let pub_key = priv_key.public_key(); - let data2 = "Hello".as_bytes(); + let data2 = b"Hello"; assert!(!pub_key.verify_signature(&signature, data2)); } #[test] fn test_serialization() { - let pub_key = PrivateKey::new(digest_512).public_key(); + let pub_key = PrivateKey::new(DIGEST_512).public_key(); let bytes = pub_key.to_bytes(); - let recovered_pub_key = PublicKey::from_vec(bytes, digest_512).unwrap(); + let recovered_pub_key = PublicKey::from_vec(bytes, DIGEST_512).unwrap(); assert_eq!(pub_key.one_values, recovered_pub_key.one_values); assert_eq!(pub_key.zero_values, recovered_pub_key.zero_values); @@ -85,24 +82,24 @@ fn test_serialization() { #[test] fn test_serialization_wrong_size_key() { - let pub_key = PrivateKey::new(digest_512).public_key(); + let pub_key = PrivateKey::new(DIGEST_512).public_key(); let mut too_short = pub_key.to_bytes(); let extra = too_short.pop(); - assert!(PublicKey::from_vec(too_short, digest_512).is_none()); + assert!(PublicKey::from_vec(too_short, DIGEST_512).is_none()); - let pub_key = PrivateKey::new(digest_512).public_key(); + let pub_key = PrivateKey::new(DIGEST_512).public_key(); let mut too_long = pub_key.to_bytes(); too_long.extend(extra); - assert!(PublicKey::from_vec(too_long, digest_512).is_none()); + assert!(PublicKey::from_vec(too_long, DIGEST_512).is_none()); } #[test] #[should_panic] fn test_serialization_panic() { - let pub_key = PrivateKey::new(digest_512).public_key(); + let pub_key = PrivateKey::new(DIGEST_512).public_key(); let mut bytes = pub_key.to_bytes(); bytes.pop(); - let recovered_pub_key = PublicKey::from_vec(bytes, digest_512).unwrap(); + let recovered_pub_key = PublicKey::from_vec(bytes, DIGEST_512).unwrap(); assert_eq!(pub_key.one_values, recovered_pub_key.one_values); assert_eq!(pub_key.zero_values, recovered_pub_key.zero_values); @@ -110,7 +107,7 @@ fn test_serialization_panic() { #[test] fn test_private_key_equality() { - let mut pub_key = PrivateKey::new(digest_512); + let mut pub_key = PrivateKey::new(DIGEST_512); let pub_key_2 = pub_key.clone(); assert!(pub_key == pub_key_2); @@ -119,15 +116,15 @@ fn test_private_key_equality() { assert!(pub_key != pub_key_2); - let mut pub_key = PrivateKey::new(digest_512); + let mut pub_key = PrivateKey::new(DIGEST_512); let pub_key_2 = pub_key.clone(); pub_key.one_values.pop(); assert!(pub_key != pub_key_2); - let mut pub_key = PrivateKey::new(digest_512); + let mut pub_key = PrivateKey::new(DIGEST_512); let pub_key_2 = pub_key.clone(); - pub_key.algorithm = digest_256; + pub_key.algorithm = DIGEST_256; assert!(pub_key != pub_key_2); }