aliri 0.6.4

Implementations of the Javascript/JSON Object Signing and Encryption (JOSE) standards
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::{convert::TryFrom, fmt, str::FromStr};

use serde::{Deserialize, Serialize};

use crate::{error, jwa, jws};

/// An algorithm
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum Algorithm {
    /// A signing/verification algorithm
    Signing(jws::Algorithm),
}

impl Algorithm {
    /// Gets the usage related to this algorithm
    pub fn to_usage(self) -> jwa::Usage {
        match self {
            Self::Signing(_) => jwa::Usage::Signing,
        }
    }
}

impl fmt::Display for Algorithm {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::Signing(x) => fmt::Display::fmt(x, f),
        }
    }
}

#[cfg(feature = "hmac")]
#[cfg_attr(docsrs, doc(cfg(feature = "hmac")))]
impl Algorithm {
    /// The HS256 signing algorithm
    pub const HS256: Algorithm = Self::Signing(jws::Algorithm::HS256);
    /// The HS384 signing algorithm
    pub const HS384: Algorithm = Self::Signing(jws::Algorithm::HS384);
    /// The HS512 signing algorithm
    pub const HS512: Algorithm = Self::Signing(jws::Algorithm::HS512);
}

#[cfg(feature = "rsa")]
#[cfg_attr(docsrs, doc(cfg(feature = "rsa")))]
impl Algorithm {
    /// The RS256 signing algorithm
    pub const RS256: Algorithm = Self::Signing(jws::Algorithm::RS256);
    /// The RS384 signing algorithm
    pub const RS384: Algorithm = Self::Signing(jws::Algorithm::RS384);
    /// The RS512 signing algorithm
    pub const RS512: Algorithm = Self::Signing(jws::Algorithm::RS512);
    /// The PS256 signing algorithm
    pub const PS256: Algorithm = Self::Signing(jws::Algorithm::PS256);
    /// The PS384 signing algorithm
    pub const PS384: Algorithm = Self::Signing(jws::Algorithm::PS384);
    /// The PS512 signing algorithm
    pub const PS512: Algorithm = Self::Signing(jws::Algorithm::PS512);
}

#[cfg(feature = "ec")]
#[cfg_attr(docsrs, doc(cfg(feature = "ec")))]
impl Algorithm {
    /// The ES256 signing algorithm
    pub const ES256: Algorithm = Self::Signing(jws::Algorithm::ES256);
    /// The ES384 signing algorithm
    pub const ES384: Algorithm = Self::Signing(jws::Algorithm::ES384);
    /// The ES512 signing algorithm
    pub const ES512: Algorithm = Self::Signing(jws::Algorithm::ES512);
}

impl TryFrom<&'_ str> for Algorithm {
    type Error = error::UnknownAlgorithm;

    #[inline]
    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
        match value {
            #[cfg(feature = "ec")]
            "ES256" => Ok(Algorithm::ES256),
            #[cfg(feature = "ec")]
            "ES384" => Ok(Algorithm::ES384),
            #[cfg(feature = "ec")]
            "ES512" => Ok(Algorithm::ES512),
            #[cfg(feature = "rsa")]
            "RS256" => Ok(Algorithm::RS256),
            #[cfg(feature = "rsa")]
            "RS384" => Ok(Algorithm::RS384),
            #[cfg(feature = "rsa")]
            "RS512" => Ok(Algorithm::RS512),
            #[cfg(feature = "rsa")]
            "PS256" => Ok(Algorithm::PS256),
            #[cfg(feature = "rsa")]
            "PS384" => Ok(Algorithm::PS384),
            #[cfg(feature = "rsa")]
            "PS512" => Ok(Algorithm::PS512),
            #[cfg(feature = "hmac")]
            "HS256" => Ok(Algorithm::HS256),
            #[cfg(feature = "hmac")]
            "HS384" => Ok(Algorithm::HS384),
            #[cfg(feature = "hmac")]
            "HS512" => Ok(Algorithm::HS512),
            _ => Err(error::unknown_algorithm(value.to_string())),
        }
    }
}

impl TryFrom<String> for Algorithm {
    type Error = error::UnknownAlgorithm;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        Self::try_from(value.as_str())
    }
}

impl FromStr for Algorithm {
    type Err = error::UnknownAlgorithm;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::try_from(s)
    }
}

impl<T> From<T> for Algorithm
where
    jws::Algorithm: From<T>,
{
    #[inline]
    fn from(alg: T) -> Self {
        Self::Signing(jws::Algorithm::from(alg))
    }
}

impl TryFrom<Algorithm> for jws::Algorithm {
    type Error = error::IncompatibleAlgorithm;

    #[inline]
    fn try_from(alg: Algorithm) -> Result<Self, Self::Error> {
        match alg {
            Algorithm::Signing(alg) => Ok(alg),

            #[allow(unreachable_patterns)]
            _ => Err(error::incompatible_algorithm(alg)),
        }
    }
}