Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 159 insertions, 0 deletions

diff --git a/third_party/rust/rust-argon2/src/variant.rs b/third_party/rust/rust-argon2/src/variant.rs
new file mode 100644
index 0000000000..8fb6c0b54c
--- /dev/null
+++ b/third_party/rust/rust-argon2/src/variant.rs
@@ -0,0 +1,159 @@
+// Copyright (c) 2017 Martijn Rijkeboer <mrr@sru-systems.com>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+use super::error::Error;
+use super::result::Result;
+
+/// The Argon2 variant.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub enum Variant {
+    /// Argon2 using data-dependent memory access to thwart tradeoff attacks.
+    /// Recommended for cryptocurrencies and backend servers.
+    Argon2d = 0,
+
+    /// Argon2 using data-independent memory access to thwart side-channel
+    /// attacks. Recommended for password hashing and password-based key
+    /// derivation.
+    Argon2i = 1,
+
+    /// Argon2 using hybrid construction.
+    Argon2id = 2,
+}
+
+impl Variant {
+    /// Gets the lowercase string slice representation of the variant.
+    pub fn as_lowercase_str(&self) -> &'static str {
+        match *self {
+            Variant::Argon2d => "argon2d",
+            Variant::Argon2i => "argon2i",
+            Variant::Argon2id => "argon2id",
+        }
+    }
+
+    /// Gets the u32 representation of the variant.
+    pub fn as_u32(&self) -> u32 {
+        *self as u32
+    }
+
+    /// Gets the u64 representation of the variant.
+    pub fn as_u64(&self) -> u64 {
+        *self as u64
+    }
+
+    /// Gets the uppercase string slice representation of the variant.
+    pub fn as_uppercase_str(&self) -> &'static str {
+        match *self {
+            Variant::Argon2d => "Argon2d",
+            Variant::Argon2i => "Argon2i",
+            Variant::Argon2id => "Argon2id",
+        }
+    }
+
+    /// Attempts to create a variant from a string slice.
+    pub fn from_str(str: &str) -> Result<Variant> {
+        match str {
+            "Argon2d" => Ok(Variant::Argon2d),
+            "Argon2i" => Ok(Variant::Argon2i),
+            "Argon2id" => Ok(Variant::Argon2id),
+            "argon2d" => Ok(Variant::Argon2d),
+            "argon2i" => Ok(Variant::Argon2i),
+            "argon2id" => Ok(Variant::Argon2id),
+            _ => Err(Error::DecodingFail),
+        }
+    }
+
+    /// Attempts to create a variant from an u32.
+    pub fn from_u32(val: u32) -> Result<Variant> {
+        match val {
+            0 => Ok(Variant::Argon2d),
+            1 => Ok(Variant::Argon2i),
+            2 => Ok(Variant::Argon2id),
+            _ => Err(Error::IncorrectType),
+        }
+    }
+}
+
+impl Default for Variant {
+    fn default() -> Variant {
+        Variant::Argon2i
+    }
+}
+
+impl fmt::Display for Variant {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.as_lowercase_str())
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+
+    use error::Error;
+    use super::*;
+
+    #[test]
+    fn as_lowercase_str_returns_correct_str() {
+        assert_eq!(Variant::Argon2d.as_lowercase_str(), "argon2d");
+        assert_eq!(Variant::Argon2i.as_lowercase_str(), "argon2i");
+        assert_eq!(Variant::Argon2id.as_lowercase_str(), "argon2id");
+    }
+
+    #[test]
+    fn as_u32_returns_correct_u32() {
+        assert_eq!(Variant::Argon2d.as_u32(), 0);
+        assert_eq!(Variant::Argon2i.as_u32(), 1);
+        assert_eq!(Variant::Argon2id.as_u32(), 2);
+    }
+
+    #[test]
+    fn as_u64_returns_correct_u64() {
+        assert_eq!(Variant::Argon2d.as_u64(), 0);
+        assert_eq!(Variant::Argon2i.as_u64(), 1);
+        assert_eq!(Variant::Argon2id.as_u64(), 2);
+    }
+
+    #[test]
+    fn as_uppercase_str_returns_correct_str() {
+        assert_eq!(Variant::Argon2d.as_uppercase_str(), "Argon2d");
+        assert_eq!(Variant::Argon2i.as_uppercase_str(), "Argon2i");
+        assert_eq!(Variant::Argon2id.as_uppercase_str(), "Argon2id");
+    }
+
+    #[test]
+    fn default_returns_correct_variant() {
+        assert_eq!(Variant::default(), Variant::Argon2i);
+    }
+
+    #[test]
+    fn display_returns_correct_string() {
+        assert_eq!(format!("{}", Variant::Argon2d), "argon2d");
+        assert_eq!(format!("{}", Variant::Argon2i), "argon2i");
+        assert_eq!(format!("{}", Variant::Argon2id), "argon2id");
+    }
+
+    #[test]
+    fn from_str_returns_correct_result() {
+        assert_eq!(Variant::from_str("Argon2d"), Ok(Variant::Argon2d));
+        assert_eq!(Variant::from_str("Argon2i"), Ok(Variant::Argon2i));
+        assert_eq!(Variant::from_str("Argon2id"), Ok(Variant::Argon2id));
+        assert_eq!(Variant::from_str("argon2d"), Ok(Variant::Argon2d));
+        assert_eq!(Variant::from_str("argon2i"), Ok(Variant::Argon2i));
+        assert_eq!(Variant::from_str("argon2id"), Ok(Variant::Argon2id));
+        assert_eq!(Variant::from_str("foobar"), Err(Error::DecodingFail));
+    }
+
+    #[test]
+    fn from_u32_returns_correct_result() {
+        assert_eq!(Variant::from_u32(0), Ok(Variant::Argon2d));
+        assert_eq!(Variant::from_u32(1), Ok(Variant::Argon2i));
+        assert_eq!(Variant::from_u32(2), Ok(Variant::Argon2id));
+        assert_eq!(Variant::from_u32(3), Err(Error::IncorrectType));
+    }
+}