riptering 0.6.0

Maintained fork of kryptering: cryptographic operations with RustCrypto or AWS-LC software providers and PKCS#11 HSM backends
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

//! Provider-neutral public algorithm parameters.

/// Public finite-field Diffie-Hellman parameters and public key.
///
/// The private exponent, when present, remains inside [`crate::SoftwareKey`]
/// and is never exposed through this value.
#[derive(Clone, PartialEq, Eq)]
pub struct DhParameters {
    modulus: Vec<u8>,
    generator: Vec<u8>,
    subgroup_order: Option<Vec<u8>>,
    public_key: Vec<u8>,
}

impl std::fmt::Debug for DhParameters {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("DhParameters")
            .field("modulus_len", &self.modulus.len())
            .field("generator_len", &self.generator.len())
            .field(
                "subgroup_order_len",
                &self.subgroup_order.as_ref().map(Vec::len),
            )
            .field("public_key_len", &self.public_key.len())
            .finish()
    }
}

impl DhParameters {
    pub(crate) fn new(
        modulus: &[u8],
        generator: &[u8],
        subgroup_order: Option<&[u8]>,
        public_key: &[u8],
    ) -> Self {
        Self {
            modulus: modulus.to_vec(),
            generator: generator.to_vec(),
            subgroup_order: subgroup_order.map(<[u8]>::to_vec),
            public_key: public_key.to_vec(),
        }
    }

    #[must_use]
    pub fn modulus(&self) -> &[u8] {
        &self.modulus
    }

    #[must_use]
    pub fn generator(&self) -> &[u8] {
        &self.generator
    }

    #[must_use]
    pub fn subgroup_order(&self) -> Option<&[u8]> {
        self.subgroup_order.as_deref()
    }

    #[must_use]
    pub fn public_key(&self) -> &[u8] {
        &self.public_key
    }
}