wsfed-caep 0.1.3

Server-side WS-Federation relying party
Documentation
// SPDX-FileCopyrightText: 2026 Iya CyberSecurity Solutions, LLC
// SPDX-License-Identifier: MIT

use crate::config::parse_object;
use crate::error::fail;
use crate::relying_party::RelyingParty;
use crate::x509util::{self, create_self_signed_key_pair};
use serde_json::Value;
use std::collections::HashMap;
use std::io::{self, Write};
use std::path::{Path, PathBuf};

const USAGE: &str = "Usage:\n  wsfed-caep generate-keys --config <wsfed.json> [--cn <name>] [--days <n>] [--bits <n>] [--force]\n  wsfed-caep generate-keys --key <file> --cert <file> [--cn <name>] [--days <n>] [--bits <n>] [--force]\n      A new RSA key and a self-signed certificate, written where the configuration's privateKey and\n      certificate point (or to --key and --cert). Refuses to replace existing files without --force.\n      The key decrypts encrypted assertions and can authenticate the Shared Signals receiver (mutual\n      TLS); WS-Federation itself signs nothing. The common name defaults to one naming the realm.\n\n  wsfed-caep metadata --config <wsfed.json> [--out <file>]\n      This relying party's federation metadata, from the configuration (and its certificate, when it\n      has one): give it to the identity provider. Written to --out, or to standard output.";

fn parse_cli(argv: &[String]) -> std::result::Result<(String, HashMap<String, String>), String> {
    if argv.is_empty() { return Ok((String::new(), HashMap::new())); }
    let command = argv[0].clone();
    let rest = &argv[1..];
    let mut args = HashMap::new();
    let mut index = 0;
    while index < rest.len() {
        let item = &rest[index];
        if !item.starts_with("--") { return Err(format!("unexpected argument {item}\n\n{USAGE}")); }
        let key = &item[2..];
        if key == "force" || key == "help" {
            args.insert(key.to_string(), "true".to_string());
            index += 1;
            continue;
        }
        if index + 1 >= rest.len() || rest[index + 1].starts_with("--") {
            return Err(format!("--{key} needs a value\n\n{USAGE}"));
        }
        args.insert(key.to_string(), rest[index + 1].clone());
        index += 2;
    }
    Ok((command, args))
}

fn clip_runes(value: &str, n: usize) -> String {
    value.chars().take(n).collect()
}

fn strip_file(value: &str) -> &str {
    value.strip_prefix("file:").unwrap_or(value)
}

fn key_paths(args: &HashMap<String, String>) -> std::result::Result<(String, String, String), String> {
    let config_path = args.get("config").cloned().unwrap_or_default();
    let mut key = args.get("key").cloned().unwrap_or_default();
    let mut cert = args.get("cert").cloned().unwrap_or_default();
    let mut common_name = args.get("cn").cloned().unwrap_or_default();
    if !config_path.is_empty() {
        let raw = std::fs::read_to_string(&config_path).map_err(|err| err.to_string())?;
        let parsed = parse_object(&raw).map_err(|err| err.to_string())?;
        let base = std::fs::canonicalize(&config_path).unwrap_or_else(|_| PathBuf::from(&config_path));
        let base = base.parent().unwrap_or(Path::new("."));
        let at = |value: &str, what: &str| -> std::result::Result<String, String> {
            if value.is_empty() || value.contains("-----BEGIN ") {
                return Err(format!("{config_path}'s {what} must be a file path for generate-keys to write to"));
            }
            let value = strip_file(value);
            if Path::new(value).is_absolute() { Ok(value.to_string()) } else { Ok(base.join(value).to_string_lossy().into_owned()) }
        };
        if key.is_empty() {
            if let Some(text) = parsed.get("privateKey").and_then(|item| item.as_str()) {
                if !text.is_empty() { key = at(text, "privateKey")?; }
            }
        }
        if cert.is_empty() {
            if let Some(text) = parsed.get("certificate").and_then(|item| item.as_str()) {
                if !text.is_empty() { cert = at(text, "certificate")?; }
            }
        }
        if common_name.is_empty() {
            if let Some(realm) = parsed.get("realm").and_then(|item| item.as_str()) {
                if !realm.is_empty() { common_name = clip_runes(&format!("wsfed-caep-nodejs relying party {realm}"), 64); }
            }
        }
    }
    if key.is_empty() || cert.is_empty() {
        return Err(format!("generate-keys needs --config, or --key and --cert\n\n{USAGE}"));
    }
    let key = std::fs::canonicalize(Path::new(&key).parent().unwrap_or(Path::new("."))).unwrap_or_else(|_| PathBuf::from(".")).join(Path::new(&key).file_name().unwrap_or_default());
    let cert_abs = std::fs::canonicalize(Path::new(&cert).parent().unwrap_or(Path::new("."))).unwrap_or_else(|_| PathBuf::from(".")).join(Path::new(&cert).file_name().unwrap_or_default());
    if common_name.is_empty() { common_name = "wsfed-caep-nodejs relying party".to_string(); }
    Ok((key.to_string_lossy().into_owned(), cert_abs.to_string_lossy().into_owned(), common_name))
}

