use std::io::{Read, Write};
use std::net::TcpListener;
use std::process::Command;
use std::sync::Arc;
use std::thread;
use rcgen::{BasicConstraints, CertificateParams, DnType, IsCa, Issuer, KeyPair, KeyUsagePurpose};
use serde_json::{json, Map};
use crate::support::idp_metadata;
use crate::ServiceProvider;
struct Chain {
pem: String,
leaf_key: String,
}
fn ca_params(name: &str) -> CertificateParams {
let mut params = CertificateParams::new(Vec::<String>::new()).expect("params");
params.distinguished_name = rcgen::DistinguishedName::new();
params.distinguished_name.push(DnType::CommonName, name);
params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign, KeyUsagePurpose::DigitalSignature];
params
}
fn chain() -> Chain {
let root_key = KeyPair::generate().expect("key");
let root_params = ca_params("test Root CA");
let root = root_params.self_signed(&root_key).expect("root");
let root_issuer = Issuer::from_params(&root_params, &root_key);
let intermediate_key = KeyPair::generate().expect("key");
let intermediate_params = ca_params("test Intermediate CA");
let intermediate = intermediate_params.signed_by(&intermediate_key, &root_issuer).expect("intermediate");
let intermediate_issuer = Issuer::from_params(&intermediate_params, &intermediate_key);
let issuing_key = KeyPair::generate().expect("key");
let issuing_params = ca_params("test TLS Issuing CA");
let issuing = issuing_params.signed_by(&issuing_key, &intermediate_issuer).expect("issuing");
let issuing_issuer = Issuer::from_params(&issuing_params, &issuing_key);
let leaf_key = KeyPair::generate().expect("key");
let mut leaf_params = CertificateParams::new(vec!["127.0.0.1".to_string(), "localhost".to_string()]).expect("params");
leaf_params.distinguished_name = rcgen::DistinguishedName::new();
leaf_params.distinguished_name.push(DnType::CommonName, "127.0.0.1");
leaf_params.is_ca = IsCa::NoCa;
let leaf = leaf_params.signed_by(&leaf_key, &issuing_issuer).expect("leaf");
Chain {
pem: format!("{}{}{}{}", leaf.pem(), issuing.pem(), intermediate.pem(), root.pem()),
leaf_key: leaf_key.serialize_pem(),
}
}
fn serve_tls(chain: &Chain, published: bool) -> String {
let identity = native_tls::Identity::from_pkcs8(chain.pem.as_bytes(), chain.leaf_key.as_bytes()).expect("identity");
let acceptor = Arc::new(native_tls::TlsAcceptor::new(identity).expect("acceptor"));
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
let port = listener.local_addr().expect("addr").port();
let chain_pem = chain.pem.clone();
thread::spawn(move || {
for stream in listener.incoming() {
let Ok(stream) = stream else { break };
let acceptor = acceptor.clone();
let chain_pem = chain_pem.clone();
thread::spawn(move || {
let Ok(mut tls) = acceptor.accept(stream) else { return };
let mut request = Vec::new();
let mut buffer = [0u8; 2048];
while !request.windows(4).any(|w| w == b"\r\n\r\n") {
match tls.read(&mut buffer) {
Ok(0) | Err(_) => return,
Ok(n) => request.extend_from_slice(&buffer[..n]),
}
}
let text = String::from_utf8_lossy(&request);
let path = text.split_whitespace().nth(1).unwrap_or("/").to_string();
let (status, body) = if path == "/tls/server-certificate" && published {
("200 OK", chain_pem)
} else if path == "/metadata" {
("200 OK", idp_metadata(""))
} else {
("404 Not Found", String::new())
};
let _ = write!(tls, "HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len());
let _ = tls.flush();
let _ = tls.shutdown();
});
}
});
format!("https://127.0.0.1:{port}")
}
fn blocks(pem: &str) -> usize {
pem.matches("-----BEGIN CERTIFICATE-----").count()
}
fn scratch(name: &str) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!("saml2-sp-rust-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
fn save_with_registrar(dir: &std::path::Path, origin: &str) -> String {
std::fs::write(dir.join("saml.json"), r#"{
"entityId": "http://localhost:3000/saml/metadata",
"acsUrl": "http://localhost:3000/saml/acs",
"privateKey": "file:generated/sp.key",
"certificate": "file:generated/sp.crt",
"idpMetadata": "file:generated/idp-metadata.xml",
"idpCa": "file:generated/idp-ca.pem"
}"#).unwrap();
let script = r#"import importlib.util, json, sys
from pathlib import Path
spec = importlib.util.spec_from_file_location("configure_iya_sts", sys.argv[1])
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
files = mod.files_of(str(Path(sys.argv[2]) / "saml.json"))
assert files.idp_ca == str((Path(sys.argv[2]) / "generated" / "idp-ca.pem").resolve()), files.idp_ca
saved = mod.save_trust_chain(sys.argv[3], files.idp_ca)
print(json.dumps({"count": saved["count"], "anchor": saved["anchor"].subject.rfc4514_string(), "path": saved["path"]}))
"#;
let script_path = format!("{}/scripts/configure_iya_sts.py", env!("CARGO_MANIFEST_DIR"));
let out = Command::new("python3").arg("-c").arg(script).arg(&script_path).arg(dir).arg(origin).output().unwrap();
assert!(out.status.success(), "{}\n{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
String::from_utf8_lossy(&out.stdout).into_owned()
}
#[test]
fn registrar_writes_the_published_chain_to_idp_ca() {
let chain = chain();
let origin = serve_tls(&chain, true);
let dir = scratch("chain-published");
let printed = save_with_registrar(&dir, &origin);
let written = std::fs::read_to_string(dir.join("generated/idp-ca.pem")).unwrap();
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(blocks(&written), 4, "{written}");
assert_eq!(written.trim(), chain.pem.trim());
assert!(printed.contains("\"count\": 4"), "{printed}");
assert!(printed.contains("CN=test Root CA"), "{printed}");
}
#[test]
fn registrar_falls_back_to_the_handshake_chain() {
let chain = chain();
let origin = serve_tls(&chain, false);
let dir = scratch("chain-handshake");
let printed = save_with_registrar(&dir, &origin);
let written = std::fs::read_to_string(dir.join("generated/idp-ca.pem")).unwrap();
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(blocks(&written), 4, "{written}");
assert!(printed.contains("CN=test Root CA"), "{printed}");
}
#[test]
fn library_trusts_the_whole_chain_file_as_idp_ca() {
let chain = chain();
let origin = serve_tls(&chain, true);
let dir = scratch("chain-trust");
let ca_path = dir.join("idp-ca.pem");
std::fs::write(&ca_path, &chain.pem).unwrap();
let mut extra = Map::new();
extra.insert("idpCa".into(), json!(format!("file:{}", ca_path.display())));
extra.insert("idpMetadata".into(), json!(format!("{origin}/metadata")));
let config = crate::support::test_config(extra, "");
let made = ServiceProvider::create(&config, "", None);
let _ = std::fs::remove_dir_all(&dir);
let sp = made.unwrap_or_else(|e| panic!("the chain file was not a usable trust store: {e}"));
assert_eq!(sp.config.idp_ca.trim(), chain.pem.trim());
assert_eq!(crate::http::trust_anchors(&chain.pem).unwrap().len(), 4);
}
#[test]
fn library_refuses_a_ca_file_with_no_certificate() {
assert!(crate::http::trust_anchors("not a certificate").is_err());
let unterminated = "-----BEGIN CERTIFICATE-----\nAAAA\n";
assert!(crate::http::trust_anchors(unterminated).is_err());
}