#!/usr/bin/env python3
"""
Create a separate NEW UML L0 RCA keypair and candidate certificate
using the exact TheEnbyperor/c-its reference commit e3bb3b82480d6df4237e2a8c35ea0dd7eade25b4.

THIS DOES NOT REPLACE OR RECREATE THE EU-REGISTERED ROOT. The result is not trusted
or registered until it completes a deliberate registration/re-key process.

The new private key never leaves this machine and is permanently stored only as
encrypted PKCS#8 PEM. A 32-byte private scalar is passed to the already-built
local Rust process over stdin and is never written to disk unencrypted.
"""

from __future__ import annotations

import getpass
import hashlib
import os
from pathlib import Path
import re
import shutil
import subprocess
import sys
import tarfile
import zipfile
from datetime import datetime

UPSTREAM_COMMIT = "e3bb3b82480d6df4237e2a8c35ea0dd7eade25b4"
TEMPLATE_SHA256 = "7168E341764188E140EF591634A9D2488D7FDACDA667EE53AFD566A8034ED5DB"
CERTIFICATE_ID = "0_Urban-Mobility-Lab-Root-CA_L0"

HERE = Path(__file__).resolve().parent
ROOT = HERE.parent
TEMPLATE = ROOT / "rca" / "AFD566A8034ED5DB.oer"
PATCH_SOURCE = HERE / "src" / "create_new_root.rs"
BUNDLED_SOURCE = HERE / "vendor" / "c-its-source-e3bb3b8.zip"
VENDORED_CRATES = HERE / "vendor" / "cargo-crates.tar.gz"
UPSTREAM_DIR = HERE / "_build_cits"
CARGO_VENDOR_DIR = HERE / "_cargo_vendor"

def die(msg: str) -> None:
    raise SystemExit("\nERROR: " + msg)

def run(cmd, *, cwd=None, input_bytes=None, capture=False, env=None):
    print("+", " ".join(str(x) for x in cmd))
    return subprocess.run(
        cmd,
        cwd=cwd,
        input=input_bytes,
        check=True,
        text=False,
        capture_output=capture,
        env=env,
    )

def require_program(name: str) -> None:
    if shutil.which(name) is None:
        die(
            f"'{name}' is not installed or not on PATH. "
            "Install Git and the Rust toolchain (cargo/rustc) first. "
            "On Windows, WSL2 Ubuntu is a good fallback if native compilation causes problems."
        )

def validate_submission_date(s: str) -> str:
    try:
        datetime.strptime(s, "%Y-%m-%d")
    except ValueError:
        die("Submission date must be YYYY-MM-DD.")
    return s

def prepare_upstream() -> None:
    """Create a disposable build tree from the bundled pinned source."""
    if not BUNDLED_SOURCE.is_file() or not VENDORED_CRATES.is_file():
        die("Bundled c-its source or Cargo crate archive is missing.")
    if UPSTREAM_DIR.exists():
        shutil.rmtree(UPSTREAM_DIR)
    if CARGO_VENDOR_DIR.exists():
        shutil.rmtree(CARGO_VENDOR_DIR)
    UPSTREAM_DIR.mkdir()
    CARGO_VENDOR_DIR.mkdir()
    with zipfile.ZipFile(BUNDLED_SOURCE) as archive:
        archive.extractall(UPSTREAM_DIR)
    with tarfile.open(VENDORED_CRATES, "r:gz") as archive:
        archive.extractall(CARGO_VENDOR_DIR)

    # Replace only the root-generator utility. Security/crypto/ASN.1 implementation
    # remains the pinned upstream commit.
    shutil.copy2(PATCH_SOURCE, UPSTREAM_DIR / "src" / "util" / "generate_root.rs")
    shutil.copy2(TEMPLATE, UPSTREAM_DIR / TEMPLATE.name)

    # Host-build fix for Windows/native desktop targets:
    # ieee80211 pulls embedded defmt support through default features, but a
    # normal host executable has no defmt transport/logger providing symbols
    # such as _defmt_panic, _defmt_acquire and _defmt_write.
    cargo_toml = UPSTREAM_DIR / "Cargo.toml"
    cargo_text = cargo_toml.read_text(encoding="utf-8")
    original_ieee = 'ieee80211 = "0.5.9"'
    patched_ieee = 'ieee80211 = { version = "0.5.9", default-features = false }'
    if original_ieee in cargo_text:
        cargo_text = cargo_text.replace(original_ieee, patched_ieee, 1)
        cargo_toml.write_text(cargo_text, encoding="utf-8")
        print("Applied host-build patch: ieee80211 default features disabled (defmt removed).")
    elif patched_ieee in cargo_text:
        print("Host-build patch already present.")
    else:
        die("Expected ieee80211 dependency line not found in pinned Cargo.toml.")

    cargo_config = UPSTREAM_DIR / ".cargo" / "config.toml"
    cargo_config.parent.mkdir()
    cargo_config.write_text(
        '[source.crates-io]\nreplace-with = "vendored-sources"\n\n'
        '[source.vendored-sources]\ndirectory = "../_cargo_vendor"\n\n'
        '[net]\noffline = true\n',
        encoding="utf-8",
    )

