sanstun 0.1.0

A fast, sans-IO implementation of the WireGuard® protocol
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::fmt;

use zeroize::Zeroizing;

/// An X25519 public key.
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct PublicKey([u8; 32]);

impl PublicKey {
    pub fn as_bytes(&self) -> &[u8; 32] {
        &self.0
    }

    pub fn to_bytes(&self) -> [u8; 32] {
        self.0
    }

    pub(crate) fn to_dalek(self) -> x25519_dalek::PublicKey {
        x25519_dalek::PublicKey::from(self.0)
    }
}

impl From<[u8; 32]> for PublicKey {
    fn from(bytes: [u8; 32]) -> Self {
        Self(bytes)
    }
}

impl From<&StaticSecret> for PublicKey {
    fn from(secret: &StaticSecret) -> Self {
        Self(x25519_dalek::PublicKey::from(&secret.0).to_bytes())
    }
}

impl fmt::Debug for PublicKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("PublicKey(")?;
        for byte in self.0 {
            write!(f, "{byte:02x}")?;
        }
        f.write_str(")")
    }
}

/// An X25519 static private key, zeroized on drop.
#[derive(Clone)]
pub struct StaticSecret(x25519_dalek::StaticSecret);

impl StaticSecret {
    pub fn as_bytes(&self) -> &[u8; 32] {
        self.0.as_bytes()
    }

    pub(crate) fn as_dalek(&self) -> &x25519_dalek::StaticSecret {
        &self.0
    }
}

impl From<Zeroizing<[u8; 32]>> for StaticSecret {
    fn from(bytes: Zeroizing<[u8; 32]>) -> Self {
        Self(x25519_dalek::StaticSecret::from(*bytes))
    }
}

impl fmt::Debug for StaticSecret {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("StaticSecret(..)")
    }
}

/// A WireGuard preshared key, zeroized on drop.
pub struct PresharedKey(Zeroizing<[u8; 32]>);

impl PresharedKey {
    pub(crate) fn as_bytes(&self) -> &[u8; 32] {
        &self.0
    }
}

impl From<Zeroizing<[u8; 32]>> for PresharedKey {
    fn from(bytes: Zeroizing<[u8; 32]>) -> Self {
        Self(bytes)
    }
}

impl fmt::Debug for PresharedKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("PresharedKey(..)")
    }
}

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

    #[test]
    fn debug_redacts_only_the_secrets() {
        let secret = StaticSecret::from(Zeroizing::new([0xab; 32]));
        let psk = PresharedKey::from(Zeroizing::new([0xab; 32]));

        assert_eq!(format!("{secret:?}"), "StaticSecret(..)");
        assert_eq!(format!("{psk:?}"), "PresharedKey(..)");
        assert_eq!(
            format!("{:?}", PublicKey::from([0xab; 32])),
            format!("PublicKey({})", "ab".repeat(32))
        );
    }
}