use std::path::Path;
use std::sync::Arc;
use nitr_core::{Error, Result};
use rustls::ServerConfig;
use rustls::pki_types::pem::PemObject as _;
use rustls::pki_types::{CertificateDer, PrivateKeyDer, pem};
use crate::config::TlsConfig;
pub const ALPN_PROTOCOLS: [&[u8]; 1] = [b"http/1.1"];
#[derive(Debug)]
pub struct Loaded {
pub config: Arc<ServerConfig>,
pub certs: usize,
}
pub(crate) fn load(cfg: &TlsConfig) -> Result<Loaded> {
let cert_path = require(cfg.cert.as_deref(), "cert")?;
let key_path = require(cfg.key.as_deref(), "key")?;
let cert_pem = read(cert_path, "cert")?;
let key_pem = zeroize::Zeroizing::new(read(key_path, "key")?);
build(&cert_pem, &key_pem, cfg.min_version.as_deref()).map_err(|err| {
Error::Config(format!(
"[tls] cannot use {} with {}: {err}",
cert_path.display(),
key_path.display()
))
})
}
pub fn build(cert_pem: &[u8], key_pem: &[u8], min_version: Option<&str>) -> Result<Loaded> {
let versions = protocol_versions(min_version)?;
let certs = parse_certs(cert_pem)?;
let count = certs.len();
let key = parse_key(key_pem)?;
let provider = Arc::new(rustls::crypto::ring::default_provider());
let mut config = ServerConfig::builder_with_provider(provider)
.with_protocol_versions(versions)
.map_err(|err| Error::Config(format!("unsupported TLS protocol versions: {err}")))?
.with_no_client_auth()
.with_single_cert(certs, key)
.map_err(|err| Error::Config(format!("the certificate and key were rejected: {err}")))?;
config.alpn_protocols = ALPN_PROTOCOLS.iter().map(|p| p.to_vec()).collect();
Ok(Loaded {
config: Arc::new(config),
certs: count,
})
}
const TLS12_AND_UP: &[&rustls::SupportedProtocolVersion] =
&[&rustls::version::TLS13, &rustls::version::TLS12];
const TLS13_ONLY: &[&rustls::SupportedProtocolVersion] = &[&rustls::version::TLS13];
fn protocol_versions(
min_version: Option<&str>,
) -> Result<&'static [&'static rustls::SupportedProtocolVersion]> {
match min_version {
None | Some("1.2") => Ok(TLS12_AND_UP),
Some("1.3") => Ok(TLS13_ONLY),
Some(other) => Err(Error::Config(format!(
"unknown [tls] min_version `{other}`: expected \"1.2\" or \"1.3\" \
(TLS 1.0 and 1.1 are deprecated and not offered)"
))),
}
}
fn parse_certs(pem: &[u8]) -> Result<Vec<CertificateDer<'static>>> {
let certs = CertificateDer::pem_slice_iter(pem)
.collect::<std::result::Result<Vec<_>, _>>()
.map_err(|err| Error::Config(format!("the certificate PEM is malformed: {err}")))?;
if certs.is_empty() {
return Err(Error::Config(
"the certificate file holds no CERTIFICATE block: it must be PEM, leaf \
certificate first, not DER and not a key"
.into(),
));
}
Ok(certs)
}
fn parse_key(pem_bytes: &[u8]) -> Result<PrivateKeyDer<'static>> {
PrivateKeyDer::from_pem_slice(pem_bytes).map_err(|err| match err {
pem::Error::NoItemsFound => Error::Config(
"the key file holds no private key block: expected PRIVATE KEY, RSA \
PRIVATE KEY or EC PRIVATE KEY"
.into(),
),
err => Error::Config(format!("the private key PEM is malformed: {err}")),
})
}
fn require<'a>(path: Option<&'a Path>, key: &str) -> Result<&'a Path> {
path.ok_or_else(|| {
Error::Config(format!(
"[tls] enabled = true requires `{key}`: set [tls] {key} to a PEM file"
))
})
}
fn read(path: &Path, key: &str) -> Result<Vec<u8>> {
std::fs::read(path).map_err(|err| {
Error::Config(format!(
"cannot read [tls] {key} = {}: {err}",
path.display()
))
})
}
#[cfg(test)]
mod tests {
use super::*;
fn identity() -> (String, String) {
let key = rcgen::generate_simple_self_signed(vec!["localhost".into()])
.expect("generate a self-signed certificate");
(key.cert.pem(), key.signing_key.serialize_pem())
}
#[test]
fn a_matching_pair_loads_and_advertises_only_http11() {
let (cert, key) = identity();
let loaded = build(cert.as_bytes(), key.as_bytes(), None).expect("a matching pair loads");
assert_eq!(loaded.certs, 1);
assert_eq!(loaded.config.alpn_protocols, vec![b"http/1.1".to_vec()]);
}
#[test]
fn a_chain_keeps_every_certificate() {
let (leaf, key) = identity();
let (extra, _) = identity();
let chain = format!("{leaf}{extra}");
let loaded = build(chain.as_bytes(), key.as_bytes(), None).expect("a chain loads");
assert_eq!(loaded.certs, 2, "both blocks must survive the parse");
}
#[test]
fn a_certificate_without_its_key_is_refused() {
let (cert, _) = identity();
let err = build(cert.as_bytes(), cert.as_bytes(), None).expect_err("no key present");
assert!(
err.to_string().contains("no private key block"),
"got: {err}"
);
}
#[test]
fn a_key_without_its_certificate_is_refused() {
let (_, key) = identity();
let err = build(key.as_bytes(), key.as_bytes(), None).expect_err("no certificate present");
assert!(
err.to_string().contains("no CERTIFICATE block"),
"got: {err}"
);
}
#[test]
fn a_key_that_does_not_match_the_certificate_is_refused() {
let (cert, _) = identity();
let (_, other_key) = identity();
let err = build(cert.as_bytes(), other_key.as_bytes(), None).expect_err("mismatched pair");
let msg = err.to_string();
assert!(msg.contains("rejected"), "got: {msg}");
assert!(
msg.to_ascii_lowercase().contains("mismatch"),
"the refusal must say the key does not match, got: {msg}"
);
}
#[test]
fn malformed_pem_is_refused_rather_than_half_read() {
let (cert, key) = identity();
let truncated = &cert.as_bytes()[..cert.len() / 2];
let err = build(truncated, key.as_bytes(), None).expect_err("truncated certificate");
assert!(err.to_string().contains("malformed"), "got: {err}");
let garbled = "-----BEGIN CERTIFICATE-----\n!!!!\n-----END CERTIFICATE-----\n";
let err = build(garbled.as_bytes(), key.as_bytes(), None).expect_err("bad base64");
assert!(err.to_string().contains("malformed"), "got: {err}");
let not_der = "-----BEGIN CERTIFICATE-----\nAAAA\n-----END CERTIFICATE-----\n";
let err = build(not_der.as_bytes(), key.as_bytes(), None).expect_err("not a certificate");
assert!(err.to_string().contains("rejected"), "got: {err}");
let err = build(cert.as_bytes(), &key.as_bytes()[..key.len() / 2], None)
.expect_err("truncated key");
assert!(err.to_string().contains("malformed"), "got: {err}");
}
#[test]
fn empty_files_are_refused_and_name_which_one() {
let (cert, key) = identity();
let err = build(b"", key.as_bytes(), None).expect_err("empty certificate file");
assert!(
err.to_string().contains("no CERTIFICATE block"),
"got: {err}"
);
let err = build(cert.as_bytes(), b"", None).expect_err("empty key file");
assert!(
err.to_string().contains("no private key block"),
"got: {err}"
);
let err = build(b"", b"", None).expect_err("both empty");
assert!(
err.to_string().contains("no CERTIFICATE block"),
"got: {err}"
);
}
#[test]
fn min_version_names_are_strict_and_never_go_below_1_2() {
let (cert, key) = identity();
for accepted in ["1.2", "1.3"] {
build(cert.as_bytes(), key.as_bytes(), Some(accepted))
.unwrap_or_else(|err| panic!("min_version {accepted} must load: {err}"));
}
assert_eq!(
protocol_versions(None).expect("the default version set"),
protocol_versions(Some("1.2")).expect("1.2"),
"an unset min_version must mean exactly TLS 1.2"
);
for rejected in ["1.1", "1.0", "1", "SSLv3", "TLSv1.3", "", "1.4", "0.9"] {
for (what, cert, key) in [
("a good pair", cert.as_str(), key.as_str()),
("a broken pair", "", ""),
] {
let err = build(cert.as_bytes(), key.as_bytes(), Some(rejected))
.expect_err("unknown min_version");
assert!(
err.to_string().contains("min_version"),
"{what}: the refusal must name the setting, got: {err}"
);
}
}
let names: Vec<_> = protocol_versions(None)
.expect("versions")
.iter()
.map(|v| format!("{:?}", v.version))
.collect();
assert_eq!(names, vec!["TLSv1_3", "TLSv1_2"], "unexpected version set");
}
#[test]
fn a_missing_file_names_the_setting_that_pointed_at_it() {
let cfg = TlsConfig {
enabled: true,
cert: Some("/nonexistent/nitr/cert.pem".into()),
key: Some("/nonexistent/nitr/key.pem".into()),
min_version: None,
handshake_ms: None,
};
let err = load(&cfg).expect_err("missing cert file");
assert!(err.to_string().contains("[tls] cert"), "got: {err}");
let cfg = TlsConfig { cert: None, ..cfg };
let err = load(&cfg).expect_err("no cert configured");
assert!(err.to_string().contains("requires `cert`"), "got: {err}");
}
}