Add basic SHA1 support

Author: ctz

graviola/src/high/hash.rs

@@ -4,13 +4,16 @@
 use core::ops::{Deref, DerefMut};
 
 use crate::low::ct_equal;
+use crate::mid::sha1;
 use crate::mid::sha2;
 
 /// Output from a hash function.
 ///
 /// This has one variant per supported hash function.
 #[derive(Clone, Debug)]
 pub enum HashOutput {
+    /// Output from SHA1
+    Sha1([u8; sha1::Sha1Context::OUTPUT_SZ]),
     /// Output from SHA256
     Sha256([u8; sha2::Sha256Context::OUTPUT_SZ]),
     /// Output from SHA384
@@ -43,6 +46,7 @@ impl HashOutput {
 impl PartialEq for HashOutput {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
+            (Self::Sha1(s), Self::Sha1(o)) => ct_equal(s, o),
             (Self::Sha256(s), Self::Sha256(o)) => ct_equal(s, o),
             (Self::Sha384(s), Self::Sha384(o)) => ct_equal(s, o),
             (Self::Sha512(s), Self::Sha512(o)) => ct_equal(s, o),
@@ -54,6 +58,7 @@ impl PartialEq for HashOutput {
 impl AsRef<[u8]> for HashOutput {
     fn as_ref(&self) -> &[u8] {
         match self {
+            Self::Sha1(v) => v,
             Self::Sha256(v) => v,
             Self::Sha384(v) => v,
             Self::Sha512(v) => v,
@@ -64,6 +69,7 @@ impl AsRef<[u8]> for HashOutput {
 impl AsMut<[u8]> for HashOutput {
     fn as_mut(&mut self) -> &mut [u8] {
         match self {
+            Self::Sha1(v) => v,
             Self::Sha256(v) => v,
             Self::Sha384(v) => v,
             Self::Sha512(v) => v,
@@ -259,12 +265,87 @@ impl HashContext for Sha512Context {
     }
 }
 
+/// This is SHA1.
+///
+/// Do not use SHA1 for new applications or for applications involving signatures.
+///
+/// This is described in [FIPS180-1](https://nvlpubs.nist.gov/nistpubs/Legacy/FIPS/fipspub180-1.pdf).
+#[derive(Clone)]
+pub struct Sha1;
+
+impl Hash for Sha1 {
+    type Context = Sha1Context;
+
+    fn new() -> Self::Context {
+        Sha1Context(sha1::Sha1Context::new())
+    }
+
+    fn hash(bytes: &[u8]) -> HashOutput {
+        let mut ctx = Self::new();
+        ctx.update(bytes);
+        ctx.finish()
+    }
+
+    fn zeroed_block() -> HashBlock {
+        HashBlock::new(sha1::Sha1Context::BLOCK_SZ)
+    }
+
+    fn zeroed_output() -> HashOutput {
+        HashOutput::Sha1([0u8; sha1::Sha1Context::OUTPUT_SZ])
+    }
+}
+
+#[derive(Clone)]
+pub struct Sha1Context(sha1::Sha1Context);
+
+impl HashContext for Sha1Context {
+    fn update(&mut self, bytes: &[u8]) {
+        self.0.update(bytes)
+    }
+
+    fn finish(self) -> HashOutput {
+        HashOutput::Sha1(self.0.finish())
+    }
+}
+
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
     use super::*;
     use crate::test::*;
 
+    #[test]
+    fn equality() {
+        let s1a = Sha1::hash(b"a");
+        let s1b = Sha1::hash(b"b");
+        let s256a = Sha256::hash(b"a");
+        let s256b = Sha256::hash(b"b");
+        let s384a = Sha384::hash(b"a");
+        let s384b = Sha384::hash(b"b");
+        let s512a = Sha512::hash(b"a");
+        let s512b = Sha512::hash(b"b");
+
+        assert_eq!(s1a, Sha1::hash(b"a"));
+        for other in [&s1b, &s256a, &s384a, &s512a] {
+            assert_ne!(&s1a, other);
+        }
+
+        assert_eq!(s256a, Sha256::hash(b"a"));
+        for other in [&s1a, &s256b, &s384a, &s512a] {
+            assert_ne!(&s256a, other);
+        }
+
+        assert_eq!(s384a, Sha384::hash(b"a"));
+        for other in [&s1a, &s256a, &s384b, &s512a] {
+            assert_ne!(&s384a, other);
+        }
+
+        assert_eq!(s512a, Sha512::hash(b"a"));
+        for other in [&s1a, &s256a, &s384a, &s512b] {
+            assert_ne!(&s512a, other);
+        }
+    }
+
     #[test]
     fn cavp() {
         #[derive(Debug)]

graviola/src/high/hmac_drbg.rs

@@ -121,7 +121,7 @@ impl<H: Hash> RandomSource for HmacDrbg<H> {
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
     use super::*;
-    use crate::high::hash::Sha256;
+    use crate::high::hash::{Sha1, Sha256, Sha384, Sha512};
 
     #[test]
     fn rfc6979_example() {
@@ -139,4 +139,49 @@ mod tests {
         ctx.fill(&mut t2).unwrap();
         assert_eq!(&t2, b"\xC7\x0C\x78\x60\x8A\x3B\x5B\xE9\x28\x9B\xE9\x0E\xF6\xE8\x1A\x9E\x2C\x15\x16\xD5\x75\x1D\x2F\x75\xF5\x00\x33\xE4\x5F\x73\xBD\xEB");
     }
+
+    #[test]
+    fn vectors() {
+        // Generated independently with python.
+        fn check<H: Hash>(first: &[u8; 70], second: &[u8; 30]) {
+            let entropy: [u8; 32] = core::array::from_fn(|i| i as u8);
+            let nonce: [u8; 16] = core::array::from_fn(|i| 0x40 + i as u8);
+            let perso = b"graviola hmac-drbg";
+
+            let mut ctx = HmacDrbg::<H>::new(&entropy, &nonce, perso);
+
+            let mut o1 = [0u8; 70];
+            ctx.fill(&mut o1).unwrap();
+            assert_eq!(&o1, first);
+
+            let mut o2 = [0u8; 30];
+            ctx.fill(&mut o2).unwrap();
+            assert_eq!(&o2, second);
+        }
+
+        check::<Sha1>(
+            b"\x8d\x1b\xb7\x15\xf8\xdb\x72\x42\x65\x10\xd5\x2e\xac\x76\x59\x53\x5c\xf6\xb9\x1c\x3a\x6b\xf3\x4d\x73\x38\xc9\xf9\x7f\xe2\
+              \xdb\x77\xcc\x4b\xa9\xb6\x8a\xec\x28\x85\xf0\xa9\x5c\x65\x96\x63\x73\x0a\xd0\x2e\x88\x7c\x55\xc0\x25\xb5\xd3\xe8\xbb\x93\
+              \x9f\x8a\xb7\x62\x75\x18\x2b\xbb\x6f\x9b",
+            b"\x05\x6d\x9e\xdb\x14\x7b\x7f\x07\x13\xa7\x0f\xc9\xb1\xdd\x3d\xb2\x4a\x57\x55\x0f\xe5\xb2\x05\xb7\x0d\x90\x34\x13\x1d\xa9",
+        );
+        check::<Sha256>(
+            b"\xc5\xc1\x25\x25\xc2\x09\xb9\x25\x91\x57\xc8\x31\x76\xd2\xd0\xd5\x88\x5e\x5e\xaf\x29\xd9\x22\x86\xec\xe7\x6a\x94\x27\x0c\
+              \x79\x9a\x57\x1d\xb2\x31\xb5\x87\xe1\x7c\x3b\x64\x2e\x26\x62\xac\x5d\x62\x16\x8d\xc5\xbe\x78\x0f\xde\xa8\x76\x6e\x03\x8a\
+              \xc3\xd7\xb5\x15\x3b\x33\xbc\x21\x21\xab",
+            b"\x7d\xbb\x59\xe0\x36\x7a\x1c\x0a\xc3\x1a\xbd\x60\xfc\x42\xba\x3c\x4c\x2b\x0a\xf2\x5c\xf8\xe1\x65\x00\x62\x7c\x82\x14\x21",
+        );
+        check::<Sha384>(
+            b"\x93\xb3\x8c\xe3\x14\x37\x84\x75\x2a\x48\x20\xd6\x87\xda\x6c\xc8\xc6\x1a\x2c\x54\xc1\x64\x7b\xff\x4c\x81\x16\x43\x57\xdf\
+              \x65\x02\x1c\xee\x99\x71\x77\xa3\x31\x04\x63\x67\x60\xa1\xb3\x5e\x35\x9d\x55\xa6\x5f\x48\xce\x79\x45\x3b\x54\x44\x19\x21\
+              \xd8\xae\x2e\xaa\x84\xc8\x73\x69\xa4\xef",
+            b"\xca\xd6\x29\x26\x73\x0e\x38\xad\x07\xaf\x3a\x06\xe4\xfa\x48\xc5\x9e\x50\xbe\x2e\x71\x20\x6d\x1e\x0f\xee\x4a\x3e\x95\x4f",
+        );
+        check::<Sha512>(
+            b"\x41\x86\x6a\x14\x61\x21\x70\x57\xab\x66\xde\x78\xb7\x05\x9c\xbc\x87\x4e\x05\xe7\x49\xde\x57\xbd\x17\xff\x5e\x44\xaf\x88\
+              \x16\xd2\x72\x4e\x5a\xa3\xf5\x41\x61\x47\xc2\x18\x1f\xdd\x39\x8d\xed\xc6\xa2\xb6\x79\x9e\x2d\xa3\xf2\x22\x72\x7e\xaa\xaa\
+              \xd8\x7e\x68\xc3\x7a\x2e\xee\x9e\x1b\xa3",
+            b"\xb2\x6d\x4e\xf0\x66\x27\x45\xc1\xa3\x80\x51\xf6\x18\x3d\x22\x0c\x94\xd7\x3a\xaf\xa4\x00\xc7\x2a\xee\x47\xf3\x74\x1c\x55",
+        );
+    }
 }

graviola/src/lib.rs

@@ -166,8 +166,9 @@ pub mod signing {
 
 /// Cryptographic hash functions.
 pub mod hashing {
-    pub use super::high::hash::{Hash, HashContext, HashOutput, Sha256, Sha384, Sha512};
+    pub use super::high::hash::{Hash, HashContext, HashOutput, Sha1, Sha256, Sha384, Sha512};
     pub use super::high::hmac;
+    pub use super::mid::sha1;
     pub use super::mid::sha2;
     pub use super::mid::sha3;
 }

graviola/src/mid/mod.rs

@@ -12,6 +12,7 @@ pub(super) mod p384;
 pub(super) mod rng;
 pub(super) mod rsa_priv;
 pub(super) mod rsa_pub;
+pub mod sha1;
 pub mod sha2;
 pub mod sha3;
 pub(super) mod util;