Secp256k1 in parity crypto and alternative wasm32 implementation

Cargo.toml

@@ -17,5 +17,5 @@ members = [
 	"trace-time",
 	"trie-standardmap",
 	"triehash",
-	"uint"
+	"uint",
 ]

mem/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "mem"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+clear_on_drop = "0.2.3"
+
+[features]
+# when activated mem is removed through volatile primitive instead of clear_on_drop crate
+volatile-erase = []

mem/src/lib.rs

@@ -0,0 +1,74 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+extern crate clear_on_drop as cod;
+
+use std::ops::{Deref, DerefMut};
+
+#[cfg(feature = "volatile-erase")]
+use std::ptr;
+
+#[cfg(not(feature = "volatile-erase"))]
+pub use cod::clear::Clear;
+
+/// reexport clear_on_drop crate
+pub mod clear_on_drop {
+	pub use cod::*;
+}
+
+/// Wrapper to zero out memory when dropped.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Memzero<T: AsMut<[u8]>> {
+	mem: T,
+}
+
+impl<T: AsMut<[u8]>> From<T> for Memzero<T> {
+	fn from(mem: T) -> Memzero<T> {
+		Memzero { mem }
+	}
+}
+
+#[cfg(feature = "volatile-erase")]
+impl<T: AsMut<[u8]>> Drop for Memzero<T> {
+	fn drop(&mut self) {
+		unsafe {
+			for byte_ref in self.mem.as_mut() {
+				ptr::write_volatile(byte_ref, 0)
+			}
+		}
+	}
+}
+
+#[cfg(not(feature = "volatile-erase"))]
+impl<T: AsMut<[u8]>> Drop for Memzero<T> {
+	fn drop(&mut self) {
+		self.as_mut().clear();
+	}
+}
+
+impl<T: AsMut<[u8]>> Deref for Memzero<T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		&self.mem
+	}
+}
+
+impl<T: AsMut<[u8]>> DerefMut for Memzero<T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.mem
+	}
+}

parity-crypto/Cargo.toml

@@ -5,9 +5,53 @@ authors = ["Parity Technologies <admin@parity.io>"]
 repository = "https://github.com/paritytech/parity-common"
 description = "Crypto utils used by ethstore and network."
 license = "GPL-3.0"
+autobenches = false
+
+[[bench]]
+name = "bench"
+harness = false
+
 
 [dependencies]
 quick-error = "1.2.2"
-ring = "0.13"
-rust-crypto = "0.2.36"
+
 tiny-keccak = "1.4"
