light-openid 2.0.6

Lightweight OpenID primitives & client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use crate::utils::crypt_utils::sha256_str;
use std::fmt::Display;

/// A Nonce used for authentication requests
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
#[serde(tag = "t")]
pub enum Nonce {
    Hashed { id: uuid::Uuid },
    Plain { val: String },
}

impl Default for Nonce {
    fn default() -> Self {
        Self::new()
    }
}

impl Nonce {
    /// Generate a new random nonce
    pub fn new() -> Self {
        Self::Hashed {
            id: uuid::Uuid::new_v4(),
        }
    }

    /// Generate a new plain text nonce. Will be used as-is in authorization and token requests
    /// (no hashing performed)
    pub fn new_plain(d: impl Display) -> Self {
        Self::Plain { val: d.to_string() }
    }

    /// Get a hash of the nonce
    pub fn hash(&self) -> String {
        match self {
            Nonce::Hashed { id } => {
                let hash = sha256_str(id.as_bytes());
                hash[0..hash.len() / 2].to_string()
            }
            Nonce::Plain { val } => val.to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::nonce::Nonce;

    #[test]
    fn serialize_nonce() {
        let nonce = Nonce::new();
        let serialized = serde_json::to_string(&nonce).unwrap();
        let deserialized: Nonce = serde_json::from_str(&serialized).unwrap();
        assert_eq!(deserialized, nonce);
    }
}