use crate::json_rpc::JsonRpcError;
use base64::Engine;
use hmac::{Hmac, Mac};
use rand::RngCore;
use sha2::Sha256;
#[derive(Debug, Clone, Default)]
pub struct AuthConfig {
pub token: Option<String>,
pub username: Option<String>,
pub password: Option<String>,
}
impl AuthConfig {
pub fn with_token(mut self, token: impl Into<String>) -> Self {
self.token = Some(token.into());
self
}
pub fn with_basic_auth(mut self, user: impl Into<String>, pass: impl Into<String>) -> Self {
self.username = Some(user.into());
let password = pass.into();
self.password = (!password.is_empty()).then_some(password);
self
}
pub fn has_token(&self) -> bool {
self.token.is_some()
}
pub fn has_basic(&self) -> bool {
self.username
.as_deref()
.is_some_and(|username| !username.is_empty())
}
pub fn verify_token(&self, provided: &str) -> bool {
match &self.token {
None => true,
Some(t) => constant_time_eq(t, provided),
}
}
pub fn verify_basic(&self, encoded: &str) -> bool {
let decoded = base64_decode(encoded).unwrap_or_default();
let Some((user, pass)) = decoded.split_once(':') else {
return false;
};
let username_matches = self
.username
.as_deref()
.is_some_and(|expected| constant_time_eq(expected, user));
let password_matches = match self.password.as_deref() {
Some(expected) if !expected.is_empty() => constant_time_eq(expected, pass),
None => true,
Some(_) => true,
};
username_matches && password_matches
}
pub fn verify_authorization(&self, header: Option<&str>) -> bool {
let Some(header) = header else {
return false;
};
let Some((scheme, encoded)) = header.trim().split_once(' ') else {
return false;
};
scheme.eq_ignore_ascii_case("Basic") && self.verify_basic(encoded.trim())
}
}
fn base64_decode(s: &str) -> Result<String, String> {
let bytes = base64::engine::general_purpose::STANDARD
.decode(s)
.map_err(|error| error.to_string())?;
String::from_utf8(bytes).map_err(|error| error.to_string())
}
fn constant_time_eq_bytes(a: &[u8], b: &[u8]) -> bool {
let mut diff = a.len() ^ b.len();
for i in 0..a.len().max(b.len()) {
diff |= usize::from(a.get(i).copied().unwrap_or(0) ^ b.get(i).copied().unwrap_or(0));
}
diff == 0
}
fn constant_time_eq(a: &str, b: &str) -> bool {
let a = a.as_bytes();
let b = b.as_bytes();
let mut diff = a.len() ^ b.len();
for i in 0..a.len().max(b.len()) {
let ai = *a.get(i).unwrap_or(&0u8);
let bi = *b.get(i).unwrap_or(&0u8);
diff |= usize::from(ai ^ bi);
}
diff == 0
}
type RpcHmac = Hmac<Sha256>;
pub struct RpcAuthMiddleware {
secret: String,
hmac_key: Option<Vec<u8>>,
expected: Option<Vec<u8>>,
}
impl RpcAuthMiddleware {
pub fn new(secret: &str) -> Self {
let (hmac_key, expected) = if secret.is_empty() {
(None, None)
} else {
let mut key = vec![0u8; 32];
rand::thread_rng().fill_bytes(&mut key);
let mut mac =
RpcHmac::new_from_slice(&key).expect("HMAC-SHA256 accepts keys of every length");
mac.update(secret.as_bytes());
(Some(key), Some(mac.finalize().into_bytes().to_vec()))
};
Self {
secret: secret.to_string(),
hmac_key,
expected,
}
}
pub fn validate(&self, token: Option<&str>) -> Result<(), JsonRpcError> {
if self.secret.is_empty() {
return Ok(());
}
match token {
Some(t) if self.verify_hmac(t) => Ok(()),
Some(_) => Err(JsonRpcError::Unauthorized("Invalid token".to_string())),
None => Err(JsonRpcError::Unauthorized(
"Token required (set rpc-secret)".to_string(),
)),
}
}
fn verify_hmac(&self, token: &str) -> bool {
let (Some(key), Some(expected)) = (&self.hmac_key, &self.expected) else {
return false;
};
let mut mac = RpcHmac::new_from_slice(key).expect("valid HMAC key");
mac.update(token.as_bytes());
constant_time_eq_bytes(expected, mac.finalize().into_bytes().as_ref())
}
pub fn is_auth_enabled(&self) -> bool {
!self.secret.is_empty()
}
#[allow(dead_code)] pub fn secret(&self) -> &str {
&self.secret
}
}
impl Default for RpcAuthMiddleware {
fn default() -> Self {
Self::new("")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_auth_config_default() {
let auth = AuthConfig::default();
assert!(!auth.has_token());
assert!(!auth.has_basic());
assert!(auth.verify_token(""));
}
#[test]
fn test_auth_config_token() {
let auth = AuthConfig::default().with_token("my-secret");
assert!(auth.has_token());
assert!(auth.verify_token("my-secret"));
assert!(!auth.verify_token("wrong"));
}
#[test]
fn test_constant_time_eq() {
assert!(constant_time_eq("", ""));
assert!(constant_time_eq("my-secret", "my-secret"));
assert!(constant_time_eq(
"rpc-secret-token-123",
"rpc-secret-token-123"
));
assert!(!constant_time_eq("secret", "secretX")); assert!(!constant_time_eq("aaaaaa", "aaaaba")); assert!(!constant_time_eq("baaaaa", "aaaaaa")); assert!(!constant_time_eq("abcdef", "fedcba"));
assert!(!constant_time_eq("abc", "abcd"));
assert!(!constant_time_eq("abcd", "abc"));
assert!(!constant_time_eq("", "x"));
assert!(!constant_time_eq("x", ""));
assert!(!constant_time_eq("my-secret", "my-secret-extra"));
}
#[test]
fn test_auth_config_token_constant_time() {
let auth = AuthConfig::default().with_token("s3cr3t-tok3n");
assert!(auth.verify_token("s3cr3t-tok3n"));
assert!(!auth.verify_token("s3cr3t-tok3m"));
assert!(!auth.verify_token("X3cr3t-tok3n"));
assert!(!auth.verify_token("s3cr3t"));
assert!(!auth.verify_token("s3cr3t-tok3n-extra"));
assert!(!auth.verify_token(""));
assert!(!auth.verify_token("not-the-token"));
}
#[test]
fn test_auth_config_basic() {
let auth = AuthConfig::default().with_basic_auth("admin", "pass123");
assert!(auth.has_basic());
let encoded = base64::engine::general_purpose::STANDARD.encode(b"admin:pass123");
assert!(auth.verify_basic(&encoded));
assert!(auth.verify_authorization(Some(&format!("Basic {encoded}"))));
assert!(auth.verify_authorization(Some(&format!("basic {encoded}"))));
assert!(
!auth.verify_basic(
base64::engine::general_purpose::STANDARD
.encode(b"admin:wrong")
.as_str()
)
);
assert!(!auth.verify_authorization(None));
assert!(!auth.verify_authorization(Some("Bearer token")));
}
#[test]
fn test_auth_config_username_only_basic_auth() {
let auth = AuthConfig {
username: Some("admin".into()),
password: None,
..AuthConfig::default()
};
let encoded = base64::engine::general_purpose::STANDARD.encode(b"admin:anything");
assert!(auth.has_basic());
assert!(auth.verify_basic(&encoded));
}
#[test]
fn test_auth_config_empty_password_matches_username_only_behavior() {
let auth = AuthConfig::default().with_basic_auth("admin", "");
assert!(auth.has_basic());
assert!(auth.password.is_none());
for credentials in ["admin:anything", "admin:"] {
let encoded = base64::engine::general_purpose::STANDARD.encode(credentials);
assert!(auth.verify_basic(&encoded), "credentials: {credentials}");
}
let explicit_empty = AuthConfig {
username: Some("admin".into()),
password: Some(String::new()),
..AuthConfig::default()
};
let encoded = base64::engine::general_purpose::STANDARD.encode("admin:anything");
assert!(explicit_empty.verify_basic(&encoded));
}
#[test]
fn test_auth_valid_token_passes() {
let middleware = RpcAuthMiddleware::new("my-secret-token");
assert!(middleware.validate(Some("my-secret-token")).is_ok());
}
#[test]
fn test_auth_wrong_token_rejected() {
let middleware = RpcAuthMiddleware::new("my-secret-token");
let result = middleware.validate(Some("wrong-token"));
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.code(), 1);
assert!(err.to_string().contains("Invalid token"));
}
#[test]
fn test_auth_token_constant_time_validate() {
let middleware = RpcAuthMiddleware::new("my-secret-token");
assert!(middleware.validate(Some("my-secret-token")).is_ok());
assert!(middleware.validate(Some("my-secret-tokem")).is_err());
assert!(middleware.validate(Some("nY-secret-token")).is_err());
assert!(middleware.validate(Some("my-secret")).is_err());
assert!(middleware.validate(Some("my-secret-token-extra")).is_err());
assert!(middleware.validate(Some("")).is_err());
let err = middleware.validate(None).unwrap_err();
assert!(err.to_string().contains("Token required"));
}
#[test]
fn test_auth_no_secret_configured_accepts_all() {
let middleware = RpcAuthMiddleware::new(""); assert!(middleware.validate(None).is_ok());
assert!(middleware.validate(Some("anything")).is_ok());
assert!(middleware.validate(Some("")).is_ok());
assert!(
!middleware.is_auth_enabled(),
"Auth should be disabled with empty secret"
);
}
#[test]
fn test_auth_token_required_when_secret_set() {
let middleware = RpcAuthMiddleware::new("secret123");
let result = middleware.validate(None);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.code(), 1);
assert!(err.to_string().contains("Token required"));
assert!(
middleware.is_auth_enabled(),
"Auth should be enabled with non-empty secret"
);
}
#[test]
fn test_auth_middleware_default() {
let middleware = RpcAuthMiddleware::default();
assert!(!middleware.is_auth_enabled());
assert!(middleware.validate(None).is_ok());
assert!(middleware.validate(Some("x")).is_ok());
}
#[test]
fn test_auth_middleware_secret_accessor() {
let middleware = RpcAuthMiddleware::new("test-secret");
assert_eq!(middleware.secret(), "test-secret");
}
}