From 12cefb1d18ed0ccd8059e4b993ea66a959a40c10 Mon Sep 17 00:00:00 2001 From: Noah Vesely Date: Mon, 2 Apr 2018 15:02:10 -0500 Subject: [PATCH] Rustfmt updates + refactor Travis configuration (#60) * Update rustfmt compliance Looks like rustfmt has made some improvements recently, so wanted to bring the code up to date. * Add rustfmt to nightly item in Travis matrix * Use Travis Cargo cache * Allow fast_finish in Travis Items that match the `allow_failures` predicate (right now, just Rust nightly), will still finish, but Travis won't wait for them to report a result if the other builds have already finished. * Run kcov in a separate matrix build in Travis * Rework allowed_failures logic We don't want rustfmt to match `allow_failures` just because it needs to use nightly, while we do want nightly to match `allow_failures`. Env vars provide a solution. * Add --all switch to rustfmt Travis * Test building docs in Travis * Use exact Ubuntu dependencies listed for kcov Some of the dependencies we were installing were not listed on https://github.com/SimonKagstrom/kcov/blob/master/INSTALL.md, and we were missing one dependency that was listed there. When `sudo: true` Travis uses Ubuntu Trusty. * No need to build before running kcov kcov builds its own test executables. * Generate `Cargo.lock` w/ `cargo update` before running kcov As noted in aeb3906cce8e3e26c7bc80d6aec417b365f3d2f1 it is not necessary to build the project before running kcov, but kcov does require a `Cargo.lock` file, which can be generated with `cargo update`. --- .travis.yml | 56 +++++++++++++++++++++-------------- benches/ss1.rs | 22 +++++++++----- benches/sss.rs | 10 +++---- benches/thss.rs | 10 +++---- benches/wrapped_secrets.rs | 16 +++++----- build.rs | 4 +-- src/dss/format.rs | 2 +- src/dss/metadata.rs | 2 +- src/dss/mod.rs | 2 +- src/dss/ss1/mod.rs | 2 +- src/dss/ss1/scheme.rs | 16 +++++----- src/dss/ss1/serialize.rs | 4 +-- src/dss/ss1/share.rs | 2 +- src/dss/thss/scheme.rs | 6 ++-- src/dss/thss/serialize.rs | 4 +-- src/dss/thss/share.rs | 2 +- src/dss/utils.rs | 2 +- src/gf256.rs | 13 ++++---- src/lagrange.rs | 2 +- src/lib.rs | 6 ++-- src/sss/format.rs | 4 +-- src/sss/scheme.rs | 8 ++--- src/sss/share.rs | 4 +-- src/wrapped_secrets/scheme.rs | 4 +-- 24 files changed, 114 insertions(+), 89 deletions(-) diff --git a/.travis.yml b/.travis.yml index 13be6b3..cd35f73 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,38 +1,50 @@ - -sudo: required - language: rust +cache: cargo # https://docs.travis-ci.com/user/caching/#Rust-Cargo-cache rust: - stable - beta - - nightly matrix: + # Since this item is allowed to fail, don't wait for it's result to mark the + # build complete. + fast_finish: true allow_failures: - - rust: nightly + - env: NAME='nightly' + - env: NAME='kcov' + include: + - env: NAME='nightly' + rust: nightly + - env: NAME='rustfmt' + rust: nightly + before_script: + - rustup component add rustfmt-preview + script: + - cargo fmt --all -- --write-mode=diff + - env: NAME='kcov' + sudo: required # travis-ci/travis-ci#9061 + before_script: + - cargo install cargo-update || echo "cargo-update already installed" + - cargo install cargo-kcov || echo "cargo-kcov already installed" + - cargo install-update -a + script: + - cargo kcov --print-install-kcov-sh | sh + - cargo update # Creates `Cargo.lock` needed by next command + - cargo kcov --verbose --features dss --coveralls -- --verify --exclude-pattern=/.cargo,/usr/lib,src/proto + addons: + apt: + packages: + - libcurl4-openssl-dev + - libdw-dev + - binutils-dev + - libiberty-dev + - zlib1g-dev env: global: - RUSTFLAGS="-C link-dead-code" -addons: - apt: - packages: - - libcurl4-openssl-dev - - libdw-dev - - cmake - - g++ - - pkg-config - - binutils-dev - - libiberty-dev - script: - cargo build --verbose --all-features - cargo test --verbose --all-features - -after_success: - - cargo install cargo-kcov - - cargo kcov --print-install-kcov-sh | sh - - cargo kcov --verbose --features dss --coveralls -- --verify --exclude-pattern=/.cargo,/usr/lib,src/proto - + - cargo doc --verbose --all-features diff --git a/benches/ss1.rs b/benches/ss1.rs index d32b72b..f6e993a 100644 --- a/benches/ss1.rs +++ b/benches/ss1.rs @@ -10,29 +10,37 @@ mod shared; mod ss1 { use rusty_secrets::dss::ss1; - use test::{black_box, Bencher}; use shared; + use test::{black_box, Bencher}; macro_rules! bench_generate { - ($name:ident, $k:expr, $n:expr, $secret:ident) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); b.iter(move || { - let shares = ss1::split_secret($k, $n, &secret, ss1::Reproducibility::reproducible(), &None).unwrap(); + let shares = ss1::split_secret( + $k, + $n, + &secret, + ss1::Reproducibility::reproducible(), + &None, + ).unwrap(); black_box(shares); }); } - ) + }; } macro_rules! bench_recover { - ($name:ident, $k:expr, $n:expr, $secret:ident) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); - let all_shares = ss1::split_secret($k, $n, &secret, ss1::Reproducibility::reproducible(), &None).unwrap(); + let all_shares = + ss1::split_secret($k, $n, &secret, ss1::Reproducibility::reproducible(), &None) + .unwrap(); let shares = &all_shares.into_iter().take($k).collect::>().clone(); b.iter(|| { @@ -40,7 +48,7 @@ mod ss1 { black_box(result); }); } - ) + }; } bench_generate!(generate_1kb_3_5, 3, 5, secret_1kb); diff --git a/benches/sss.rs b/benches/sss.rs index b48b6aa..65ead56 100644 --- a/benches/sss.rs +++ b/benches/sss.rs @@ -8,12 +8,12 @@ mod shared; mod sss { - use test::{black_box, Bencher}; use rusty_secrets::sss; use shared; + use test::{black_box, Bencher}; macro_rules! bench_generate { - ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); @@ -23,11 +23,11 @@ mod sss { black_box(shares); }); } - ) + }; } macro_rules! bench_recover { - ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); @@ -39,7 +39,7 @@ mod sss { black_box(result); }); } - ) + }; } bench_generate!(generate_1kb_3_5, 3, 5, secret_1kb, false); diff --git a/benches/thss.rs b/benches/thss.rs index b11386b..c4dd97d 100644 --- a/benches/thss.rs +++ b/benches/thss.rs @@ -10,11 +10,11 @@ mod shared; mod thss { use rusty_secrets::dss::thss; - use test::{black_box, Bencher}; use shared; + use test::{black_box, Bencher}; macro_rules! bench_generate { - ($name:ident, $k:expr, $n:expr, $secret:ident) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); @@ -24,11 +24,11 @@ mod thss { black_box(shares); }); } - ) + }; } macro_rules! bench_recover { - ($name:ident, $k:expr, $n:expr, $secret:ident) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); @@ -40,7 +40,7 @@ mod thss { black_box(result); }); } - ) + }; } bench_generate!(generate_1kb_3_5, 3, 5, secret_1kb); diff --git a/benches/wrapped_secrets.rs b/benches/wrapped_secrets.rs index 627f376..af57141 100644 --- a/benches/wrapped_secrets.rs +++ b/benches/wrapped_secrets.rs @@ -8,30 +8,32 @@ mod shared; mod wrapped_secrets { - use test::{black_box, Bencher}; use rusty_secrets::wrapped_secrets; use shared; + use test::{black_box, Bencher}; macro_rules! bench_generate { - ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); b.iter(move || { - let shares = wrapped_secrets::split_secret($k, $n, secret, None, $signed).unwrap(); + let shares = + wrapped_secrets::split_secret($k, $n, secret, None, $signed).unwrap(); black_box(shares); }); } - ) + }; } macro_rules! bench_recover { - ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => ( + ($name:ident, $k:expr, $n:expr, $secret:ident, $signed:expr) => { #[bench] fn $name(b: &mut Bencher) { let secret = shared::$secret(); - let all_shares = wrapped_secrets::split_secret($k, $n, &secret, None, $signed).unwrap(); + let all_shares = + wrapped_secrets::split_secret($k, $n, &secret, None, $signed).unwrap(); let shares = all_shares.into_iter().take($k).collect::>(); b.iter(|| { @@ -39,7 +41,7 @@ mod wrapped_secrets { black_box(result); }); } - ) + }; } bench_generate!(generate_1kb_3_5, 3, 5, secret_1kb, false); diff --git a/build.rs b/build.rs index b47873e..a4d5019 100644 --- a/build.rs +++ b/build.rs @@ -1,9 +1,9 @@ use std::env; +use std::fmt; use std::fs::File; use std::io::Write; -use std::path::Path; -use std::fmt; use std::num::Wrapping; +use std::path::Path; const POLY: u8 = 0x1D; diff --git a/src/dss/format.rs b/src/dss/format.rs index 70669b5..c4d0386 100644 --- a/src/dss/format.rs +++ b/src/dss/format.rs @@ -1,7 +1,7 @@ use std::error::Error; -use protobuf::{self, Message}; use base64; +use protobuf::{self, Message}; use errors::*; use proto::dss::ShareProto; diff --git a/src/dss/metadata.rs b/src/dss/metadata.rs index 86c3f92..fa11f24 100644 --- a/src/dss/metadata.rs +++ b/src/dss/metadata.rs @@ -1,5 +1,5 @@ -use std::collections::BTreeMap; use ring::digest; +use std::collections::BTreeMap; /// A share's public metadata. #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Default)] diff --git a/src/dss/mod.rs b/src/dss/mod.rs index ab45caa..f7739d2 100644 --- a/src/dss/mod.rs +++ b/src/dss/mod.rs @@ -27,8 +27,8 @@ //! **ErrDet** | An inauthentic set of shares produced by an adversary will be flagged as such when fed to the recovery algorithm. //! **Repro** | Share reproducible: The scheme can produce shares in a deterministic way. -pub mod thss; pub mod ss1; +pub mod thss; mod metadata; diff --git a/src/dss/ss1/mod.rs b/src/dss/ss1/mod.rs index 78335d2..18a4b06 100644 --- a/src/dss/ss1/mod.rs +++ b/src/dss/ss1/mod.rs @@ -29,8 +29,8 @@ mod share; pub use self::share::*; mod scheme; -use self::scheme::SS1; pub use self::scheme::Reproducibility; +use self::scheme::SS1; use dss::AccessStructure; diff --git a/src/dss/ss1/scheme.rs b/src/dss/ss1/scheme.rs index 9672e5e..49c9e4e 100644 --- a/src/dss/ss1/scheme.rs +++ b/src/dss/ss1/scheme.rs @@ -1,17 +1,17 @@ use std::collections::HashSet; -use ring::{hkdf, hmac}; -use ring::rand::{SecureRandom, SystemRandom}; -use ring::digest::{Context, SHA256}; use rand::{ChaChaRng, Rng, SeedableRng}; +use ring::digest::{Context, SHA256}; +use ring::rand::{SecureRandom, SystemRandom}; +use ring::{hkdf, hmac}; -use errors::*; -use dss::{thss, AccessStructure}; -use dss::thss::{MetaData, ThSS}; -use dss::random::{random_bytes_count, FixedRandom, MAX_MESSAGE_SIZE}; -use share::validation::{validate_share_count, validate_shares}; use super::share::*; +use dss::random::{random_bytes_count, FixedRandom, MAX_MESSAGE_SIZE}; +use dss::thss::{MetaData, ThSS}; use dss::utils; +use dss::{thss, AccessStructure}; +use errors::*; +use share::validation::{validate_share_count, validate_shares}; use vol_hash::VOLHash; /// We bound the message size at about 16MB to avoid overflow in `random_bytes_count`. diff --git a/src/dss/ss1/serialize.rs b/src/dss/ss1/serialize.rs index ca040df..15b48d9 100644 --- a/src/dss/ss1/serialize.rs +++ b/src/dss/ss1/serialize.rs @@ -1,8 +1,8 @@ -use errors::*; use super::{MetaData, Share}; use dss::format::{format_share_protobuf, parse_share_protobuf}; -use proto::dss::{MetaDataProto, ShareProto}; use dss::utils::{btreemap_to_hashmap, hashmap_to_btreemap}; +use errors::*; +use proto::dss::{MetaDataProto, ShareProto}; pub(crate) fn share_to_string(share: Share) -> String { let proto = share_to_protobuf(share); diff --git a/src/dss/ss1/share.rs b/src/dss/ss1/share.rs index 4ca4178..d1f6fcc 100644 --- a/src/dss/ss1/share.rs +++ b/src/dss/ss1/share.rs @@ -1,6 +1,6 @@ +use super::serialize::{share_from_string, share_to_string}; use errors::*; use share::IsShare; -use super::serialize::{share_from_string, share_to_string}; pub use dss::metadata::MetaData; diff --git a/src/dss/thss/scheme.rs b/src/dss/thss/scheme.rs index 141c932..e7d0d1e 100644 --- a/src/dss/thss/scheme.rs +++ b/src/dss/thss/scheme.rs @@ -4,15 +4,15 @@ use std::fmt; use ring::rand::{SecureRandom, SystemRandom}; +use dss::random::{random_bytes, random_bytes_count, MAX_MESSAGE_SIZE}; use errors::*; use gf256::Gf256; -use dss::random::{random_bytes, random_bytes_count, MAX_MESSAGE_SIZE}; -use share::validation::{validate_share_count, validate_shares}; use lagrange; +use share::validation::{validate_share_count, validate_shares}; use super::AccessStructure; -use super::share::*; use super::encode::encode_secret; +use super::share::*; /// We bound the message size at about 16MB to avoid overflow in `random_bytes_count`. /// Moreover, given the current performances, it is almost unpractical to run diff --git a/src/dss/thss/serialize.rs b/src/dss/thss/serialize.rs index 7190934..1111f55 100644 --- a/src/dss/thss/serialize.rs +++ b/src/dss/thss/serialize.rs @@ -1,8 +1,8 @@ -use errors::*; use super::{MetaData, Share}; use dss::format::{format_share_protobuf, parse_share_protobuf}; -use proto::dss::{MetaDataProto, ShareProto}; use dss::utils::{btreemap_to_hashmap, hashmap_to_btreemap}; +use errors::*; +use proto::dss::{MetaDataProto, ShareProto}; pub(crate) fn share_to_string(share: Share) -> String { let proto = share_to_protobuf(share); diff --git a/src/dss/thss/share.rs b/src/dss/thss/share.rs index 15a942b..f68bf15 100644 --- a/src/dss/thss/share.rs +++ b/src/dss/thss/share.rs @@ -1,6 +1,6 @@ +use super::serialize::{share_from_string, share_to_string}; use errors::*; use share::IsShare; -use super::serialize::{share_from_string, share_to_string}; pub use dss::metadata::MetaData; diff --git a/src/dss/utils.rs b/src/dss/utils.rs index 59a2362..20a0fed 100644 --- a/src/dss/utils.rs +++ b/src/dss/utils.rs @@ -1,7 +1,7 @@ use std; -use std::hash::Hash; use std::collections::{BTreeMap, HashMap}; +use std::hash::Hash; /// Transmutes a `&[u8]` into a `&[u32]`. /// Despite `std::mem::transmute` being very unsafe in diff --git a/src/gf256.rs b/src/gf256.rs index 23546d9..49ad57e 100644 --- a/src/gf256.rs +++ b/src/gf256.rs @@ -143,7 +143,9 @@ impl Neg for Gf256 { #[macro_export] #[doc(hidden)] macro_rules! gf256 { - ($e:expr) => (Gf256::from_byte($e)) + ($e:expr) => { + Gf256::from_byte($e) + }; } #[macro_export] @@ -178,10 +180,10 @@ mod tests { mod vectors { use super::*; + use flate2::read::GzDecoder; + use itertools::Itertools; use std::fs::File; use std::io::{BufRead, BufReader}; - use itertools::Itertools; - use flate2::read::GzDecoder; macro_rules! mk_test { ($id:ident, $op:expr, $val:expr) => { @@ -196,7 +198,8 @@ mod tests { }); let ref_path = format!("tests/fixtures/gf256/gf256_{}.txt.gz", stringify!($id)); - let reference = BufReader::new(GzDecoder::new(File::open(ref_path).unwrap()).unwrap()); + let reference = + BufReader::new(GzDecoder::new(File::open(ref_path).unwrap()).unwrap()); for ((i, j, k), line) in results.zip(reference.lines()) { let left = format!("{} {} {} = {}", i, $op, j, k); @@ -204,7 +207,7 @@ mod tests { assert_eq!(left, right); } } - } + }; } mk_test!(add, "+", |i: Gf256, j: Gf256| i + j); diff --git a/src/lagrange.rs b/src/lagrange.rs index 4118818..b49a91f 100644 --- a/src/lagrange.rs +++ b/src/lagrange.rs @@ -86,10 +86,10 @@ pub(crate) fn interpolate(points: &[(Gf256, Gf256)]) -> Poly { #[allow(trivial_casts)] mod tests { - use std; use super::*; use gf256::*; use quickcheck::*; + use std; quickcheck! { diff --git a/src/lib.rs b/src/lib.rs index 4b88428..90d5c3c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -18,15 +18,15 @@ extern crate ring; #[macro_use] mod gf256; -mod share; -mod poly; mod lagrange; +mod poly; +mod share; mod vol_hash; pub mod errors; +pub mod proto; pub mod sss; pub mod wrapped_secrets; -pub mod proto; #[cfg(feature = "dss")] pub mod dss; diff --git a/src/sss/format.rs b/src/sss/format.rs index 142ae8b..e6cb2a7 100644 --- a/src/sss/format.rs +++ b/src/sss/format.rs @@ -1,9 +1,9 @@ +use base64; use errors::*; use merkle_sigs::{MerklePublicKey, Proof, PublicKey}; +use proto::wrapped::ShareProto; use protobuf::{self, Message, RepeatedField}; -use base64; use sss::{Share, HASH_ALGO}; -use proto::wrapped::ShareProto; use std::error::Error; const BASE64_CONFIG: base64::Config = base64::STANDARD_NO_PAD; diff --git a/src/sss/scheme.rs b/src/sss/scheme.rs index 4072c91..836bec6 100644 --- a/src/sss/scheme.rs +++ b/src/sss/scheme.rs @@ -1,13 +1,13 @@ //! SSS provides Shamir's secret sharing with raw data. -use rand::{OsRng, Rng}; use merkle_sigs::sign_data_vec; +use rand::{OsRng, Rng}; use errors::*; -use sss::{Share, HASH_ALGO}; -use sss::format::format_share_for_signing; -use share::validation::{validate_share_count, validate_signed_shares}; use lagrange::interpolate_at; +use share::validation::{validate_share_count, validate_signed_shares}; +use sss::format::format_share_for_signing; +use sss::{Share, HASH_ALGO}; use super::encode::encode_secret_byte; diff --git a/src/sss/share.rs b/src/sss/share.rs index f46ad67..e3ff1ca 100644 --- a/src/sss/share.rs +++ b/src/sss/share.rs @@ -1,8 +1,8 @@ -use std::error::Error; use std::collections::{HashMap, HashSet}; +use std::error::Error; -use merkle_sigs::{MerklePublicKey, Proof}; use merkle_sigs::verify_data_vec_signature; +use merkle_sigs::{MerklePublicKey, Proof}; use errors::*; use share::{IsShare, IsSignedShare}; diff --git a/src/wrapped_secrets/scheme.rs b/src/wrapped_secrets/scheme.rs index 40c50f8..f3a5896 100644 --- a/src/wrapped_secrets/scheme.rs +++ b/src/wrapped_secrets/scheme.rs @@ -1,8 +1,8 @@ use errors::*; +use proto::VersionProto; +use proto::wrapped::SecretProto; use protobuf; use protobuf::Message; -use proto::wrapped::SecretProto; -use proto::VersionProto; use sss::SSS; pub(crate) use sss::Share;