#![forbid(unsafe_code)]
pub mod acceptor;
pub mod client;
pub mod config;
pub mod crypto;
pub mod der;
pub mod fast;
pub mod gss;
pub mod keys;
pub mod kkdcp;
pub mod kpasswd;
pub mod messages;
pub mod rc4;
pub mod rfc8009;
pub mod spnego;
pub mod types;
pub use crypto::*;
pub use keys::{Enctype, KerberosKey, KeyError};
#[non_exhaustive]
#[derive(Debug)]
pub enum KerbError {
Der(der::DerError),
Key(keys::KeyError),
Decrypt(crypto::DecryptError),
Rc4(rc4::Rc4Error),
Rfc8009(rfc8009::Rfc8009Error),
Gss(gss::GssError),
Spnego(spnego::SpnegoError),
Fast(fast::FastError),
Kkdcp(kkdcp::KkdcpError),
Kpasswd(kpasswd::KpasswdError),
}
impl std::fmt::Display for KerbError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
KerbError::Der(e) => write!(f, "DER: {e:?}"),
KerbError::Key(e) => write!(f, "key: {e:?}"),
KerbError::Decrypt(e) => write!(f, "decrypt: {e:?}"),
KerbError::Rc4(e) => write!(f, "rc4-hmac: {e:?}"),
KerbError::Rfc8009(e) => write!(f, "rfc8009: {e:?}"),
KerbError::Gss(e) => write!(f, "gss: {e:?}"),
KerbError::Spnego(e) => write!(f, "spnego: {e:?}"),
KerbError::Fast(e) => write!(f, "fast: {e:?}"),
KerbError::Kkdcp(e) => write!(f, "kkdcp: {e:?}"),
KerbError::Kpasswd(e) => write!(f, "kpasswd: {e:?}"),
}
}
}
impl std::error::Error for KerbError {}
macro_rules! from_impl {
($src:path, $variant:ident) => {
impl From<$src> for KerbError {
fn from(e: $src) -> Self {
KerbError::$variant(e)
}
}
};
}
from_impl!(der::DerError, Der);
from_impl!(keys::KeyError, Key);
from_impl!(crypto::DecryptError, Decrypt);
from_impl!(rc4::Rc4Error, Rc4);
from_impl!(rfc8009::Rfc8009Error, Rfc8009);
from_impl!(gss::GssError, Gss);
from_impl!(spnego::SpnegoError, Spnego);
from_impl!(fast::FastError, Fast);
from_impl!(kkdcp::KkdcpError, Kkdcp);
from_impl!(kpasswd::KpasswdError, Kpasswd);
#[cfg(test)]
mod kerb_error_tests {
use super::*;
#[test]
fn each_module_error_lifts_via_question_mark() {
fn _f() -> Result<(), KerbError> {
Err(der::DerError::Truncated)?
}
assert!(_f().is_err());
}
#[test]
fn display_has_variant_prefix() {
let e: KerbError = der::DerError::Truncated.into();
let s = format!("{e}");
assert!(s.starts_with("DER: "), "unexpected display: {s}");
}
#[test]
fn kerb_error_implements_error_trait() {
fn _accepts_error<E: std::error::Error>(_: E) {}
_accepts_error(KerbError::from(der::DerError::Truncated));
}
}