use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::time::{Duration, Instant};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Capability {
Gpu,
Cpu,
Memory,
Disk,
Network,
Motherboard,
Power,
Fan,
Process,
Connections,
Services,
SystemInfo,
BootConfig,
Drivers,
History,
Events,
Context,
FanControl,
ProcessControl,
GpuControl,
PowerControl,
Admin,
}
impl Capability {
pub fn is_read_only(&self) -> bool {
matches!(
self,
Capability::Gpu
| Capability::Cpu
| Capability::Memory
| Capability::Disk
| Capability::Network
| Capability::Motherboard
| Capability::Power
| Capability::Fan
| Capability::Process
| Capability::Connections
| Capability::Services
| Capability::SystemInfo
| Capability::BootConfig
| Capability::Drivers
| Capability::History
| Capability::Events
| Capability::Context
)
}
pub fn is_control(&self) -> bool {
matches!(
self,
Capability::FanControl
| Capability::ProcessControl
| Capability::GpuControl
| Capability::PowerControl
)
}
pub fn all() -> Vec<Capability> {
vec![
Capability::Gpu,
Capability::Cpu,
Capability::Memory,
Capability::Disk,
Capability::Network,
Capability::Motherboard,
Capability::Power,
Capability::Fan,
Capability::Process,
Capability::Connections,
Capability::Services,
Capability::SystemInfo,
Capability::BootConfig,
Capability::Drivers,
Capability::History,
Capability::Events,
Capability::Context,
Capability::FanControl,
Capability::ProcessControl,
Capability::GpuControl,
Capability::PowerControl,
Capability::Admin,
]
}
pub fn read_only_set() -> HashSet<Capability> {
Capability::all()
.into_iter()
.filter(|c| c.is_read_only())
.collect()
}
}
impl std::fmt::Display for Capability {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let name = match self {
Capability::Gpu => "gpu",
Capability::Cpu => "cpu",
Capability::Memory => "memory",
Capability::Disk => "disk",
Capability::Network => "network",
Capability::Motherboard => "motherboard",
Capability::Power => "power",
Capability::Fan => "fan",
Capability::Process => "process",
Capability::Connections => "connections",
Capability::Services => "services",
Capability::SystemInfo => "system_info",
Capability::BootConfig => "boot_config",
Capability::Drivers => "drivers",
Capability::History => "history",
Capability::Events => "events",
Capability::Context => "context",
Capability::FanControl => "fan_control",
Capability::ProcessControl => "process_control",
Capability::GpuControl => "gpu_control",
Capability::PowerControl => "power_control",
Capability::Admin => "admin",
};
write!(f, "{}", name)
}
}
impl std::str::FromStr for Capability {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"gpu" => Ok(Capability::Gpu),
"cpu" => Ok(Capability::Cpu),
"memory" => Ok(Capability::Memory),
"disk" => Ok(Capability::Disk),
"network" => Ok(Capability::Network),
"motherboard" => Ok(Capability::Motherboard),
"power" => Ok(Capability::Power),
"fan" => Ok(Capability::Fan),
"process" => Ok(Capability::Process),
"connections" => Ok(Capability::Connections),
"services" => Ok(Capability::Services),
"system_info" | "systeminfo" => Ok(Capability::SystemInfo),
"boot_config" | "bootconfig" => Ok(Capability::BootConfig),
"drivers" => Ok(Capability::Drivers),
"history" => Ok(Capability::History),
"events" => Ok(Capability::Events),
"context" => Ok(Capability::Context),
"fan_control" | "fancontrol" => Ok(Capability::FanControl),
"process_control" | "processcontrol" => Ok(Capability::ProcessControl),
"gpu_control" | "gpucontrol" => Ok(Capability::GpuControl),
"power_control" | "powercontrol" => Ok(Capability::PowerControl),
"admin" => Ok(Capability::Admin),
"*" | "all" => Ok(Capability::Admin), _ => Err(format!("Unknown capability: {}", s)),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Default)]
pub enum Scope {
#[default]
Read,
Write,
All,
Resource(String),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Permission {
pub capability: Capability,
pub scope: Scope,
pub resource: Option<String>,
}
impl Permission {
pub fn read(capability: Capability) -> Self {
Self {
capability,
scope: Scope::Read,
resource: None,
}
}
pub fn full(capability: Capability) -> Self {
Self {
capability,
scope: Scope::All,
resource: None,
}
}
pub fn resource(capability: Capability, resource: impl Into<String>) -> Self {
let resource_str = resource.into();
Self {
capability,
scope: Scope::Resource(resource_str.clone()),
resource: Some(resource_str),
}
}
pub fn parse(s: &str) -> Result<Self, String> {
let parts: Vec<&str> = s.split(':').collect();
match parts.len() {
1 => {
let cap = parts[0].parse()?;
Ok(Permission::read(cap))
}
2 => {
let cap = parts[0].parse()?;
let scope = match parts[1].to_lowercase().as_str() {
"read" | "r" => Scope::Read,
"write" | "w" => Scope::Write,
"all" | "*" => Scope::All,
resource => Scope::Resource(resource.to_string()),
};
Ok(Permission {
capability: cap,
scope,
resource: None,
})
}
_ => Err(format!("Invalid permission format: {}", s)),
}
}
}
impl std::fmt::Display for Permission {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.scope {
Scope::Read => write!(f, "{}:read", self.capability),
Scope::Write => write!(f, "{}:write", self.capability),
Scope::All => write!(f, "{}:*", self.capability),
Scope::Resource(r) => write!(f, "{}:{}", self.capability, r),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLimit {
pub max_requests: u32,
pub period_secs: u64,
}
impl RateLimit {
pub fn period(&self) -> Duration {
Duration::from_secs(self.period_secs)
}
}
impl Default for RateLimit {
fn default() -> Self {
Self {
max_requests: 100,
period_secs: 60, }
}
}
#[derive(Clone, Serialize, Deserialize)]
pub struct ApiKey {
pub name: String,
pub key: String,
#[serde(default)]
pub permissions: Vec<Permission>,
#[serde(default)]
pub capabilities: Vec<String>,
pub rate_limit: Option<RateLimit>,
#[serde(default = "default_true")]
pub enabled: bool,
pub expires_at: Option<String>,
pub description: Option<String>,
}
fn default_true() -> bool {
true
}
impl std::fmt::Debug for ApiKey {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ApiKey")
.field("name", &self.name)
.field("key", &format_args!("<redacted {} bytes>", self.key.len()))
.field("permissions", &self.permissions)
.field("capabilities", &self.capabilities)
.field("rate_limit", &self.rate_limit)
.field("enabled", &self.enabled)
.field("expires_at", &self.expires_at)
.field("description", &self.description)
.finish()
}
}
impl ApiKey {
pub fn new(
name: impl Into<String>,
key: impl Into<String>,
permissions: Vec<Permission>,
) -> Self {
Self {
name: name.into(),
key: key.into(),
permissions,
capabilities: Vec::new(),
rate_limit: None,
enabled: true,
expires_at: None,
description: None,
}
}
pub fn read_only(name: impl Into<String>, key: impl Into<String>) -> Self {
let permissions: Vec<Permission> = Capability::read_only_set()
.into_iter()
.map(Permission::read)
.collect();
Self::new(name, key, permissions)
}
pub fn admin(name: impl Into<String>, key: impl Into<String>) -> Self {
let permissions = vec![Permission::full(Capability::Admin)];
Self::new(name, key, permissions)
}
pub fn has_permission(&self, capability: Capability, required_scope: &Scope) -> bool {
if self
.permissions
.iter()
.any(|p| p.capability == Capability::Admin)
{
return true;
}
self.permissions.iter().any(|p| {
p.capability == capability
&& match (&p.scope, required_scope) {
(Scope::All, _) => true,
(Scope::Write, Scope::Read) => true,
(Scope::Write, Scope::Write) => true,
(Scope::Read, Scope::Read) => true,
(Scope::Resource(granted), Scope::Resource(required)) => granted == required,
_ => false,
}
})
}
pub fn granted_capabilities(&self) -> HashSet<Capability> {
if self
.permissions
.iter()
.any(|p| p.capability == Capability::Admin)
{
return Capability::all().into_iter().collect();
}
self.permissions.iter().map(|p| p.capability).collect()
}
}
#[derive(Debug)]
pub struct RateLimiter {
requests: Vec<Instant>,
limit: RateLimit,
}
impl RateLimiter {
pub fn new(limit: RateLimit) -> Self {
Self {
requests: Vec::new(),
limit,
}
}
pub fn check(&mut self) -> bool {
let now = Instant::now();
let window_start = now - self.limit.period();
self.requests.retain(|&t| t > window_start);
if self.requests.len() < self.limit.max_requests as usize {
self.requests.push(now);
true
} else {
false
}
}
pub fn remaining(&self) -> u32 {
let now = Instant::now();
let window_start = now - self.limit.period();
let active_requests = self.requests.iter().filter(|&&t| t > window_start).count();
self.limit
.max_requests
.saturating_sub(active_requests as u32)
}
pub fn retry_after(&self) -> Option<Duration> {
if self.requests.len() < self.limit.max_requests as usize {
return None;
}
let oldest = self.requests.first()?;
let elapsed = oldest.elapsed();
if elapsed < self.limit.period() {
Some(self.limit.period() - elapsed)
} else {
None
}
}
}
#[derive(Debug)]
pub struct PermissionChecker {
keys: HashMap<String, ApiKey>,
rate_limiters: HashMap<String, RateLimiter>,
default_rate_limit: RateLimit,
}
impl PermissionChecker {
pub fn new(keys: Vec<ApiKey>) -> Self {
let key_map: HashMap<String, ApiKey> =
keys.into_iter().map(|k| (k.key.clone(), k)).collect();
Self {
keys: key_map,
rate_limiters: HashMap::new(),
default_rate_limit: RateLimit::default(),
}
}
pub fn allow_all() -> Self {
Self {
keys: HashMap::new(),
rate_limiters: HashMap::new(),
default_rate_limit: RateLimit {
max_requests: u32::MAX,
period_secs: 1,
},
}
}
pub fn get_key(&self, key: &str) -> Option<&ApiKey> {
self.keys.get(key)
}
pub fn check(
&mut self,
api_key: &str,
capability: Capability,
scope: &Scope,
) -> Result<(), PermissionError> {
let key = self.keys.get(api_key).ok_or(PermissionError::InvalidKey)?;
if !key.enabled {
return Err(PermissionError::KeyDisabled);
}
let rate_limit = key
.rate_limit
.clone()
.unwrap_or_else(|| self.default_rate_limit.clone());
let limiter = self
.rate_limiters
.entry(api_key.to_string())
.or_insert_with(|| RateLimiter::new(rate_limit));
if !limiter.check() {
return Err(PermissionError::RateLimited {
retry_after: limiter.retry_after(),
});
}
if !key.has_permission(capability, scope) {
return Err(PermissionError::AccessDenied {
capability,
scope: scope.clone(),
});
}
Ok(())
}
pub fn capabilities_for_key(&self, api_key: &str) -> HashSet<Capability> {
self.keys
.get(api_key)
.map(|k| k.granted_capabilities())
.unwrap_or_default()
}
pub fn add_key(&mut self, key: ApiKey) {
self.keys.insert(key.key.clone(), key);
}
pub fn remove_key(&mut self, api_key: &str) {
self.keys.remove(api_key);
self.rate_limiters.remove(api_key);
}
pub fn rate_limit_status(&self, api_key: &str) -> Option<(u32, u32, u64)> {
let key = self.keys.get(api_key)?;
let rate_limit = key
.rate_limit
.clone()
.unwrap_or_else(|| self.default_rate_limit.clone());
let remaining = self
.rate_limiters
.get(api_key)
.map(|limiter| limiter.remaining())
.unwrap_or(rate_limit.max_requests);
let reset_at = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() + rate_limit.period_secs)
.unwrap_or(0);
Some((remaining, rate_limit.max_requests, reset_at))
}
}
#[derive(Debug, Clone)]
pub enum PermissionError {
InvalidKey,
KeyDisabled,
RateLimited { retry_after: Option<Duration> },
AccessDenied {
capability: Capability,
scope: Scope,
},
}
impl std::fmt::Display for PermissionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PermissionError::InvalidKey => write!(f, "Invalid API key"),
PermissionError::KeyDisabled => write!(f, "API key is disabled"),
PermissionError::RateLimited { retry_after } => {
if let Some(d) = retry_after {
write!(f, "Rate limited. Retry after {:?}", d)
} else {
write!(f, "Rate limited")
}
}
PermissionError::AccessDenied { capability, scope } => {
write!(f, "Access denied: {}:{:?}", capability, scope)
}
}
}
}
impl std::error::Error for PermissionError {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiConfig {
#[serde(default = "default_true")]
pub enabled: bool,
#[serde(default = "default_bind")]
pub bind: String,
#[serde(default = "default_port")]
pub port: u16,
#[serde(default = "default_true")]
pub require_auth: bool,
#[serde(default)]
pub allow_anonymous_read: bool,
#[serde(default)]
pub keys: Vec<ApiKey>,
#[serde(default)]
pub default_rate_limit: Option<RateLimit>,
#[serde(default = "default_true")]
pub enable_websocket: bool,
#[serde(default)]
pub enable_cors: bool,
#[serde(default)]
pub allowed_origins: Vec<String>,
}
fn default_bind() -> String {
"127.0.0.1".to_string()
}
fn default_port() -> u16 {
8787
}
impl Default for ApiConfig {
fn default() -> Self {
Self {
enabled: true,
bind: default_bind(),
port: default_port(),
require_auth: true,
allow_anonymous_read: false,
keys: Vec::new(),
default_rate_limit: None,
enable_websocket: true,
enable_cors: false,
allowed_origins: Vec::new(),
}
}
}
impl ApiConfig {
pub fn load_from_file(path: &std::path::Path) -> Result<Self, Box<dyn std::error::Error>> {
let contents = std::fs::read_to_string(path)?;
let config: Self = toml::from_str(&contents)?;
Ok(config)
}
pub fn save_to_file(&self, path: &std::path::Path) -> Result<(), Box<dyn std::error::Error>> {
let contents = toml::to_string_pretty(self)?;
std::fs::write(path, contents)?;
Ok(())
}
pub fn generate_key() -> String {
use std::time::{SystemTime, UNIX_EPOCH};
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
format!("sk-ironmon-{:x}", timestamp)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_permission_parse() {
let p = Permission::parse("gpu:read").unwrap();
assert_eq!(p.capability, Capability::Gpu);
assert_eq!(p.scope, Scope::Read);
let p = Permission::parse("process").unwrap();
assert_eq!(p.capability, Capability::Process);
assert_eq!(p.scope, Scope::Read);
let p = Permission::parse("admin:*").unwrap();
assert_eq!(p.capability, Capability::Admin);
assert_eq!(p.scope, Scope::All);
}
#[test]
fn api_key_debug_never_prints_the_secret() {
let key = ApiKey::read_only("ci", "sk-very-secret-value");
let shown = format!("{key:?}");
assert!(!shown.contains("sk-very-secret-value"), "{shown}");
assert!(shown.contains("<redacted 20 bytes>"), "{shown}");
assert!(shown.contains("ci"), "name stays visible: {shown}");
let list = format!("{:?}", vec![key]);
assert!(!list.contains("sk-very-secret-value"), "{list}");
}
#[test]
fn test_api_key_permissions() {
let key = ApiKey::read_only("test", "sk-test");
assert!(key.has_permission(Capability::Gpu, &Scope::Read));
assert!(!key.has_permission(Capability::GpuControl, &Scope::Write));
let admin = ApiKey::admin("admin", "sk-admin");
assert!(admin.has_permission(Capability::GpuControl, &Scope::Write));
assert!(admin.has_permission(Capability::Admin, &Scope::All));
}
#[test]
fn test_rate_limiter() {
let mut limiter = RateLimiter::new(RateLimit {
max_requests: 3,
period_secs: 60,
});
assert!(limiter.check());
assert!(limiter.check());
assert!(limiter.check());
assert!(!limiter.check()); assert_eq!(limiter.remaining(), 0);
}
#[test]
fn test_rate_limit_status_unknown_key() {
let checker = PermissionChecker::new(vec![]);
assert!(checker.rate_limit_status("nonexistent").is_none());
}
#[test]
fn test_rate_limit_status_known_key() {
let key = ApiKey::read_only("test", "sk-test");
let checker = PermissionChecker::new(vec![key]);
let status = checker.rate_limit_status("sk-test");
assert!(status.is_some());
let (remaining, limit, reset_at) = status.unwrap();
assert_eq!(limit, 100);
assert_eq!(remaining, 100); assert!(reset_at > 0);
}
#[test]
fn test_rate_limit_status_after_requests() {
let key = ApiKey::new("test", "sk-test", vec![Permission::read(Capability::Gpu)]);
let mut checker = PermissionChecker::new(vec![key]);
let _ = checker.check("sk-test", Capability::Gpu, &Scope::Read);
let _ = checker.check("sk-test", Capability::Gpu, &Scope::Read);
let (remaining, limit, _) = checker.rate_limit_status("sk-test").unwrap();
assert_eq!(limit, 100);
assert_eq!(remaining, 98); }
#[test]
fn test_rate_limit_status_with_custom_limit() {
let mut key = ApiKey::read_only("test", "sk-test");
key.rate_limit = Some(RateLimit {
max_requests: 10,
period_secs: 30,
});
let checker = PermissionChecker::new(vec![key]);
let (remaining, limit, _) = checker.rate_limit_status("sk-test").unwrap();
assert_eq!(limit, 10);
assert_eq!(remaining, 10);
}
}