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)
}
fn read_tls_ca<T>(parse: impl FnOnce(&[u8]) -> anyhow::Result<Vec<T>>) -> anyhow::Result<Vec<T>> {
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()))?;
parse(&pem).with_context(|| format!("LLMMAN_TLS_CA: parse {}", path.to_string_lossy()))
}
pub fn tls_ca() -> anyhow::Result<Vec<reqwest::Certificate>> {
read_tls_ca(|pem| Ok(reqwest::Certificate::from_pem_bundle(pem)?))
}
pub fn tls_ca_der() -> anyhow::Result<Vec<rustls::pki_types::CertificateDer<'static>>> {
use rustls::pki_types::{pem::PemObject, CertificateDer};
read_tls_ca(|pem| Ok(CertificateDer::pem_slice_iter(pem).collect::<Result<_, _>>()?))
}
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());
}
}