jose-jwk 0.1.1

Pure Rust implementation of the JSON Web Key (JWK) component of the Javascript Object Signing and Encryption (JOSE) specification as described in RFC7517
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

// SPDX-FileCopyrightText: 2022 Profian Inc. <opensource@profian.com>
// SPDX-License-Identifier: Apache-2.0 OR MIT

use jose_jwa::Algorithm;

use super::KeyInfo;

/// The kind of a key (public or private).
pub enum Kind<P, S> {
    /// A public key.
    Public(P),

    /// A private key.
    Secret(S),
}

impl<P: KeyInfo, S: KeyInfo> KeyInfo for Kind<P, S> {
    fn strength(&self) -> usize {
        match self {
            Self::Public(k) => k.strength(),
            Self::Secret(k) => k.strength(),
        }
    }

    fn is_supported(&self, algo: &Algorithm) -> bool {
        match self {
            Self::Public(k) => k.is_supported(algo),
            Self::Secret(k) => k.is_supported(algo),
        }
    }
}

#[cfg(feature = "rsa")]
impl From<&Kind<rsa::RsaPublicKey, rsa::RsaPrivateKey>> for crate::Rsa {
    fn from(value: &Kind<rsa::RsaPublicKey, rsa::RsaPrivateKey>) -> Self {
        match value {
            Kind::Public(key) => key.into(),
            Kind::Secret(key) => key.into(),
        }
    }
}

#[cfg(feature = "rsa")]
impl TryFrom<&crate::Rsa> for Kind<rsa::RsaPublicKey, rsa::RsaPrivateKey> {
    type Error = super::Error;

    fn try_from(value: &crate::Rsa) -> Result<Self, Self::Error> {
        if value.prv.is_none() {
            Ok(Kind::Public(value.try_into()?))
        } else {
            Ok(Kind::Secret(value.try_into()?))
        }
    }
}

#[cfg(feature = "p256")]
impl From<&Kind<p256::PublicKey, p256::SecretKey>> for crate::Ec {
    fn from(value: &Kind<p256::PublicKey, p256::SecretKey>) -> Self {
        match value {
            Kind::Public(key) => key.into(),
            Kind::Secret(key) => key.into(),
        }
    }
}

#[cfg(feature = "p256")]
impl TryFrom<&crate::Ec> for Kind<p256::PublicKey, p256::SecretKey> {
    type Error = super::Error;

    fn try_from(value: &crate::Ec) -> Result<Self, Self::Error> {
        if value.d.is_none() {
            Ok(Kind::Public(value.try_into()?))
        } else {
            Ok(Kind::Secret(value.try_into()?))
        }
    }
}

#[cfg(feature = "p384")]
impl From<&Kind<p384::PublicKey, p384::SecretKey>> for crate::Ec {
    fn from(value: &Kind<p384::PublicKey, p384::SecretKey>) -> Self {
        match value {
            Kind::Public(key) => key.into(),
            Kind::Secret(key) => key.into(),
        }
    }
}

#[cfg(feature = "p384")]
impl TryFrom<&crate::Ec> for Kind<p384::PublicKey, p384::SecretKey> {
    type Error = super::Error;

    fn try_from(value: &crate::Ec) -> Result<Self, Self::Error> {
        if value.d.is_none() {
            Ok(Kind::Public(value.try_into()?))
        } else {
            Ok(Kind::Secret(value.try_into()?))
        }
    }
}