use crate::pki;
use std::{
net::{SocketAddr, TcpListener},
path::{Path, PathBuf},
sync::Arc,
thread,
};
mod connection;
mod registry;
#[cfg(test)]
mod tests;
pub use registry::{EnrollIssueError, EnrollRegistry};
pub const TOKEN_TTL_SECS: u64 = 180;
const MAX_PENDING: usize = 64;
fn build_enroll_server_config(
ca_path: &Path,
cert_path: &Path,
key_path: &Path,
) -> Result<Arc<rustls::ServerConfig>, String> {
let mut chain = indicatrix_net::tls::load_certs(cert_path)
.map_err(|e| format!("--cert {}: {e}", cert_path.display()))?;
let ca_certs = indicatrix_net::tls::load_certs(ca_path)
.map_err(|e| format!("--ca {}: {e}", ca_path.display()))?;
chain.extend(ca_certs);
let key = indicatrix_net::tls::load_private_key(key_path)
.map_err(|e| format!("--key {}: {e}", key_path.display()))?;
let config = rustls::ServerConfig::builder_with_protocol_versions(&[&rustls::version::TLS13])
.with_no_client_auth()
.with_single_cert(chain, key)
.map_err(|e| format!("failed to build the enrollment TLS config: {e}"))?;
Ok(Arc::new(config))
}
pub struct EnrollConfig {
pub bind_addr: SocketAddr,
pub pki_dir: PathBuf,
pub allowlist_path: Option<PathBuf>,
pub tls_config: Arc<rustls::ServerConfig>,
}
impl EnrollConfig {
pub fn build(
bind_addr: SocketAddr,
enroll_bind: Option<&str>,
allow_remote: bool,
ca_path: &Path,
cert_path: &Path,
key_path: &Path,
allowlist_path: Option<PathBuf>,
) -> Result<Self, String> {
let enroll_addr_str = enroll_bind.map_or_else(
|| format!("{}:{}", bind_addr.ip(), bind_addr.port().saturating_add(1)),
str::to_string,
);
let enroll_bind_addr: SocketAddr = enroll_addr_str
.parse()
.map_err(|e| format!("invalid --enroll-bind address {enroll_addr_str:?}: {e}"))?;
if !enroll_bind_addr.ip().is_loopback() && !allow_remote {
return Err(format!(
"refusing to bind non-loopback enrollment address {enroll_bind_addr} without --allow-remote -- \
exposing the enrollment listener beyond localhost must be explicit, same as --bind (see --help)"
));
}
let tls_config = build_enroll_server_config(ca_path, cert_path, key_path)?;
let pki_dir = ca_path
.parent()
.filter(|p| !p.as_os_str().is_empty())
.unwrap_or_else(|| Path::new("."))
.to_path_buf();
Ok(Self {
bind_addr: enroll_bind_addr,
pki_dir,
allowlist_path,
tls_config,
})
}
}
pub fn maybe_start_from_serve_args(
args: &crate::cli::ServeArgs,
bind_addr: SocketAddr,
) -> Result<(), String> {
if args.insecure_no_tls || args.no_enroll {
return Ok(());
}
let (Some(ca_path), Some(cert_path), Some(key_path)) = (&args.ca, &args.cert, &args.key) else {
return Ok(()); };
let allowlist_path = if args.trust_any_client_cert {
None
} else {
Some(
args.allowlist
.clone()
.unwrap_or_else(|| pki::default_allowlist_path(ca_path)),
)
};
let config = EnrollConfig::build(
bind_addr,
args.enroll_bind.as_deref(),
args.allow_remote,
ca_path,
cert_path,
key_path,
allowlist_path,
)?;
spawn_enroll_listener(config).map(|_bound_addr| ())
}
pub fn spawn_enroll_listener(config: EnrollConfig) -> Result<SocketAddr, String> {
let listener = TcpListener::bind(config.bind_addr).map_err(|e| {
format!(
"failed to bind enrollment listener {}: {e}",
config.bind_addr
)
})?;
let bound_addr = listener
.local_addr()
.map_err(|e| format!("enrollment listener bound but local_addr() failed: {e}"))?;
tracing::info!(
"indicatrix-worker serve: enrollment listener on {bound_addr} (token TTL {TOKEN_TTL_SECS}s; `indicatrix-worker cert \
issue-token` to mint one)"
);
let registry = Arc::new(EnrollRegistry::new());
let tls_config = config.tls_config;
let pki_dir = config.pki_dir;
let allowlist_path = config.allowlist_path;
thread::spawn(move || {
for incoming in listener.incoming() {
match incoming {
Ok(stream) => {
let peer = stream.peer_addr().ok();
let tls_config = Arc::clone(&tls_config);
let registry = Arc::clone(®istry);
let pki_dir = pki_dir.clone();
let allowlist_path = allowlist_path.clone();
thread::spawn(move || {
let Some(tls_stream) =
connection::accept_enroll_tls(stream, &tls_config, peer)
else {
return;
};
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
connection::handle_enroll_connection(
tls_stream,
®istry,
&pki_dir,
allowlist_path.as_deref(),
peer,
)
}));
match result {
Ok(Ok(())) => {}
Ok(Err(e)) => {
tracing::warn!(
"enrollment connection {peer:?} ended with an error: {e}"
);
}
Err(_) => {
tracing::warn!(
"enrollment connection {peer:?} panicked and was dropped"
);
}
}
});
}
Err(e) => tracing::warn!("enrollment accept error: {e}"),
}
}
});
Ok(bound_addr)
}