willow25 0.4.0

A ready-to-use implementation of the Willow specifications.
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

use core::fmt;

#[cfg(feature = "dev")]
use arbitrary::Arbitrary;

use ed25519_dalek::SigningKey;
use rand_core::CryptoRngCore;
use signature::{Keypair, Signer};

use crate::prelude::*;

wrapper! {
    /// A secret key corresponding to a [`SubspaceId`] — see the [`SubspaceId`] docs for an overview, and see the [`authentication`](crate::authorisation) docs for how to use the secret for authentication.
    ///
    /// You can randomly generate subspace secrets and their corresponding subspace ids with the [`randomly_generate_subspace`] function.
    ///
    /// This type is a fairly thin wrapper around [`SigningKey`], use the [`From`] implementations to convert between the two.
    ///
    /// ```
    /// use rand::rngs::OsRng;
    /// use willow25::prelude::*;
    ///
    /// let mut csprng = OsRng; // cryptographically secure pseudo-random number generator
    ///
    /// let (_subspace_id, _secret) = randomly_generate_subspace(&mut csprng);
    /// ```
    #[derive(PartialEq, Eq, Clone)]
    SubspaceSecret; SigningKey
}

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

impl SubspaceSecret {
    /// Computes the [`SubspaceId`] corresponding to `self`, i.e., the [`SubspaceId`] which can be used to verify [`SubspaceSignatures`](super::SubspaceSignature) issued by `self`.
    ///
    /// ```
    /// use rand::rngs::OsRng;
    /// use willow25::prelude::*;
    ///
    /// let mut csprng = OsRng; // cryptographically secure pseudo-random number generator
    ///
    /// let (subspace_id, secret) = randomly_generate_subspace(&mut csprng);
    ///
    /// assert_eq!(secret.corresponding_subspace_id(), subspace_id);
    /// ```
    pub fn corresponding_subspace_id(&self) -> SubspaceId {
        SubspaceId::from_ed25519_verifying_key(self.0.verifying_key())
    }
}

#[cfg(feature = "dev")]
impl<'a> Arbitrary<'a> for SubspaceSecret {
    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
        Ok(Self(SigningKey::from_bytes(&Arbitrary::arbitrary(u)?)))
    }
}

/// Randomly generate a [`SubspaceSecret`] and the corresponding [`SubspaceId`].
///
/// ```
/// use rand::rngs::OsRng;
/// use willow25::prelude::*;
///
/// let mut csprng = OsRng; // cryptographically secure pseudo-random number generator
///
/// let (_subspace_id, _secret) = randomly_generate_subspace(&mut csprng);
/// ```
pub fn randomly_generate_subspace<R: CryptoRngCore + ?Sized>(
    csprng: &mut R,
) -> (SubspaceId, SubspaceSecret) {
    let signing_key = SigningKey::generate(csprng);
    let verifying_key = signing_key.verifying_key();

    (
        SubspaceId::from_ed25519_verifying_key(verifying_key),
        SubspaceSecret(signing_key),
    )
}

impl Keypair for SubspaceSecret {
    type VerifyingKey = SubspaceId;

    fn verifying_key(&self) -> Self::VerifyingKey {
        self.corresponding_subspace_id()
    }
}

impl Signer<SubspaceSignature> for SubspaceSecret {
    fn try_sign(&self, msg: &[u8]) -> Result<SubspaceSignature, signature::Error> {
        self.0.try_sign(msg).map(Into::into)
    }
}