Split Digest into Digest512/Digest256 using blake2b/blake2s.

src/coordinator.rs

@@ -126,11 +126,11 @@ impl ConnectionHandler {
 
         let mut peers = vec![];
         let mut pubkeys = vec![];
-        let mut commitments: Vec<Digest> = vec![];
+        let mut commitments: Vec<Digest512> = vec![];
         for peerid in new_peers.into_iter().take(PLAYERS) {
             info!("Initializing new player (peerid={})", peerid.to_hex());
             info!("Asking for commitment to PublicKey (peerid={})", peerid.to_hex());
-            let comm: Digest = self.read(&peerid);
+            let comm: Digest512 = self.read(&peerid);
             info!("PublicKey Commitment received (peerid={})", peerid.to_hex());
 
             info!("Writing commitment to transcript");

src/protocol/digest.rs

@@ -4,18 +4,77 @@ use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
 use bincode::SizeLimit::Infinite;
 use bincode::rustc_serialize::encode;
 use blake2_rfc::blake2b::blake2b;
+use blake2_rfc::blake2s::blake2s;
 
-/// 512-bit BLAKE2b hash digest
-pub struct Digest([u8; 64]);
+macro_rules! digest_impl {
+    ($name:ident, $bytes:expr, $hash:ident) => {
+        pub struct $name([u8; $bytes]);
 
-impl Digest {
+        impl $name {
+            pub fn from<E: Encodable>(obj: &E) -> Option<Self> {
+                let serialized = encode(obj, Infinite);
+                match serialized {
+                    Ok(ref serialized) => {
+                        let mut buf: [u8; $bytes] = [0; $bytes];
+                        buf.copy_from_slice(&$hash($bytes, &[], serialized).as_bytes());
+
+                        Some($name(buf))
+                    },
+                    Err(_) => None
+                }
+            }
+        }
+
+        impl PartialEq for $name {
+            fn eq(&self, other: &$name) -> bool {
+                (&self.0[..]).eq(&other.0[..])
+            }
+        }
+
+        impl Eq for $name { }
+
+        impl Copy for $name { }
+        impl Clone for $name {
+            fn clone(&self) -> $name {
+                *self
+            }
+        }
+
+        impl Encodable for $name {
+            fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+                for i in 0..$bytes {
+                    try!(s.emit_u8(self.0[i]));
+                }
+
+                Ok(())
+            }
+        }
+
+        impl Decodable for $name {
+            fn decode<S: Decoder>(s: &mut S) -> Result<$name, S::Error> {
+                let mut buf = [0; $bytes];
+
+                for i in 0..$bytes {
+                    buf[i] = try!(s.read_u8());
+                }
+
+                Ok($name(buf))
+            }
+        }
+    }
+}
+
+digest_impl!(Digest512, 64, blake2b);
+digest_impl!(Digest256, 32, blake2s);
+
+impl Digest512 {
     pub fn to_string(&self) -> String {
         use rustc_serialize::hex::{ToHex};
 
         self.0.to_hex()
     }
 
-    pub fn from_string(s: &str) -> Option<Digest> {
+    pub fn from_string(s: &str) -> Option<Digest512> {
         use rustc_serialize::hex::{FromHex};
 
         match s.from_hex() {
@@ -23,7 +82,7 @@ impl Digest {
                 if decoded.len() == 64 {
                     let mut decoded_bytes: [u8; 64] = [0; 64];
                     decoded_bytes.copy_from_slice(&decoded);
-                    Some(Digest(decoded_bytes))
+                    Some(Digest512(decoded_bytes))
                 } else {
                     None
                 }
@@ -34,57 +93,7 @@ impl Digest {
         }
     }
 
-    pub fn from<E: Encodable>(obj: &E) -> Option<Self> {
-        let serialized = encode(obj, Infinite);
-        match serialized {
-            Ok(ref serialized) => {
-                let mut buf: [u8; 64] = [0; 64];
-                buf.copy_from_slice(&blake2b(64, &[], serialized).as_bytes());
-
-                Some(Digest(buf))
-            },
-            Err(_) => None
-        }
-    }
-
     pub fn interpret(&self) -> Fr {
         Fr::interpret(&self.0)
     }
 }
-
-impl PartialEq for Digest {
-    fn eq(&self, other: &Digest) -> bool {
-        (&self.0[..]).eq(&other.0[..])
-    }
-}
-
-impl Eq for Digest { }
-
-impl Copy for Digest { }
-impl Clone for Digest {
-    fn clone(&self) -> Digest {
-        *self
-    }
-}
-
-impl Encodable for Digest {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        for i in 0..64 {
-            try!(s.emit_u8(self.0[i]));
-        }
-
-        Ok(())
-    }
-}
-
-impl Decodable for Digest {
-    fn decode<S: Decoder>(s: &mut S) -> Result<Digest, S::Error> {
-        let mut buf = [0; 64];
-
-        for i in 0..64 {
-            buf[i] = try!(s.read_u8());
-        }
-
-        Ok(Digest(buf))
-    }
-}

src/protocol/nizk.rs

@@ -1,6 +1,6 @@
 use bn::*;
 use rand::Rng;
-use super::digest::Digest;
+use super::digest::Digest512;
 
 #[derive(PartialEq, Eq, Clone, RustcEncodable, RustcDecodable)]
 pub struct Nizk<G: Group> {
@@ -14,7 +14,7 @@ impl<G: Group> Nizk<G> {
     pub fn new<R: Rng>(rng: &mut R, f: G, s: Fr) -> Nizk<G> {
         let a = Fr::random(rng);
         let r = f * a;
-        let c = Digest::from(&r).expect("group element should never fail to encode").interpret();
+        let c = Digest512::from(&r).expect("group element should never fail to encode").interpret();
         Nizk {
             r: r,
             u: a + c * s
@@ -23,7 +23,7 @@ impl<G: Group> Nizk<G> {
 
     /// Verify the Nizk
     pub fn verify(&self, f: G, fs: G) -> bool {
-        let c = Digest::from(&self.r).expect("group element should never fail to encode").interpret();
+        let c = Digest512::from(&self.r).expect("group element should never fail to encode").interpret();
         
         (f * self.u) == (self.r + fs * c)
     }

src/protocol/secrets.rs

@@ -2,7 +2,7 @@ use bn::*;
 use rand::Rng;
 use super::spair::{Spair, same_power};
 use super::nizk::Nizk;
-use super::digest::Digest;
+use super::digest::Digest512;
 #[cfg(feature = "snark")]
 use snark::*;
 use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
@@ -66,8 +66,8 @@ impl PublicKey {
         same_power(&self.f8_gamma, &Spair::new(self.f2_beta, self.f2_beta_gamma).unwrap())
     }
 
-    pub fn hash(&self) -> Digest {
-        Digest::from(self).expect("PublicKey should never fail to encode")
+    pub fn hash(&self) -> Digest512 {
+        Digest512::from(self).expect("PublicKey should never fail to encode")
     }
 
     pub fn tau_g2(&self) -> Spair<G2> {