use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::SaslMechanism;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AuthMethod {
Anonymous,
SaslPlain,
SaslScramSha256,
SaslScramSha512,
SaslOAuthBearer,
SaslGssapi,
MTls,
}
impl AuthMethod {
#[must_use]
pub fn from_sasl(m: SaslMechanism) -> Self {
match m {
SaslMechanism::Plain => Self::SaslPlain,
SaslMechanism::ScramSha256 => Self::SaslScramSha256,
SaslMechanism::ScramSha512 => Self::SaslScramSha512,
SaslMechanism::OAuthBearer => Self::SaslOAuthBearer,
SaslMechanism::Gssapi => Self::SaslGssapi,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Principal {
pub name: String,
pub auth_method: AuthMethod,
pub groups: Vec<String>,
}
impl Principal {
#[must_use]
pub fn to_kafka(&self) -> KafkaPrincipal {
KafkaPrincipal {
principal_type: "User".to_string(),
name: self.name.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct KafkaPrincipal {
pub principal_type: String,
pub name: String,
}
impl std::fmt::Display for KafkaPrincipal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}:{}", self.principal_type, self.name)
}
}
impl std::str::FromStr for KafkaPrincipal {
type Err = String;
fn from_str(s: &str) -> Result<Self, String> {
let (pt, n) = s
.split_once(':')
.ok_or_else(|| format!("invalid principal {s:?}"))?;
Ok(Self {
principal_type: pt.into(),
name: n.into(),
})
}
}
#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum AuthError {
#[error("unknown user")]
UnknownUser,
#[error("bad password")]
BadPassword,
#[error("bad proof")]
BadProof,
#[error("malformed message")]
MalformedMessage,
#[error("unsupported mechanism")]
UnsupportedMechanism,
#[error("authorization id differs from the authenticating user")]
AuthorizationIdMismatch,
#[error("invalid token")]
InvalidToken,
#[error("oauthbearer introspection transport: {0}")]
IntrospectionTransport(String),
#[error("insufficient scope: requires {required_scope:?}")]
InsufficientScope { required_scope: Vec<String> },
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn from_sasl_mapping() {
for (mechanism, want) in [
(SaslMechanism::Plain, AuthMethod::SaslPlain),
(SaslMechanism::ScramSha256, AuthMethod::SaslScramSha256),
(SaslMechanism::ScramSha512, AuthMethod::SaslScramSha512),
(SaslMechanism::OAuthBearer, AuthMethod::SaslOAuthBearer),
(SaslMechanism::Gssapi, AuthMethod::SaslGssapi),
] {
assert2::assert!(AuthMethod::from_sasl(mechanism) == want);
}
}
#[test]
fn principal_display_is_type_colon_name() {
let p = KafkaPrincipal {
principal_type: "User".into(),
name: "alice".into(),
};
assert2::assert!(p.to_string() == "User:alice");
assert2::assert!("User:alice".parse::<KafkaPrincipal>().unwrap() == p);
}
}