rops 0.1.7

SOPS-like library in pure Rust
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use std::str::FromStr;

use generic_array::{typenum::U32, ArrayLength};

use crate::*;

#[derive(Debug, Clone, PartialEq)]
pub struct Nonce<T: ArrayLength<u8> = U32>(RngKey<T>);

impl<T: ArrayLength<u8>> Nonce<T> {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self(RngKey::new())
    }
}

// TEMP(WORKAROUND): derive_more::AsRef doesn't seem to work
impl<T: ArrayLength<u8>> AsRef<[u8]> for Nonce<T> {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

// TEMP(WORKAROUND): derive_more::AsMut doesn't seem to work
impl<T: ArrayLength<u8>> AsMut<[u8]> for Nonce<T> {
    fn as_mut(&mut self) -> &mut [u8] {
        self.0.as_mut()
    }
}

impl<T: ArrayLength<u8>> FromStr for Nonce<T> {
    type Err = Base64DecodeError;

    fn from_str(base64_str: &str) -> Result<Self, Self::Err> {
        let mut nonce = Self(RngKey::empty());
        nonce.as_mut().decode_base64(base64_str).map(|_| nonce)
    }
}

#[cfg(feature = "test-utils")]
mod mock {
    use generic_array::GenericArray;

    use super::*;

    impl MockTestUtil for Nonce {
        fn mock() -> Self {
            Self(RngKey(GenericArray::from([
                89, 68, 40, 65, 58, 209, 95, 15, 237, 82, 12, 41, 153, 33, 186, 247, 21, 173, 119, 151, 85, 49, 247, 188, 169, 73, 114,
                213, 80, 124, 185, 195,
            ])))
        }
    }

    impl MockDisplayTestUtil for Nonce {
        fn mock_display() -> String {
            "WUQoQTrRXw/tUgwpmSG69xWtd5dVMfe8qUly1VB8ucM=".to_string()
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_base64_str() {
        FromStrTestUtils::assert_parse::<Nonce>();
    }
}