def build_generator() -> Path:
    print("\nBuilding the pinned c-its generator BEFORE generating any private key...")
    try:
        run(
            [
                "cargo", "build", "--offline", "--release",
                "--features", "build-binary",
                "--bin", "c-its-generate-root",
            ],
            cwd=UPSTREAM_DIR,
        )
    except subprocess.CalledProcessError as exc:
        die(
            "The pinned c-its host build failed. No RCA private key has been generated. "
            "If the remaining linker error still mentions _defmt_*, delete the package's "
            "_upstream_cits directory and rerun this V2 script. "
            f"Cargo exit code: {exc.returncode}"
        )
    exe = UPSTREAM_DIR / "target" / "release" / (
        "c-its-generate-root.exe" if os.name == "nt" else "c-its-generate-root"
    )
    if not exe.exists():
        die(f"Build reported success but executable is missing: {exe}")
    return exe

def generate_keypair_and_certificate(exe: Path) -> Path:
    try:
        from cryptography.hazmat.primitives.asymmetric import ec, utils
        from cryptography.hazmat.primitives import hashes, serialization
    except ImportError:
        die("Python package 'cryptography' is required. Run: python -m pip install cryptography")

    submission_date = validate_submission_date(
        input("\nActual submission date (YYYY-MM-DD): ").strip()
    )

    while True:
        pw1 = getpass.getpass("Choose NEW RCA private-key passphrase: ")
        pw2 = getpass.getpass("Repeat passphrase: ")
        if pw1 != pw2:
            print("Passphrases do not match. Try again.")
            continue
        if len(pw1) < 12:
            print("Use at least 12 characters.")
            continue
        break

    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    root = HERE / f"UML_L0_RCA_NEW_{stamp}"
    submit = root / "CANDIDATE_SUBMISSION_NOT_REGISTERED"
    private_dir = root / "PRIVATE_DO_NOT_SHARE"
    public_dir = root / "PUBLIC_AND_VALIDATION"
    rust_out = root / "_rust_output"
    for d in (submit, private_dir, public_dir, rust_out):
        d.mkdir(parents=True, exist_ok=False)

    print("\nGenerating a fresh NIST P-256 keypair locally...")
    key = ec.generate_private_key(ec.SECP256R1())

    encrypted_pem = key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.BestAvailableEncryption(pw1.encode("utf-8")),
    )
    public_pem = key.public_key().public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo,
    )

    private_path = private_dir / "UML_L0_RCA_private_encrypted.pem"
    public_path = public_dir / "UML_L0_RCA_public.pem"
    private_path.write_bytes(encrypted_pem)
    public_path.write_bytes(public_pem)
    try:
        private_path.chmod(0o600)
    except OSError:
        pass

    # The scalar is kept in RAM and sent only over stdin to the local Rust binary.
    scalar = bytearray(key.private_numbers().private_value.to_bytes(32, "big"))

    env = os.environ.copy()
    env["UML_TEMPLATE"] = str(UPSTREAM_DIR / TEMPLATE.name)
    env["UML_OUTPUT_DIR"] = str(rust_out)

    try:
        proc = run(
            [str(exe)],
            cwd=UPSTREAM_DIR,
            input_bytes=(bytes(scalar).hex().upper() + "\n").encode("ascii"),
            capture=True,
            env=env,
        )
    finally:
        for i in range(len(scalar)):
            scalar[i] = 0

    stdout = proc.stdout.decode("utf-8", errors="replace")
    stderr = proc.stderr.decode("utf-8", errors="replace")
    print(stdout)
    if stderr.strip():
        print(stderr, file=sys.stderr)

    m = re.search(r"^RESULT_ID8=([0-9A-F]{16})$", stdout, re.MULTILINE)
    if not m:
        die("Rust generator succeeded but RESULT_ID8 was not found.")
    id8 = m.group(1)

    oer_src = rust_out / f"{id8}.oer"
    if not oer_src.exists():
        die(f"Expected certificate not found: {oer_src}")

    cert_bytes = oer_src.read_bytes()
    cert_sha256 = hashlib.sha256(cert_bytes).hexdigest().upper()
    if cert_sha256[-16:] != id8:
        die("Independent Python HashedID8 check failed.")

    # Independently reconstruct the IEEE/ETSI self-signed prehash from the TBS
    # emitted by rasn and verify the c-its ECDSA signature with Python cryptography.
    details = {}
    for line in (rust_out / "signing_details.txt").read_text(encoding="utf-8").splitlines():
        if "=" in line:
            k, v = line.split("=", 1)
            details[k] = v

    tbs = (rust_out / "tbs.oer").read_bytes()
    h_tbs = hashlib.sha256(tbs).digest()
    h_empty = hashlib.sha256(b"").digest()
    prehash = hashlib.sha256(h_tbs + h_empty).digest()

    if details.get("TBS_SHA256") != h_tbs.hex().upper():
        die("Independent TBS hash disagrees with Rust output.")
    if details.get("SIGNING_PREHASH_SHA256") != prehash.hex().upper():
        die("Independent IEEE/ETSI signing prehash disagrees with Rust output.")

    r = int(details["ECDSA_R"], 16)
    s = int(details["ECDSA_S"], 16)
    der_sig = utils.encode_dss_signature(r, s)
    try:
        key.public_key().verify(
            der_sig,
            prehash,
            ec.ECDSA(utils.Prehashed(hashes.SHA256())),
        )
    except Exception as exc:
        die(f"Independent Python ECDSA verification FAILED: {exc}")

    # Copy only the public submission certificate.
    oer_submit = submit / f"{id8}.oer"
    shutil.copy2(oer_src, oer_submit)

    txt_name = f"{id8}_{CERTIFICATE_ID}_{submission_date}.txt"
    txt_submit = submit / txt_name
    txt_submit.write_text(f"""EU CCMS CPOC L0 ECTL — RCA descriptive information
===================================================

Full Company Name / RCA Operator:
Hochschule für Angewandte Wissenschaften Hamburg (HAW Hamburg)
Urban Mobility Lab

RCA Name:
Urban Mobility Lab L0 Root CA

RCA Distribution Centre URL:
https://cits-dc.uml-hamburg.de

Contact:
uml-haw@proton.me

CertificateID:
{CERTIFICATE_ID}

Certificate HashedID8:
{id8}

CertificateID / acronym explanation:
- 0: CPA-ID reserved for the L0 environment.
- Urban-Mobility-Lab-Root-CA: Root CA operated for the Urban Mobility Lab at HAW Hamburg.
- L0: EU CCMS L0 research/test environment.

Purpose of testing:
The RCA is used for research, field testing and proof-of-concept activities of the
Urban Mobility Lab in the context of the micrOBU project. micrOBU investigates the
integration of vulnerable road users into C-ITS through development of a lightweight,
compact and low-cost VRU ITS-S using an MCU + mobile-phone architecture.

Contextual constraints / deviations:
- This is a candidate new RCA. It is not registered and must not be deployed until
  the EU CCMS CPOC has completed the intended registration or re-key procedure.
- The implementation, including the C-ITS protocol stack, signing functionality and
  VRU Awareness Basic Service, is under active development. Full implementation
  conformity is not claimed.
- The declared RCA Distribution Centre is the intended permanent DC URL. At the time
  of this submission, the cits-dc.uml-hamburg.de subdomain and the required /getctl
  and /getcrl endpoints are still being commissioned and are not yet operational.
- The RCA intentionally includes ITS-AID 638 (VRU Awareness basic service) with
  bitmap SSP range 01/FF for L0 VAM/VBS research. ITS-AID 638 is a standardized ETSI
  ITS-AID but is not contained in the current CPOC Protocol Release 3.3 Table 4 list;
  its inclusion is therefore an intentional L0 profile deviation.
- The RCA private key is generated and maintained locally as an encrypted PKCS#8
  NIST P-256 key for this L0 research environment. This software-based key storage is
  not claimed to satisfy production/L2 cryptographic-module requirements.

Re-key / revocation / relationship to existing certificates:
Candidate new RCA. Coordinate its relationship to existing registrations with the
EU CCMS CPOC before submission or use.

Submission date:
{submission_date}
""", encoding="utf-8")

    # Preserve public validation evidence.
    shutil.copy2(rust_out / "certificate_report.json", public_dir / "certificate_report.json")
    shutil.copy2(rust_out / "signing_details.txt", public_dir / "signing_details.txt")
    shutil.copy2(rust_out / "tbs.oer", public_dir / "tbs.oer")

    spki_der = key.public_key().public_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PublicFormat.SubjectPublicKeyInfo,
    )
    spki_sha256 = hashlib.sha256(spki_der).hexdigest().upper()

    manifest = f"""UML L0 RCA generation manifest
=============================

Reference implementation:
https://github.com/TheEnbyperor/c-its
Pinned commit:
{UPSTREAM_COMMIT}

Reference root-generator behavior:
- rasn::oer encoding
- c_its::security::crypto::PrivateKey::sign()
- self-signed signer-certificate input = empty byte string
- NIST P-256 / SHA-256

Template certificate SHA-256:
{TEMPLATE_SHA256}

NEW certificate:
{id8}.oer

Certificate SHA-256:
{cert_sha256}

HashedID8:
{id8}

New public-key SPKI SHA-256:
{spki_sha256}

Validation:
PASS - c-its parsed final certificate
PASS - c-its self-signature verification
PASS - c-its parse/re-encode stability
PASS - Python independently recomputed HashedID8
PASS - Python independently recomputed IEEE/ETSI signing prehash
PASS - Python cryptography independently verified ECDSA signature over that prehash

PRIVATE KEY:
{private_path.name}
Encrypted PKCS#8 PEM. DO NOT SUBMIT OR UPLOAD.
"""
    (public_dir / "generation_manifest.txt").write_text(manifest, encoding="utf-8")

    # Remove duplicate Rust certificate; the canonical submission copy is in SUBMIT.
    shutil.rmtree(rust_out)

    print("\nSUCCESS")
    print("A NEW, UNREGISTERED keypair and candidate certificate were generated locally.")
    print("Do not deploy it as the registered root. EU registration/re-keying is required.")
    print(f"\nCANDIDATE SUBMISSION FILES (NOT REGISTERED):\n  {oer_submit}\n  {txt_submit}")
    print(f"\nKEEP PRIVATE:\n  {private_path}")
    print(f"\nSAFE PUBLIC/VALIDATION FILES:\n  {public_dir}")
    return root

def main() -> None:
    require_program("cargo")

    if not TEMPLATE.exists():
        die(f"Missing bundled template: {TEMPLATE}")
    got = hashlib.sha256(TEMPLATE.read_bytes()).hexdigest().upper()
    if got != TEMPLATE_SHA256:
        die(f"Bundled template hash mismatch: {got}")

    prepare_upstream()
    exe = build_generator()
    root = generate_keypair_and_certificate(exe)
    print(f"\nResult folder: {root}")

if __name__ == "__main__":
    main()