Introduce better hashing.

- Blake2 for secure hashing
- XX for fast hashing

substrate/primitives/src/ed25519.rs

@@ -166,44 +166,53 @@ impl PartialEq for Signature {
 	}
 }
 
+pub mod hexdisplay {
+
+	pub struct HexDisplay<'a>(&'a [u8]);
+
+	impl<'a> HexDisplay<'a> {
+		pub fn from(d: &'a AsBytesRef) -> Self { HexDisplay(d.as_bytes_ref()) }
+	}
+
+	impl<'a> ::std::fmt::Display for HexDisplay<'a> {
+		fn fmt(&self, fmtr: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+			for byte in self.0 {
+				try!( fmtr.write_fmt(format_args!("{:02x}", byte)));
+			}
+			Ok(())
+		}
+	}
+
+	pub trait AsBytesRef {
+		fn as_bytes_ref(&self) -> &[u8];
+	}
+
+	impl AsBytesRef for [u8] {
+		fn as_bytes_ref(&self) -> &[u8] { &self }
+	}
+
+	impl AsBytesRef for Vec<u8> {
+		fn as_bytes_ref(&self) -> &[u8] { &self }
+	}
+
+	macro_rules! impl_non_endians {
+		( $( $t:ty ),* ) => { $(
+			impl AsBytesRef for $t {
+				fn as_bytes_ref(&self) -> &[u8] { &self[..] }
+			}
+		)* }
+	}
+
+	impl_non_endians!([u8; 1], [u8; 2], [u8; 3], [u8; 4], [u8; 5], [u8; 6], [u8; 7], [u8; 8],
+		[u8; 10], [u8; 12], [u8; 14], [u8; 16], [u8; 20], [u8; 24], [u8; 28], [u8; 32], [u8; 40],
+		[u8; 48], [u8; 56], [u8; 64], [u8; 80], [u8; 96], [u8; 112], [u8; 128]);
+
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;
-
-pub struct HexDisplay<'a>(&'a [u8]);
-
-impl<'a> HexDisplay<'a> {
-	pub fn from(d: &'a AsBytesRef) -> Self { HexDisplay(d.as_bytes_ref()) }
-}
-
-impl<'a> ::std::fmt::Display for HexDisplay<'a> {
-	fn fmt(&self, fmtr: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-		for byte in self.0 {
-			try!( fmtr.write_fmt(format_args!("{:02x}", byte)));
-		}
-		Ok(())
-	}
-}
-
-pub trait AsBytesRef {
-	fn as_bytes_ref(&self) -> &[u8];
-}
-
-impl AsBytesRef for [u8] {
-	fn as_bytes_ref(&self) -> &[u8] { &self }
-}
-
-macro_rules! impl_non_endians {
-	( $( $t:ty ),* ) => { $(
-		impl AsBytesRef for $t {
-			fn as_bytes_ref(&self) -> &[u8] { &self[..] }
-		}
-	)* }
-}
-
-impl_non_endians!([u8; 1], [u8; 2], [u8; 3], [u8; 4], [u8; 5], [u8; 6], [u8; 7], [u8; 8],
-	[u8; 10], [u8; 12], [u8; 14], [u8; 16], [u8; 20], [u8; 24], [u8; 28], [u8; 32], [u8; 40],
-	[u8; 48], [u8; 56], [u8; 64], [u8; 80], [u8; 96], [u8; 112], [u8; 128]);
+	use super::hexdisplay::HexDisplay;
 
 	#[test]
 	fn test_vector_should_work() {

substrate/primitives/src/hash.rs

@@ -41,8 +41,8 @@ impl_hash!(H160, 20);
 impl_serde!(H160, 20);
 impl_hash!(H256, 32);
 impl_serde!(H256, 32);
-impl_hash!(H520, 65);
-impl_serde!(H520, 65);
+impl_hash!(H512, 64);
+impl_serde!(H512, 64);
 
 #[cfg(test)]
 mod tests {

substrate/primitives/src/lib.rs

@@ -20,9 +20,11 @@
 
 extern crate rustc_hex;
 extern crate serde;
-extern crate tiny_keccak;
 extern crate ring;
 extern crate untrusted;
+extern crate twox_hash;
+extern crate byteorder;
+extern crate blake2_rfc;
 
 #[macro_use]
 extern crate crunchy;
@@ -53,12 +55,98 @@ pub mod ed25519;
 /// Alias to 160-bit hash when used in the context of an account address.
 pub type Address = hash::H160;
 /// Alias to 520-bit hash when used in the context of a signature.
-pub type Signature = hash::H520;
+pub type Signature = hash::H512;
 
 pub use self::hash::{H160, H256};
 pub use self::uint::{U256, U512};
 
 /// A hash function.
 pub fn hash(data: &[u8]) -> hash::H256 {
-	tiny_keccak::keccak256(data).into()
+	blake2_256(data).into()
+}
+
+/// Do a Blake2 512-bit hash and place result in `dest`.
+pub fn blake2_512_into(data: &[u8], dest: &mut[u8; 64]) {
+	dest.copy_from_slice(blake2_rfc::blake2b::blake2b(64, &[], data).as_bytes());
+}
+
+/// Do a Blake2 512-bit hash and return result.
+pub fn blake2_512(data: &[u8]) -> [u8; 64] {
+	let mut r: [u8; 64] = unsafe { std::mem::uninitialized() };
+	blake2_512_into(data, &mut r);
+	r
+}
+
+/// Do a Blake2 256-bit hash and place result in `dest`.
+pub fn blake2_256_into(data: &[u8], dest: &mut[u8; 32]) {
+	dest.copy_from_slice(blake2_rfc::blake2b::blake2b(32, &[], data).as_bytes());
+}
+
+/// Do a Blake2 256-bit hash and return result.
+pub fn blake2_256(data: &[u8]) -> [u8; 32] {
+	let mut r: [u8; 32] = unsafe { std::mem::uninitialized() };
+	blake2_256_into(data, &mut r);
+	r
+}
+
+/// Do a Blake2 128-bit hash and place result in `dest`.
+pub fn blake2_128_into(data: &[u8], dest: &mut[u8; 16]) {
+	dest.copy_from_slice(blake2_rfc::blake2b::blake2b(16, &[], data).as_bytes());
+}
+
+/// Do a Blake2 128-bit hash and return result.
+pub fn blake2_128(data: &[u8]) -> [u8; 16] {
+	let mut r: [u8; 16] = unsafe { std::mem::uninitialized() };
+	blake2_128_into(data, &mut r);
+	r
+}
+
+/// Do a XX 128-bit hash and place result in `dest`.
+pub fn twox_128_into(data: &[u8], dest: &mut [u8; 16]) {
+	use ::std::hash::Hasher;
+	let mut h0 = twox_hash::XxHash::with_seed(0);
+	let mut h1 = twox_hash::XxHash::with_seed(1);
+	h0.write(data);
+	h1.write(data);
+	let r0 = h0.finish();
+	let r1 = h1.finish();
+	use byteorder::{ByteOrder, LittleEndian};
+	LittleEndian::write_u64(&mut dest[0..8], r0);
+	LittleEndian::write_u64(&mut dest[8..16], r1);
+}
+
+/// Do a XX 128-bit hash and return result.
+pub fn twox_128(data: &[u8]) -> [u8; 16] {
+	let mut r: [u8; 16] = unsafe { std::mem::uninitialized() };
+	twox_128_into(data, &mut r);
+	r
+}
+
+/// Do a XX 256-bit hash and place result in `dest`.
+pub fn twox_256_into(data: &[u8], dest: &mut [u8; 32]) {
+	use ::std::hash::Hasher;
+	use byteorder::{ByteOrder, LittleEndian};
+	let mut h0 = twox_hash::XxHash::with_seed(0);
+	let mut h1 = twox_hash::XxHash::with_seed(1);
+	let mut h2 = twox_hash::XxHash::with_seed(2);
+	let mut h3 = twox_hash::XxHash::with_seed(3);
+	h0.write(data);
+	h1.write(data);
+	h2.write(data);
+	h3.write(data);
+	let r0 = h0.finish();
+	let r1 = h1.finish();
+	let r2 = h2.finish();
+	let r3 = h3.finish();
+	LittleEndian::write_u64(&mut dest[0..8], r0);
+	LittleEndian::write_u64(&mut dest[8..16], r1);
+	LittleEndian::write_u64(&mut dest[16..24], r2);
+	LittleEndian::write_u64(&mut dest[24..32], r3);
+}
+
+/// Do a XX 256-bit hash and return result.
+pub fn twox_256(data: &[u8]) -> [u8; 32] {
+	let mut r: [u8; 32] = unsafe { std::mem::uninitialized() };
+	twox_256_into(data, &mut r);
+	r
 }