use anyhow::Context;
use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};
pub fn disabled_by_env() -> bool {
std::env::var("LLMMAN_AUTH").ok().is_some_and(|v| {
matches!(
v.trim().to_ascii_lowercase().as_str(),
"0" | "false" | "no" | "off"
)
})
}
pub fn server_keys() -> Vec<String> {
crate::config::auth_api_keys()
}
pub fn client_key() -> Option<String> {
std::env::var("LLMMAN_API_KEY")
.ok()
.map(|k| k.trim().to_string())
.filter(|k| !k.is_empty())
.or_else(|| (!disabled_by_env()).then(|| server_keys().into_iter().next())?)
}
pub fn peer_key() -> Option<String> {
crate::config::peer_api_key().or_else(client_key)
}
pub fn bearer(key: &str) -> anyhow::Result<HeaderValue> {
let mut value = HeaderValue::from_str(&format!("Bearer {key}"))
.context("API key is not a valid HTTP header value")?;
value.set_sensitive(true);
Ok(value)
}
pub fn client_headers() -> anyhow::Result<HeaderMap> {
static WARNED: std::sync::Once = std::sync::Once::new();
let mut headers = HeaderMap::new();
if let Some(key) = client_key() {
if !crate::daemon::connects_securely() {
WARNED.call_once(|| {
eprintln!(
"[llmman] warning: the API key for llmman serve goes to {} over plain http",
crate::daemon::server()
);
});
}
headers.insert(AUTHORIZATION, bearer(&key)?);
}
Ok(headers)
}
pub fn tls_ca() -> anyhow::Result<Vec<reqwest::Certificate>> {
let Some(path) = std::env::var_os("LLMMAN_TLS_CA").filter(|p| !p.is_empty()) else {
return Ok(Vec::new());
};
let pem = std::fs::read(&path)
.with_context(|| format!("LLMMAN_TLS_CA: read {}", path.to_string_lossy()))?;
reqwest::Certificate::from_pem_bundle(&pem)
.with_context(|| format!("LLMMAN_TLS_CA: parse {}", path.to_string_lossy()))
}
pub fn trusted_client() -> anyhow::Result<reqwest::ClientBuilder> {
let mut builder = reqwest::Client::builder();
for cert in tls_ca()? {
builder = builder.add_root_certificate(cert);
}
Ok(builder)
}
pub const WS_PROTOCOL_PREFIX: &str = "llmman.bearer.";
pub fn ws_protocol(key: &str) -> String {
use base64::Engine as _;
format!(
"{WS_PROTOCOL_PREFIX}{}",
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(key)
)
}
pub fn ws_protocol_key(protocol: &str) -> Option<String> {
use base64::Engine as _;
let encoded = protocol.trim().strip_prefix(WS_PROTOCOL_PREFIX)?;
let bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(encoded)
.ok()?;
String::from_utf8(bytes).ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_ws_protocol_round_trips_any_key() {
for key in ["abc", "sk-with/slashes+and=padding", "spaces are fine", ""] {
let protocol = ws_protocol(key);
assert!(protocol.starts_with(WS_PROTOCOL_PREFIX));
assert!(protocol
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"-_.".contains(&b)));
assert_eq!(ws_protocol_key(&protocol).as_deref(), Some(key));
}
assert_eq!(ws_protocol_key("chat"), None);
assert_eq!(ws_protocol_key("llmman.bearer.%%%"), None);
}
#[test]
fn a_bearer_header_is_sensitive() {
let value = bearer("k").unwrap();
assert!(value.is_sensitive());
assert_eq!(value.to_str().unwrap(), "Bearer k");
assert!(bearer("line\nbreak").is_err());
}
}