fn exists(path: &str) -> bool { Path::new(path).exists() }

pub fn main(argv: &[String], mut out: impl Write) -> i32 {
    let (command, args) = match parse_cli(argv) {
        Ok(value) => value,
        Err(err) => { eprintln!("{err}"); return 1; }
    };
    if command.is_empty() || args.get("help").map(String::as_str) == Some("true") || command == "help" {
        let _ = writeln!(out, "{USAGE}");
        return 0;
    }
    if command == "generate-keys" {
        let (key, cert, common_name) = match key_paths(&args) {
            Ok(value) => value,
            Err(err) => { eprintln!("{err}"); return 1; }
        };
        if args.get("force").map(String::as_str) != Some("true") && (exists(&key) || exists(&cert)) {
            let which = if exists(&key) { &key } else { &cert };
            eprintln!("{which} already exists; pass --force to replace the key pair.\nReplacing it means giving the identity provider the new metadata before it next encrypts to this relying party.");
            return 1;
        }
        let mut days = 1095i64;
        let mut bits = 3072usize;
        if let Some(text) = args.get("days") {
            match text.parse::<i64>() { Ok(value) if value > 0 => days = value, _ => { eprintln!("--days must be a positive whole number"); return 1; } }
        }
        if let Some(text) = args.get("bits") {
            match text.parse::<usize>() { Ok(2048) | Ok(3072) | Ok(4096) => bits = text.parse().unwrap_or(3072), _ => { eprintln!("--bits must be 2048, 3072 or 4096"); return 1; } }
        }
        let pair = match create_self_signed_key_pair(&common_name, days, bits) {
            Ok(value) => value,
            Err(err) => { eprintln!("{err}"); return 1; }
        };
        if let Some(dir) = Path::new(&key).parent() { let _ = std::fs::create_dir_all(dir); }
        if let Some(dir) = Path::new(&cert).parent() { let _ = std::fs::create_dir_all(dir); }
        if write_mode(&key, pair.private_key_pem.as_bytes(), 0o600).is_err() || write_mode(&cert, pair.certificate_pem.as_bytes(), 0o644).is_err() {
            eprintln!("the key pair could not be written");
            return 1;
        }
        let _ = writeln!(out, "Wrote the private key  {key} (mode 600)");
        let _ = writeln!(out, "Wrote the certificate  {cert}");
        let _ = writeln!(out, "  subject   {}", x509util::subject_string(&pair.certificate_der));
        return 0;
    }
    if command == "metadata" {
        let config_path = args.get("config").cloned().unwrap_or_default();
        if config_path.is_empty() { eprintln!("metadata needs --config\n\n{USAGE}"); return 1; }
        let raw = match std::fs::read_to_string(&config_path) { Ok(value) => value, Err(err) => { eprintln!("{err}"); return 1; } };
        let mut parsed = match parse_object(&raw) { Ok(value) => value, Err(err) => { eprintln!("{err}"); return 1; } };
        parsed.remove("idpCa");
        let base = std::fs::canonicalize(&config_path).unwrap_or_else(|_| PathBuf::from(&config_path));
        let base = base.parent().unwrap_or(Path::new(".")).to_path_buf();
        let party = match RelyingParty::create(&parsed, &base) { Ok(value) => value, Err(err) => { eprintln!("{err}"); return 1; } };
        let xml = party.metadata_xml();
        if let Some(target) = args.get("out") {
            if let Some(dir) = Path::new(target).parent() { let _ = std::fs::create_dir_all(dir); }
            if std::fs::write(target, xml.as_bytes()).is_err() { eprintln!("the metadata could not be written"); return 1; }
            let _ = writeln!(out, "Wrote the relying party metadata to {target}");
        } else {
            let _ = write!(out, "{xml}");
        }
        return 0;
    }
    eprintln!("unknown command {command}\n\n{USAGE}");
    let _ = fail("config", "");
    let _ = Value::Null;
    1
}

fn write_mode(path: &str, bytes: &[u8], mode: u32) -> io::Result<()> {
    use std::io::Write as _;
    use std::os::unix::fs::OpenOptionsExt;
    let mut file = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(mode).open(path)?;
    file.write_all(bytes)
}

pub fn main_args() -> i32 {
    let argv: Vec<String> = std::env::args().skip(1).collect();
    main(&argv, io::stdout())
}