use std::{io, net::SocketAddr, num::NonZeroUsize, path::PathBuf};
use clap::{Parser, Subcommand, ValueEnum};
#[derive(Parser)]
#[clap(
author,
version,
about = "TLS and HTTP/1/2/3 fingerprint analysis server",
arg_required_else_help = true
)]
#[command(args_conflicts_with_subcommands = true)]
pub(crate) struct AppArgs {
#[clap(subcommand)]
pub(crate) command: Command,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, ValueEnum)]
pub(crate) enum AcmeChallenge {
#[default]
#[value(name = "tls-alpn-01")]
TlsAlpn01,
#[value(name = "http-01")]
Http01,
}
#[derive(clap::Args, Default)]
pub(crate) struct AcmeArgs {
#[arg(
long,
value_name = "DOMAIN",
value_parser = clap::builder::NonEmptyStringValueParser::new(),
conflicts_with_all = ["tls_cert", "tls_key"]
)]
acme_domain: Vec<String>,
#[arg(
long,
value_name = "EMAIL",
value_parser = clap::builder::NonEmptyStringValueParser::new(),
requires = "acme_domain"
)]
acme_email: Vec<String>,
#[arg(long, value_enum, default_value_t, requires = "acme_domain")]
acme_challenge: AcmeChallenge,
#[arg(long, value_name = "ADDR", requires = "acme_domain")]
acme_http_bind: Option<SocketAddr>,
#[arg(long, requires = "acme_domain")]
acme_production: bool,
}
pub(crate) struct AcmeOptions {
pub(crate) domains: Vec<String>,
pub(crate) contacts: Vec<String>,
pub(crate) challenge: AcmeChallenge,
pub(crate) http_bind: Option<SocketAddr>,
pub(crate) production: bool,
}
pub(crate) enum TlsSource {
SelfSigned,
Files {
cert: PathBuf,
key: PathBuf,
},
Acme(AcmeOptions),
}
#[derive(clap::Args)]
pub(crate) struct ServerArgs {
#[arg(long, default_value = "info", env = "PINGLY_LOG")]
pub(crate) log: String,
#[arg(short, long, default_value = "0.0.0.0:8181")]
pub(crate) bind: SocketAddr,
#[arg(short, long, default_value = "1024")]
pub(crate) concurrent: NonZeroUsize,
#[arg(short, long, default_value = "0")]
pub(crate) keep_alive_timeout: u64,
#[arg(
short = 'C',
long,
requires = "tls_key",
conflicts_with = "acme_domain"
)]
pub(crate) tls_cert: Option<PathBuf>,
#[arg(
short = 'K',
long,
requires = "tls_cert",
conflicts_with = "acme_domain"
)]
pub(crate) tls_key: Option<PathBuf>,
#[command(flatten)]
pub(crate) acme: AcmeArgs,
#[cfg(target_os = "linux")]
#[arg(long, short = 'T')]
pub(crate) tcp_capture_packet: bool,
#[cfg(target_os = "linux")]
#[arg(long, short = 'I')]
pub(crate) tcp_capture_interface: Option<String>,
}
impl ServerArgs {
pub(crate) fn take_tls_source(&mut self) -> crate::Result<TlsSource> {
match (self.tls_cert.take(), self.tls_key.take()) {
(Some(cert), Some(key)) => Ok(TlsSource::Files { cert, key }),
(None, None) if self.acme.acme_domain.is_empty() => Ok(TlsSource::SelfSigned),
(None, None) => Ok(TlsSource::Acme(self.acme.take_options()?)),
_ => Err(io::Error::new(
io::ErrorKind::InvalidInput,
"TLS certificate and private key must be supplied together",
)
.into()),
}
}
#[cfg(target_os = "linux")]
pub(crate) fn requires_privileged_bind(&self) -> bool {
self.bind.port() < 1024
|| (self.acme.acme_challenge == AcmeChallenge::Http01
&& self
.acme
.acme_http_bind
.unwrap_or(AcmeArgs::DEFAULT_HTTP_BIND)
.port()
< 1024)
}
}
impl AcmeArgs {
const DEFAULT_HTTP_BIND: SocketAddr =
SocketAddr::new(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED), 80);
fn take_options(&mut self) -> crate::Result<AcmeOptions> {
let http_bind = match (self.acme_challenge, self.acme_http_bind) {
(AcmeChallenge::Http01, bind) => Some(bind.unwrap_or(Self::DEFAULT_HTTP_BIND)),
(AcmeChallenge::TlsAlpn01, None) => None,
(AcmeChallenge::TlsAlpn01, Some(_)) => {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"--acme-http-bind is only valid with --acme-challenge http-01",
)
.into());
}
};
let contacts = std::mem::take(&mut self.acme_email)
.into_iter()
.map(|email| {
if email.starts_with("mailto:") {
email
} else {
format!("mailto:{email}")
}
})
.collect();
Ok(AcmeOptions {
domains: std::mem::take(&mut self.acme_domain),
contacts,
challenge: self.acme_challenge,
http_bind,
production: self.acme_production,
})
}
}
#[derive(Subcommand)]
pub(crate) enum Command {
Run(ServerArgs),
#[cfg(target_os = "linux")]
#[command(subcommand)]
Systemd(SystemdCommand),
}
#[cfg(target_os = "linux")]
#[derive(Subcommand)]
pub(crate) enum SystemdCommand {
Start(ServerArgs),
Restart(ServerArgs),
Stop,
Logs,
Status,
}