+scrypt = { version = "0.1.1", default-features = false }
+ripemd160 = "0.8.0"
+sha2 = "0.8.0"
+digest = "0.8"
+aes = "0.3.2"
+aes-ctr = "0.3.0"
+block-modes = "0.2.0"
+lazy_static = "1.0" # for secp
+mem = { path = "../mem" }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+ring = "0.13"
+eth-secp256k1 = { git = "https://github.com/paritytech/rust-secp256k1" }
+arrayvec = "0.4" # needed for eth-secp256k1
+rand = "0.4"
+hmac = { version = "0.7", optional = true }
+libsecp256k1 = { path = "./libsecp256k1", optional = true }
+pbkdf2 = { version = "0.3", default-features = false, optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+hmac = "0.7"
+subtle = { version = "1.0" }
+# libsecp256k1 = { version = "0.1", package = "libsecp256k1" } // requires 'rename-dependency' in stable
+libsecp256k1 = { path = "./libsecp256k1" }
+rand = "0.5"
+pbkdf2 = { version = "0.3", default-features = false }
+
+[dev-dependencies]
+hmac = "0.7"
+# libsecp256k1 = { version = "0.1", package = "libsecp256k1" } // requires 'rename-dependency' in stable
+libsecp256k1 = { path = "./libsecp256k1" }
+pbkdf2 = { version = "0.3", default-features = false }
+criterion = "0.2"
+
+[features]
+# expose alternative wasm32 implementation for testing and benchmarks
+alt = ["hmac", "libsecp256k1", "pbkdf2"]
+nightly = ["subtle/nightly"]
+volatile-erase = ["mem/volatile-erase"]

parity-crypto/benches/asym.rs

@@ -0,0 +1,60 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use criterion::{Criterion, Bencher};
+
+use parity_crypto::traits::asym::*;
+
+pub fn secp256k1(c: &mut Criterion) {
+	use parity_crypto::secp256k1::Secp256k1;
+	asym_bench::<Secp256k1>(c, "secp256k1".to_owned())
+}
+
+#[cfg(feature="alt")]
+pub fn secp256k1_alt(c: &mut Criterion) {
+	use parity_crypto::secp256k1_alt::Secp256k1;
+	asym_bench::<Secp256k1>(c, "secp256k1_alt".to_owned())
+}
+
+
+
+fn asym_bench<A: Asym>(c: &mut Criterion, name: String) {
+
+	c.bench_function(&(name.clone() + "_sign_verify"),
+		|b: &mut Bencher| {
+			let mut sec_buf = vec![7; A::SECRET_SIZE];
+			let message = vec![0;32];
+			b.iter(|| {
+				let (secret, public) = A::keypair_from_slice(&mut sec_buf).unwrap();
+				let signature = secret.sign(&message).unwrap();
+				assert!(public.verify(&signature, &message).unwrap());
+			});
+		}
+	);
+
+	c.bench_function(&(name.clone() + "_sign_recover"),
+		|b: &mut Bencher| {
+			let mut sec_buf = vec![3; A::SECRET_SIZE];
+			let message = vec![0;32];
+			b.iter(|| {
+				let (secret, public) = A::keypair_from_slice(&mut sec_buf).unwrap();
+				let signature = secret.sign(&message).unwrap();
+				assert!(public == A::recover(&signature, &message).unwrap());
+			});
+		}
+	);
+
+}

parity-crypto/benches/bench.rs

@@ -0,0 +1,62 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+
+extern crate parity_crypto;
+
+#[macro_use]
+extern crate criterion;
+
+mod asym;
+
+use criterion::{Criterion, Bencher};
+
+#[cfg(not(feature="alt"))]
+criterion_group!(benches, input_len, asym::secp256k1);
+
+#[cfg(feature="alt")]
+criterion_group!(benches, input_len, asym::secp256k1, asym::secp256k1_alt);
+
+criterion_main!(benches);
+
+/// general benches for multiple input size
+fn input_len(c: &mut Criterion) {
+
+	c.bench_function_over_inputs("ripemd",
+		|b: &mut Bencher, size: &usize| {
+			let data = vec![0u8; *size];
+			b.iter(|| parity_crypto::digest::ripemd160(&data[..]));
+		},
+		vec![100, 500, 1_000, 10_000, 100_000]
+	);
+
+	c.bench_function_over_inputs("aes_ctr",
+		|b: &mut Bencher, size: &usize| {
+			let data = vec![0u8; *size];
+			let mut dest = vec![0; *size];
+			let k = [0; 16];
+			let iv = [0; 16];
+
+			b.iter(||{
+				parity_crypto::aes::encrypt_128_ctr(&k[..], &iv[..], &data[..], &mut dest[..]).unwrap();
+				// same as encrypt but add it just in case
+				parity_crypto::aes::decrypt_128_ctr(&k[..], &iv[..], &data[..], &mut dest[..]).unwrap();
+			});
+		},
+		vec![100, 500, 1_000, 10_000, 100_000]
+	);
+
+}

parity-crypto/libsecp256k1/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "libsecp256k1"
+version = "0.0.1"
+authors = ["Parity Technologies <admin@parity.io>"]
+repository = "https://github.com/paritytech/parity-common"
+description = "Renaming crate for libsecp256k1."
+license = "GPL-3.0"
+
+[dependencies]
+libsecp256k1 = { version = "0.1" }

parity-crypto/libsecp256k1/src/lib.rs

@@ -0,0 +1,23 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Renaming crate for libsecp256k1, this crate should be drop as soon as
+//! 'renaming-crates' functionality makes it to stable.
+
+
+extern crate secp256k1;
+
+pub use secp256k1::*;