Merging upstream version 1.70.0+dfsg2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 959 insertions, 0 deletions

diff --git a/vendor/sha1_smol/src/lib.rs b/vendor/sha1_smol/src/lib.rs
new file mode 100644
index 000000000..48692a298
--- /dev/null
+++ b/vendor/sha1_smol/src/lib.rs
@@ -0,0 +1,790 @@
+//! A minimal implementation of SHA1 for rust.
+//!
+//! This implementation supports no_std which is the default mode.  The
+//! following features are available and can be optionally enabled:
+//!
+//! * ``serde``: when enabled the `Digest` type can be serialized.
+//! * ``std``: when enabled errors from this library implement `std::error::Error`
+//!   and the `hexdigest` shortcut becomes available.
+//!
+//! ## Example
+//!
+//! ```rust
+//! # fn main() {
+//!
+//! let mut m = sha1_smol::Sha1::new();
+//! m.update(b"Hello World!");
+//! assert_eq!(m.digest().to_string(),
+//!            "2ef7bde608ce5404e97d5f042f95f89f1c232871");
+//! # }
+//! ```
+//!
+//! The sha1 object can be updated multiple times.  If you only need to use
+//! it once you can also use shortcuts (requires std):
+//!
+//! ```
+//! # trait X { fn hexdigest(&self) -> &'static str { "2ef7bde608ce5404e97d5f042f95f89f1c232871" }}
+//! # impl X for sha1_smol::Sha1 {}
+//! # fn main() {
+//! assert_eq!(sha1_smol::Sha1::from("Hello World!").hexdigest(),
+//!            "2ef7bde608ce5404e97d5f042f95f89f1c232871");
+//! # }
+//! ```
+
+#![no_std]
+#![deny(missing_docs)]
+#![allow(deprecated)]
+#![allow(clippy::double_parens)]
+#![allow(clippy::identity_op)]
+
+use core::cmp;
+use core::fmt;
+use core::hash;
+use core::str;
+
+mod simd;
+use crate::simd::*;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+/// The length of a SHA1 digest in bytes
+pub const DIGEST_LENGTH: usize = 20;
+
+/// Represents a Sha1 hash object in memory.
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct Sha1 {
+    state: Sha1State,
+    blocks: Blocks,
+    len: u64,
+}
+
+struct Blocks {
+    len: u32,
+    block: [u8; 64],
+}
+
+#[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Default)]
+struct Sha1State {
+    state: [u32; 5],
+}
+
+/// Digest generated from a `Sha1` instance.
+///
+/// A digest can be formatted to view the digest as a hex string, or the bytes
+/// can be extracted for later processing.
+///
+/// To retrieve a hex string result call `to_string` on it (requires that std
+/// is available).
+///
+/// If the `serde` feature is enabled a digest can also be serialized and
+/// deserialized.  Likewise a digest can be parsed from a hex string.
+#[derive(PartialOrd, Ord, PartialEq, Eq, Hash, Clone, Copy, Default)]
+pub struct Digest {
+    data: Sha1State,
+}
+
+const DEFAULT_STATE: Sha1State = Sha1State {
+    state: [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0],
+};
+
+#[inline(always)]
+fn as_block(input: &[u8]) -> &[u8; 64] {
+    unsafe {
+        assert!(input.len() == 64);
+        let arr: &[u8; 64] = &*(input.as_ptr() as *const [u8; 64]);
+        arr
+    }
+}
+
+impl Default for Sha1 {
+    fn default() -> Sha1 {
+        Sha1::new()
+    }
+}
+
+impl Sha1 {
+    /// Creates an fresh sha1 hash object.
+    ///
+    /// This is equivalent to creating a hash with `Default::default`.
+    pub fn new() -> Sha1 {
+        Sha1 {
+            state: DEFAULT_STATE,
+            len: 0,
+            blocks: Blocks {
+                len: 0,
+                block: [0; 64],
+            },
+        }
+    }
+
+    /// Shortcut to create a sha1 from some bytes.
+    ///
+    /// This also lets you create a hash from a utf-8 string.  This is equivalent
+    /// to making a new Sha1 object and calling `update` on it once.
+    pub fn from<D: AsRef<[u8]>>(data: D) -> Sha1 {
+        let mut rv = Sha1::new();
+        rv.update(data.as_ref());
+        rv
+    }
+
+    /// Resets the hash object to it's initial state.
+    pub fn reset(&mut self) {
+        self.state = DEFAULT_STATE;
+        self.len = 0;
+        self.blocks.len = 0;
+    }
+
+    /// Update hash with input data.
+    pub fn update(&mut self, data: &[u8]) {
+        let len = &mut self.len;
+        let state = &mut self.state;
+        self.blocks.input(data, |block| {
+            *len += block.len() as u64;
+            state.process(block);
+        })
+    }
+
+    /// Retrieve digest result.
+    pub fn digest(&self) -> Digest {
+        let mut state = self.state;
+        let bits = (self.len + (self.blocks.len as u64)) * 8;
+        let extra = [
+            (bits >> 56) as u8,
+            (bits >> 48) as u8,
+            (bits >> 40) as u8,
+            (bits >> 32) as u8,
+            (bits >> 24) as u8,
+            (bits >> 16) as u8,
+            (bits >> 8) as u8,
+            (bits >> 0) as u8,
+        ];
+        let mut last = [0; 128];
+        let blocklen = self.blocks.len as usize;
+        last[..blocklen].clone_from_slice(&self.blocks.block[..blocklen]);
+        last[blocklen] = 0x80;
+
+        if blocklen < 56 {
+            last[56..64].clone_from_slice(&extra);
+            state.process(as_block(&last[0..64]));
+        } else {
+            last[120..128].clone_from_slice(&extra);
+            state.process(as_block(&last[0..64]));
+            state.process(as_block(&last[64..128]));
+        }
+
+        Digest { data: state }
+    }
+
+    /// Retrieve the digest result as hex string directly.
+    ///
+    /// (The function is only available if the `std` feature is enabled)
+    #[cfg(feature = "std")]
+    pub fn hexdigest(&self) -> std::string::String {
+        use std::string::ToString;
+        self.digest().to_string()
+    }
+}
+
+impl Digest {
+    /// Returns the 160 bit (20 byte) digest as a byte array.
+    pub fn bytes(&self) -> [u8; DIGEST_LENGTH] {
+        [
+            (self.data.state[0] >> 24) as u8,
+            (self.data.state[0] >> 16) as u8,
+            (self.data.state[0] >> 8) as u8,
+            (self.data.state[0] >> 0) as u8,
+            (self.data.state[1] >> 24) as u8,
+            (self.data.state[1] >> 16) as u8,
+            (self.data.state[1] >> 8) as u8,
+            (self.data.state[1] >> 0) as u8,
+            (self.data.state[2] >> 24) as u8,
+            (self.data.state[2] >> 16) as u8,
+            (self.data.state[2] >> 8) as u8,
+            (self.data.state[2] >> 0) as u8,
+            (self.data.state[3] >> 24) as u8,
+            (self.data.state[3] >> 16) as u8,
+            (self.data.state[3] >> 8) as u8,
+            (self.data.state[3] >> 0) as u8,
+            (self.data.state[4] >> 24) as u8,
+            (self.data.state[4] >> 16) as u8,
+            (self.data.state[4] >> 8) as u8,
+            (self.data.state[4] >> 0) as u8,
+        ]
+    }
+}
+
+impl Blocks {
+    fn input<F>(&mut self, mut input: &[u8], mut f: F)
+    where
+        F: FnMut(&[u8; 64]),
+    {
+        if self.len > 0 {
+            let len = self.len as usize;
+            let amt = cmp::min(input.len(), self.block.len() - len);
+            self.block[len..len + amt].clone_from_slice(&input[..amt]);
+            if len + amt == self.block.len() {
+                f(&self.block);
+                self.len = 0;
+                input = &input[amt..];
+            } else {
+                self.len += amt as u32;
+                return;
+            }
+        }
+        assert_eq!(self.len, 0);
+        for chunk in input.chunks(64) {
+            if chunk.len() == 64 {
+                f(as_block(chunk))
+            } else {
+                self.block[..chunk.len()].clone_from_slice(chunk);
+                self.len = chunk.len() as u32;
+            }
+        }
+    }
+}
+
+// Round key constants
+const K0: u32 = 0x5A827999u32;
+const K1: u32 = 0x6ED9EBA1u32;
+const K2: u32 = 0x8F1BBCDCu32;
+const K3: u32 = 0xCA62C1D6u32;
+
+/// Not an intrinsic, but gets the first element of a vector.
+#[inline]
+fn sha1_first(w0: u32x4) -> u32 {
+    w0.0
+}
+
+/// Not an intrinsic, but adds a word to the first element of a vector.
+#[inline]
+fn sha1_first_add(e: u32, w0: u32x4) -> u32x4 {
+    let u32x4(a, b, c, d) = w0;
+    u32x4(e.wrapping_add(a), b, c, d)
+}
+
+/// Emulates `llvm.x86.sha1msg1` intrinsic.
+fn sha1msg1(a: u32x4, b: u32x4) -> u32x4 {
+    let u32x4(_, _, w2, w3) = a;
+    let u32x4(w4, w5, _, _) = b;
+    a ^ u32x4(w2, w3, w4, w5)
+}
+
+/// Emulates `llvm.x86.sha1msg2` intrinsic.
+fn sha1msg2(a: u32x4, b: u32x4) -> u32x4 {
+    let u32x4(x0, x1, x2, x3) = a;
+    let u32x4(_, w13, w14, w15) = b;
+
+    let w16 = (x0 ^ w13).rotate_left(1);
+    let w17 = (x1 ^ w14).rotate_left(1);
+    let w18 = (x2 ^ w15).rotate_left(1);
+    let w19 = (x3 ^ w16).rotate_left(1);
+
+    u32x4(w16, w17, w18, w19)
+}
+
+/// Emulates `llvm.x86.sha1nexte` intrinsic.
+#[inline]
+fn sha1_first_half(abcd: u32x4, msg: u32x4) -> u32x4 {
+    sha1_first_add(sha1_first(abcd).rotate_left(30), msg)
+}
+
+/// Emulates `llvm.x86.sha1rnds4` intrinsic.
+/// Performs 4 rounds of the message block digest.
+fn sha1_digest_round_x4(abcd: u32x4, work: u32x4, i: i8) -> u32x4 {
+    const K0V: u32x4 = u32x4(K0, K0, K0, K0);
+    const K1V: u32x4 = u32x4(K1, K1, K1, K1);
+    const K2V: u32x4 = u32x4(K2, K2, K2, K2);
+    const K3V: u32x4 = u32x4(K3, K3, K3, K3);
+
+    match i {
+        0 => sha1rnds4c(abcd, work + K0V),
+        1 => sha1rnds4p(abcd, work + K1V),
+        2 => sha1rnds4m(abcd, work + K2V),
+        3 => sha1rnds4p(abcd, work + K3V),
+        _ => panic!("unknown icosaround index"),
+    }
+}
+
+/// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic.
+fn sha1rnds4c(abcd: u32x4, msg: u32x4) -> u32x4 {
+    let u32x4(mut a, mut b, mut c, mut d) = abcd;
+    let u32x4(t, u, v, w) = msg;
+    let mut e = 0u32;
+
+    macro_rules! bool3ary_202 {
+        ($a:expr, $b:expr, $c:expr) => {
+            ($c ^ ($a & ($b ^ $c)))
+        };
+    } // Choose, MD5F, SHA1C
+
+    e = e
+        .wrapping_add(a.rotate_left(5))
+        .wrapping_add(bool3ary_202!(b, c, d))
+        .wrapping_add(t);
+    b = b.rotate_left(30);
+
+    d = d
+        .wrapping_add(e.rotate_left(5))
+        .wrapping_add(bool3ary_202!(a, b, c))
+        .wrapping_add(u);
+    a = a.rotate_left(30);
+
+    c = c
+        .wrapping_add(d.rotate_left(5))
+        .wrapping_add(bool3ary_202!(e, a, b))
+        .wrapping_add(v);
+    e = e.rotate_left(30);
+
+    b = b
+        .wrapping_add(c.rotate_left(5))
+        .wrapping_add(bool3ary_202!(d, e, a))
+        .wrapping_add(w);
+    d = d.rotate_left(30);
+
+    u32x4(b, c, d, e)
+}
+
+/// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic.
+fn sha1rnds4p(abcd: u32x4, msg: u32x4) -> u32x4 {
+    let u32x4(mut a, mut b, mut c, mut d) = abcd;
+    let u32x4(t, u, v, w) = msg;
+    let mut e = 0u32;
+
+    macro_rules! bool3ary_150 {
+        ($a:expr, $b:expr, $c:expr) => {
+            ($a ^ $b ^ $c)
+        };
+    } // Parity, XOR, MD5H, SHA1P
+
+    e = e
+        .wrapping_add(a.rotate_left(5))
+        .wrapping_add(bool3ary_150!(b, c, d))
+        .wrapping_add(t);
+    b = b.rotate_left(30);
+
+    d = d
+        .wrapping_add(e.rotate_left(5))
+        .wrapping_add(bool3ary_150!(a, b, c))
+        .wrapping_add(u);
+    a = a.rotate_left(30);
+
+    c = c
+        .wrapping_add(d.rotate_left(5))
+        .wrapping_add(bool3ary_150!(e, a, b))
+        .wrapping_add(v);
+    e = e.rotate_left(30);
+
+    b = b
+        .wrapping_add(c.rotate_left(5))
+        .wrapping_add(bool3ary_150!(d, e, a))
+        .wrapping_add(w);
+    d = d.rotate_left(30);
+
+    u32x4(b, c, d, e)
+}
+
+/// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic.
+fn sha1rnds4m(abcd: u32x4, msg: u32x4) -> u32x4 {
+    let u32x4(mut a, mut b, mut c, mut d) = abcd;
+    let u32x4(t, u, v, w) = msg;
+    let mut e = 0u32;
+
+    macro_rules! bool3ary_232 {
+        ($a:expr, $b:expr, $c:expr) => {
+            ($a & $b) ^ ($a & $c) ^ ($b & $c)
+        };
+    } // Majority, SHA1M
+
+    e = e
+        .wrapping_add(a.rotate_left(5))
+        .wrapping_add(bool3ary_232!(b, c, d))
+        .wrapping_add(t);
+    b = b.rotate_left(30);
+
+    d = d
+        .wrapping_add(e.rotate_left(5))
+        .wrapping_add(bool3ary_232!(a, b, c))
+        .wrapping_add(u);
+    a = a.rotate_left(30);
+
+    c = c
+        .wrapping_add(d.rotate_left(5))
+        .wrapping_add(bool3ary_232!(e, a, b))
+        .wrapping_add(v);
+    e = e.rotate_left(30);
+
+    b = b
+        .wrapping_add(c.rotate_left(5))
+        .wrapping_add(bool3ary_232!(d, e, a))
+        .wrapping_add(w);
+    d = d.rotate_left(30);
+
+    u32x4(b, c, d, e)
+}
+
+impl Sha1State {
+    fn process(&mut self, block: &[u8; 64]) {
+        let mut words = [0u32; 16];
+        for (i, word) in words.iter_mut().enumerate() {
+            let off = i * 4;
+            *word = (block[off + 3] as u32)
+                | ((block[off + 2] as u32) << 8)
+                | ((block[off + 1] as u32) << 16)
+                | ((block[off] as u32) << 24);
+        }
+        macro_rules! schedule {
+            ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {
+                sha1msg2(sha1msg1($v0, $v1) ^ $v2, $v3)
+            };
+        }
+
+        macro_rules! rounds4 {
+            ($h0:ident, $h1:ident, $wk:expr, $i:expr) => {
+                sha1_digest_round_x4($h0, sha1_first_half($h1, $wk), $i)
+            };
+        }
+
+        // Rounds 0..20
+        let mut h0 = u32x4(self.state[0], self.state[1], self.state[2], self.state[3]);
+        let mut w0 = u32x4(words[0], words[1], words[2], words[3]);
+        let mut h1 = sha1_digest_round_x4(h0, sha1_first_add(self.state[4], w0), 0);
+        let mut w1 = u32x4(words[4], words[5], words[6], words[7]);
+        h0 = rounds4!(h1, h0, w1, 0);
+        let mut w2 = u32x4(words[8], words[9], words[10], words[11]);
+        h1 = rounds4!(h0, h1, w2, 0);
+        let mut w3 = u32x4(words[12], words[13], words[14], words[15]);
+        h0 = rounds4!(h1, h0, w3, 0);
+        let mut w4 = schedule!(w0, w1, w2, w3);
+        h1 = rounds4!(h0, h1, w4, 0);
+
+        // Rounds 20..40
+        w0 = schedule!(w1, w2, w3, w4);
+        h0 = rounds4!(h1, h0, w0, 1);
+        w1 = schedule!(w2, w3, w4, w0);
+        h1 = rounds4!(h0, h1, w1, 1);
+        w2 = schedule!(w3, w4, w0, w1);
+        h0 = rounds4!(h1, h0, w2, 1);
+        w3 = schedule!(w4, w0, w1, w2);
+        h1 = rounds4!(h0, h1, w3, 1);
+        w4 = schedule!(w0, w1, w2, w3);
+        h0 = rounds4!(h1, h0, w4, 1);
+
+        // Rounds 40..60
+        w0 = schedule!(w1, w2, w3, w4);
+        h1 = rounds4!(h0, h1, w0, 2);
+        w1 = schedule!(w2, w3, w4, w0);
+        h0 = rounds4!(h1, h0, w1, 2);
+        w2 = schedule!(w3, w4, w0, w1);
+        h1 = rounds4!(h0, h1, w2, 2);
+        w3 = schedule!(w4, w0, w1, w2);
+        h0 = rounds4!(h1, h0, w3, 2);
+        w4 = schedule!(w0, w1, w2, w3);
+        h1 = rounds4!(h0, h1, w4, 2);
+
+        // Rounds 60..80
+        w0 = schedule!(w1, w2, w3, w4);
+        h0 = rounds4!(h1, h0, w0, 3);
+        w1 = schedule!(w2, w3, w4, w0);
+        h1 = rounds4!(h0, h1, w1, 3);
+        w2 = schedule!(w3, w4, w0, w1);
+        h0 = rounds4!(h1, h0, w2, 3);
+        w3 = schedule!(w4, w0, w1, w2);
+        h1 = rounds4!(h0, h1, w3, 3);
+        w4 = schedule!(w0, w1, w2, w3);
+        h0 = rounds4!(h1, h0, w4, 3);
+
+        let e = sha1_first(h1).rotate_left(30);
+        let u32x4(a, b, c, d) = h0;
+
+        self.state[0] = self.state[0].wrapping_add(a);
+        self.state[1] = self.state[1].wrapping_add(b);
+        self.state[2] = self.state[2].wrapping_add(c);
+        self.state[3] = self.state[3].wrapping_add(d);
+        self.state[4] = self.state[4].wrapping_add(e);
+    }
+}
+
+impl PartialEq for Blocks {
+    fn eq(&self, other: &Blocks) -> bool {
+        (self.len, &self.block[..]).eq(&(other.len, &other.block[..]))
+    }
+}
+
+impl Ord for Blocks {
+    fn cmp(&self, other: &Blocks) -> cmp::Ordering {
+        (self.len, &self.block[..]).cmp(&(other.len, &other.block[..]))
+    }
+}
+
+impl PartialOrd for Blocks {
+    fn partial_cmp(&self, other: &Blocks) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Eq for Blocks {}
+
+impl hash::Hash for Blocks {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.len.hash(state);
+        self.block.hash(state);
+    }
+}
+
+impl Clone for Blocks {
+    fn clone(&self) -> Blocks {
+        Blocks { ..*self }
+    }
+}
+
+/// Indicates that a digest couldn't be parsed.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Ord, PartialOrd, Debug)]
+pub struct DigestParseError(());
+
+impl fmt::Display for DigestParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "not a valid sha1 hash")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DigestParseError {
+    fn description(&self) -> &str {
+        "not a valid sha1 hash"
+    }
+}
+
+impl str::FromStr for Digest {
+    type Err = DigestParseError;
+
+    fn from_str(s: &str) -> Result<Digest, DigestParseError> {
+        if s.len() != 40 {
+            return Err(DigestParseError(()));
+        }
+        let mut rv: Digest = Default::default();
+        for idx in 0..5 {
+            rv.data.state[idx] =
+                r#try!(u32::from_str_radix(&s[idx * 8..idx * 8 + 8], 16)
+                    .map_err(|_| DigestParseError(())));
+        }
+        Ok(rv)
+    }
+}
+
+impl fmt::Display for Digest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for i in self.data.state.iter() {
+            r#try!(write!(f, "{:08x}", i));
+        }
+        Ok(())
+    }
+}
+
+impl fmt::Debug for Digest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Digest {{ \"{}\" }}", self)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::ser::Serialize for Digest {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        fn to_hex(num: u8) -> u8 {
+            b"0123456789abcdef"[num as usize]
+        }
+
+        let mut hex_str = [0u8; 40];
+        let mut c = 0;
+        for state in self.data.state.iter() {
+            for off in 0..4 {
+                let byte = (state >> (8 * (3 - off))) as u8;
+                hex_str[c] = to_hex(byte >> 4);
+                hex_str[c + 1] = to_hex(byte & 0xf);
+                c += 2;
+            }
+        }
+        serializer.serialize_str(unsafe { str::from_utf8_unchecked(&hex_str[..]) })
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::de::Deserialize<'de> for Digest {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        struct V;
+
+        impl<'de> serde::de::Visitor<'de> for V {
+            type Value = Digest;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("SHA-1 hash")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Digest, E>
+            where
+                E: serde::de::Error,
+            {
+                value.parse().map_err(|_| {
+                    serde::de::Error::invalid_value(serde::de::Unexpected::Str(value), &self)
+                })
+            }
+        }
+
+        deserializer.deserialize_str(V)
+    }
+}
+
+#[rustfmt::skip]
+#[cfg(test)]
+mod tests {
+    extern crate std;
+    extern crate rand;
+    extern crate openssl;
+
+    use self::std::prelude::v1::*;
+
+    use crate::Sha1;
+
+    #[test]
+    fn test_simple() {
+        let mut m = Sha1::new();
+
+        let tests = [
+            ("The quick brown fox jumps over the lazy dog",
+             "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"),
+            ("The quick brown fox jumps over the lazy cog",
+             "de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3"),
+            ("", "da39a3ee5e6b4b0d3255bfef95601890afd80709"),
+            ("testing\n", "9801739daae44ec5293d4e1f53d3f4d2d426d91c"),
+            ("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+             "025ecbd5d70f8fb3c5457cd96bab13fda305dc59"),
+            ("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+             "4300320394f7ee239bcdce7d3b8bcee173a0cd5c"),
+            ("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+             "cef734ba81a024479e09eb5a75b6ddae62e6abf1"),
+        ];
+
+        for &(s, ref h) in tests.iter() {
+            let data = s.as_bytes();
+
+            m.reset();
+            m.update(data);
+            let hh = m.digest().to_string();
+
+            assert_eq!(hh.len(), h.len());
+            assert_eq!(hh, *h);
+        }
+    }
+
+    #[test]
+    fn test_shortcuts() {
+        let s = Sha1::from("The quick brown fox jumps over the lazy dog");
+        assert_eq!(s.digest().to_string(), "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
+
+        let s = Sha1::from(&b"The quick brown fox jumps over the lazy dog"[..]);
+        assert_eq!(s.digest().to_string(), "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
+
+        #[cfg(feature="std")] {
+            let s = Sha1::from("The quick brown fox jumps over the lazy dog");
+            assert_eq!(s.hexdigest(), "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
+        }
+    }
+
+    #[test]
+    fn test_multiple_updates() {
+        let mut m = Sha1::new();
+
+        m.reset();
+        m.update("The quick brown ".as_bytes());
+        m.update("fox jumps over ".as_bytes());
+        m.update("the lazy dog".as_bytes());
+        let hh = m.digest().to_string();
+
+
+        let h = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12";
+        assert_eq!(hh.len(), h.len());
+        assert_eq!(hh, &*h);
+    }
+
+    #[test]
+    fn test_sha1_loop() {
+        let mut m = Sha1::new();
+        let s = "The quick brown fox jumps over the lazy dog.";
+        let n = 1000u64;
+
+        for _ in 0..3 {
+            m.reset();
+            for _ in 0..n {
+                m.update(s.as_bytes());
+            }
+            assert_eq!(m.digest().to_string(),
+                       "7ca27655f67fceaa78ed2e645a81c7f1d6e249d2");
+        }
+    }
+
+    #[test]
+    fn spray_and_pray() {
+        use self::rand::Rng;
+
+        let mut rng = rand::thread_rng();
+        let mut m = Sha1::new();
+        let mut bytes = [0; 512];
+
+        for _ in 0..20 {
+            let ty = openssl::hash::MessageDigest::sha1();
+            let mut r = openssl::hash::Hasher::new(ty).unwrap();
+            m.reset();
+            for _ in 0..50 {
+                let len = rng.gen::<usize>() % bytes.len();
+                rng.fill_bytes(&mut bytes[..len]);
+                m.update(&bytes[..len]);
+                r.update(&bytes[..len]).unwrap();
+            }
+            assert_eq!(r.finish().unwrap().as_ref(), &m.digest().bytes());
+        }
+    }
+
+    #[test]
+    #[cfg(feature="std")]
+    fn test_parse() {
+        use crate::Digest;
+        use std::error::Error;
+        let y: Digest = "2ef7bde608ce5404e97d5f042f95f89f1c232871".parse().unwrap();
+        assert_eq!(y.to_string(), "2ef7bde608ce5404e97d5f042f95f89f1c232871");
+        assert!("asdfasdf".parse::<Digest>().is_err());
+        assert_eq!("asdfasdf".parse::<Digest>()
+            .map_err(|x| x.description().to_string()).unwrap_err(), "not a valid sha1 hash");
+    }
+}
+
+#[rustfmt::skip]
+#[cfg(all(test, feature="serde"))]
+mod serde_tests {
+    extern crate std;
+    extern crate serde_json;
+
+    use self::std::prelude::v1::*;
+
+    use crate::{Sha1, Digest};
+
+    #[test]
+    fn test_to_json() {
+        let mut s = Sha1::new();
+        s.update(b"Hello World!");
+        let x = s.digest();
+        let y = serde_json::to_vec(&x).unwrap();
+        assert_eq!(y, &b"\"2ef7bde608ce5404e97d5f042f95f89f1c232871\""[..]);
+    }
+
+    #[test]
+    fn test_from_json() {
+        let y: Digest = serde_json::from_str("\"2ef7bde608ce5404e97d5f042f95f89f1c232871\"").unwrap();
+        assert_eq!(y.to_string(), "2ef7bde608ce5404e97d5f042f95f89f1c232871");
+    }
+}
diff --git a/vendor/sha1_smol/src/simd.rs b/vendor/sha1_smol/src/simd.rs
new file mode 100644
index 000000000..011bbf862
--- /dev/null
+++ b/vendor/sha1_smol/src/simd.rs
@@ -0,0 +1,169 @@
+// Copyright (c) 2006-2009 Graydon Hoare
+// Copyright (c) 2009-2013 Mozilla Foundation
+
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+pub use self::fake::*;
+
+pub trait SimdExt {
+    fn simd_eq(self, rhs: Self) -> Self;
+}
+
+impl SimdExt for fake::u32x4 {
+    fn simd_eq(self, rhs: Self) -> Self {
+        if self == rhs {
+            fake::u32x4(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff)
+        } else {
+            fake::u32x4(0, 0, 0, 0)
+        }
+    }
+}
+
+mod fake {
+    use core::ops::{Add, BitAnd, BitOr, BitXor, Shl, Shr, Sub};
+
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    #[allow(non_camel_case_types)]
+    pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
+
+    impl Add for u32x4 {
+        type Output = u32x4;
+
+        fn add(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0.wrapping_add(rhs.0),
+                self.1.wrapping_add(rhs.1),
+                self.2.wrapping_add(rhs.2),
+                self.3.wrapping_add(rhs.3),
+            )
+        }
+    }
+
+    impl Sub for u32x4 {
+        type Output = u32x4;
+
+        fn sub(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0.wrapping_sub(rhs.0),
+                self.1.wrapping_sub(rhs.1),
+                self.2.wrapping_sub(rhs.2),
+                self.3.wrapping_sub(rhs.3),
+            )
+        }
+    }
+
+    impl BitAnd for u32x4 {
+        type Output = u32x4;
+
+        fn bitand(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0 & rhs.0,
+                self.1 & rhs.1,
+                self.2 & rhs.2,
+                self.3 & rhs.3,
+            )
+        }
+    }
+
+    impl BitOr for u32x4 {
+        type Output = u32x4;
+
+        fn bitor(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0 | rhs.0,
+                self.1 | rhs.1,
+                self.2 | rhs.2,
+                self.3 | rhs.3,
+            )
+        }
+    }
+
+    impl BitXor for u32x4 {
+        type Output = u32x4;
+
+        fn bitxor(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0 ^ rhs.0,
+                self.1 ^ rhs.1,
+                self.2 ^ rhs.2,
+                self.3 ^ rhs.3,
+            )
+        }
+    }
+
+    impl Shl<usize> for u32x4 {
+        type Output = u32x4;
+
+        fn shl(self, amt: usize) -> u32x4 {
+            u32x4(self.0 << amt, self.1 << amt, self.2 << amt, self.3 << amt)
+        }
+    }
+
+    impl Shl<u32x4> for u32x4 {
+        type Output = u32x4;
+
+        fn shl(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0 << rhs.0,
+                self.1 << rhs.1,
+                self.2 << rhs.2,
+                self.3 << rhs.3,
+            )
+        }
+    }
+
+    impl Shr<usize> for u32x4 {
+        type Output = u32x4;
+
+        fn shr(self, amt: usize) -> u32x4 {
+            u32x4(self.0 >> amt, self.1 >> amt, self.2 >> amt, self.3 >> amt)
+        }
+    }
+
+    impl Shr<u32x4> for u32x4 {
+        type Output = u32x4;
+
+        fn shr(self, rhs: u32x4) -> u32x4 {
+            u32x4(
+                self.0 >> rhs.0,
+                self.1 >> rhs.1,
+                self.2 >> rhs.2,
+                self.3 >> rhs.3,
+            )
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    #[allow(non_camel_case_types)]
+    pub struct u64x2(pub u64, pub u64);
+
+    impl Add for u64x2 {
+        type Output = u64x2;
+
+        fn add(self, rhs: u64x2) -> u64x2 {
+            u64x2(self.0.wrapping_add(rhs.0), self.1.wrapping_add(rhs.1))
+        }
+    }
+}