sasl/server/
mod.rs

1use crate::common::Identity;
2use crate::secret::Secret;
3use alloc::vec::Vec;
4use core::error::Error;
5use core::fmt;
6
7#[cfg(feature = "scram")]
8use crate::common::scram::DeriveError;
9
10#[macro_export]
11macro_rules! impl_validator_using_provider {
12    ( $validator:ty, $secret:ty ) => {
13        impl $crate::server::Validator<$secret> for $validator {
14            fn validate(
15                &self,
16                identity: &$crate::common::Identity,
17                value: &$secret,
18            ) -> Result<(), $crate::server::ValidatorError> {
19                if $crate::server::Provider::<$secret>::provide(self, identity).is_ok() {
20                    Ok(())
21                } else {
22                    Err($crate::server::ValidatorError::AuthenticationFailed)
23                }
24            }
25        }
26    };
27}
28
29pub trait Provider<S: Secret>: Validator<S> {
30    fn provide(&self, identity: &Identity) -> Result<S, ProviderError>;
31}
32
33pub trait Validator<S: Secret> {
34    fn validate(&self, identity: &Identity, value: &S) -> Result<(), ValidatorError>;
35}
36
37#[derive(Debug, PartialEq)]
38pub enum ProviderError {
39    AuthenticationFailed,
40    #[cfg(feature = "scram")]
41    DeriveError(DeriveError),
42}
43
44#[derive(Debug, PartialEq)]
45pub enum ValidatorError {
46    AuthenticationFailed,
47    ProviderError(ProviderError),
48}
49
50#[derive(Debug, PartialEq)]
51pub enum MechanismError {
52    NoUsernameSpecified,
53    ErrorDecodingUsername,
54    NoPasswordSpecified,
55    ErrorDecodingPassword,
56    ValidatorError(ValidatorError),
57
58    FailedToDecodeMessage,
59    ChannelBindingNotSupported,
60    ChannelBindingIsSupported,
61    ChannelBindingMechanismIncorrect,
62    CannotDecodeInitialMessage,
63    NoUsername,
64    NoNonce,
65    FailedToGenerateNonce,
66    ProviderError(ProviderError),
67
68    CannotDecodeResponse,
69    #[cfg(feature = "scram")]
70    InvalidKeyLength(hmac::digest::InvalidLength),
71    #[cfg(any(feature = "scram", feature = "anonymous"))]
72    RandomFailure(getrandom::Error),
73    NoProof,
74    CannotDecodeProof,
75    AuthenticationFailed,
76    SaslSessionAlreadyOver,
77}
78
79#[cfg(feature = "scram")]
80impl From<DeriveError> for ProviderError {
81    fn from(err: DeriveError) -> ProviderError {
82        ProviderError::DeriveError(err)
83    }
84}
85
86impl From<ProviderError> for ValidatorError {
87    fn from(err: ProviderError) -> ValidatorError {
88        ValidatorError::ProviderError(err)
89    }
90}
91
92impl From<ProviderError> for MechanismError {
93    fn from(err: ProviderError) -> MechanismError {
94        MechanismError::ProviderError(err)
95    }
96}
97
98impl From<ValidatorError> for MechanismError {
99    fn from(err: ValidatorError) -> MechanismError {
100        MechanismError::ValidatorError(err)
101    }
102}
103
104#[cfg(feature = "scram")]
105impl From<hmac::digest::InvalidLength> for MechanismError {
106    fn from(err: hmac::digest::InvalidLength) -> MechanismError {
107        MechanismError::InvalidKeyLength(err)
108    }
109}
110
111#[cfg(any(feature = "scram", feature = "anonymous"))]
112impl From<getrandom::Error> for MechanismError {
113    fn from(err: getrandom::Error) -> MechanismError {
114        MechanismError::RandomFailure(err)
115    }
116}
117
118impl fmt::Display for ProviderError {
119    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
120        write!(fmt, "provider error")
121    }
122}
123
124impl fmt::Display for ValidatorError {
125    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
126        write!(fmt, "validator error")
127    }
128}
129
130impl fmt::Display for MechanismError {
131    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
132        match self {
133            MechanismError::NoUsernameSpecified => write!(fmt, "no username specified"),
134            MechanismError::ErrorDecodingUsername => write!(fmt, "error decoding username"),
135            MechanismError::NoPasswordSpecified => write!(fmt, "no password specified"),
136            MechanismError::ErrorDecodingPassword => write!(fmt, "error decoding password"),
137            MechanismError::ValidatorError(err) => write!(fmt, "validator error: {}", err),
138
139            MechanismError::FailedToDecodeMessage => write!(fmt, "failed to decode message"),
140            MechanismError::ChannelBindingNotSupported => {
141                write!(fmt, "channel binding not supported")
142            }
143            MechanismError::ChannelBindingIsSupported => {
144                write!(fmt, "channel binding is supported")
145            }
146            MechanismError::ChannelBindingMechanismIncorrect => {
147                write!(fmt, "channel binding mechanism is incorrect")
148            }
149            MechanismError::CannotDecodeInitialMessage => {
150                write!(fmt, "can’t decode initial message")
151            }
152            MechanismError::NoUsername => write!(fmt, "no username"),
153            MechanismError::NoNonce => write!(fmt, "no nonce"),
154            MechanismError::FailedToGenerateNonce => write!(fmt, "failed to generate nonce"),
155            MechanismError::ProviderError(err) => write!(fmt, "provider error: {}", err),
156
157            MechanismError::CannotDecodeResponse => write!(fmt, "can’t decode response"),
158            #[cfg(feature = "scram")]
159            MechanismError::InvalidKeyLength(err) => write!(fmt, "invalid key length: {}", err),
160            #[cfg(any(feature = "scram", feature = "anonymous"))]
161            MechanismError::RandomFailure(err) => {
162                write!(fmt, "failure to get random data: {}", err)
163            }
164            MechanismError::NoProof => write!(fmt, "no proof"),
165            MechanismError::CannotDecodeProof => write!(fmt, "can’t decode proof"),
166            MechanismError::AuthenticationFailed => write!(fmt, "authentication failed"),
167            MechanismError::SaslSessionAlreadyOver => write!(fmt, "SASL session already over"),
168        }
169    }
170}
171
172impl Error for ProviderError {}
173
174impl Error for ValidatorError {}
175
176impl Error for MechanismError {
177    fn source(&self) -> Option<&(dyn Error + 'static)> {
178        match self {
179            MechanismError::ValidatorError(err) => Some(err),
180            MechanismError::ProviderError(err) => Some(err),
181            // TODO: figure out how to enable the std feature on this crate.
182            //MechanismError::InvalidKeyLength(err) => Some(err),
183            _ => None,
184        }
185    }
186}
187
188pub trait Mechanism {
189    fn name(&self) -> &str;
190    fn respond(&mut self, payload: &[u8]) -> Result<Response, MechanismError>;
191}
192
193#[derive(Debug, Clone, PartialEq, Eq)]
194pub enum Response {
195    Success(Identity, Vec<u8>),
196    Proceed(Vec<u8>),
197}
198
199pub mod mechanisms;
sasl/server/mod.rs

sasl/server/
mod.rs
