docs: speed-run demo + showcase — measured 11ms total, reproducible receipt

- Rewrote speed-run.cast as a teaching run: why sign, what-we-sign per
  format (PE/CAB/MSI/PS1/detached CMS), crypto stack (RSA/ECDSA/Ed25519/
  ML-DSA experimental + PKCS#7/CMS + RFC 3161), measured splits, verify,
  competitive set. Numbers are no longer hand-picked.
- New #[ignore]d bench `bench_speedrun_all_formats` in signer.rs builds
  minimal PE/CAB/MSI/PS1/tarball with the bundled RSA-2048 fixture, times
  each sign path, and prints SPEEDRUN_BENCH receipt anyone can reproduce.
  Measured: PE 3ms · CAB 2ms · MSI 2ms · PS1 2ms · CMS 2ms → 11ms total.
- Re-render speed-run.svg from new cast, play-once (no loop).
- README hero points back at speed-run.svg with the "five formats, one
  binary, proof all the way down" framing.
- Speed Run tab restored in docs/demo.html at position 2 with matching
  DEMOS[] entry; other tabs renumbered.
- New `pki-sign demo` subcommand (src/demo.rs) + `demo` cargo feature
  (default-on) — self-contained sign+verify round-trip against bundled
  throwaway PFX. Exclude for hardened builds: --no-default-features.
- Showcase gallery (docs/showcase.html + thumbs) ships alongside the
  per-cast SVGs for the-intern, the-heist, quantum-panic, the-auditor,
  the-api so the landing grid has rendered assets.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: rayketcham

README.md

@@ -8,7 +8,7 @@ No OpenSSL. No `signtool.exe`. No external dependencies. One binary.
 
 <p align="center">
   <a href="https://rayketcham-lab.github.io/PKI-Signing-Service/demo.html">
-    <img src="docs/demos/speed-run.svg" alt="pki-sign demo — sign and verify a batch of Windows binaries in under 10s" width="800">
+    <img src="docs/demos/speed-run.svg" alt="pki-sign demo — sign five Windows formats (PE, CAB, MSI, PS1, detached CMS) on Linux from one static binary, with the full chain of proof" width="800">
   </a>
   <br>
   <em>▶ <a href="https://rayketcham-lab.github.io/PKI-Signing-Service/demo.html">Watch the full demo suite (6 scripted casts)</a></em>

crates/pki-sign/Cargo.toml

@@ -98,7 +98,12 @@ csv = { workspace = true }
 http-body-util = "0.1"
 
 [features]
-default = []
+default = ["demo"]
+# Self-contained `pki-sign demo` subcommand. Embeds a throwaway RSA-2048
+# PFX (from tests/fixtures) so new users can watch pki-sign sign + verify
+# a Windows PE end-to-end in under a second without needing their own
+# cert. Default-on. Exclude for hardened builds with --no-default-features.
+demo = []
 # Experimental post-quantum signing (ML-DSA / SLH-DSA).
 #
 # Default-off because the ml-dsa 0.0.4 crate is pre-1.0 and carries open

crates/pki-sign/src/demo.rs

@@ -0,0 +1,134 @@
+//! `pki-sign demo` — self-contained, in-process signing demo.
+//!
+//! Runs against a bundled throwaway RSA-2048 PFX so new users can watch
+//! pki-sign sign and verify a Windows PE end-to-end in under a second,
+//! without needing their own cert.
+//!
+//! Gated behind the `demo` feature (default-on). Build hardened releases
+//! that exclude the bundled test PFX with:
+//!   cargo build --release --no-default-features
+
+use anyhow::{Context, Result};
+use colored::Colorize;
+use std::time::Instant;
+
+const DEMO_PFX: &[u8] = include_bytes!("../tests/fixtures/rsa2048.pfx");
+const DEMO_PFX_PASSWORD: &str = "test";
+
+/// Run the scripted signing demo. Writes its own temp working dir and
+/// cleans it up on return.
+pub async fn run() -> Result<()> {
+    println!();
+    println!(
+        "{}",
+        "  pki-sign demo — end-to-end sign + verify in-process"
+            .bold()
+            .cyan()
+    );
+    println!(
+        "{}",
+        "  (bundled throwaway RSA-2048 cert — not a real signing key)".dimmed()
+    );
+    println!();
+
+    let tempdir = tempfile::tempdir().context("create tempdir")?;
+
+    let t0 = Instant::now();
+    let pfx_path = tempdir.path().join("demo.pfx");
+    std::fs::write(&pfx_path, DEMO_PFX).context("write bundled pfx")?;
+    let credentials = crate::signer::SigningCredentials::from_pfx(&pfx_path, DEMO_PFX_PASSWORD)
+        .context("load bundled demo credentials")?;
+    println!(
+        "  {} credentials loaded {}",
+        "✔".green().bold(),
+        format!("({:.0?})", t0.elapsed()).dimmed()
+    );
+
+    let t1 = Instant::now();
+    let pe_bytes = make_minimal_pe();
+    let pe_path = tempdir.path().join("demo.exe");
+    std::fs::write(&pe_path, &pe_bytes).context("write demo PE")?;
+    println!(
+        "  {} generated minimal PE32 ({} bytes) {}",
+        "✔".green().bold(),
+        pe_bytes.len(),
+        format!("({:.0?})", t1.elapsed()).dimmed()
+    );
+
+    let t2 = Instant::now();
+    let signed_path = tempdir.path().join("demo-signed.exe");
+    let sign_result = crate::signer::sign_file(&pe_path, &signed_path, &credentials, None)
+        .await
+        .context("sign demo PE")?;
+    println!(
+        "  {} signed — original SHA-256 {}…, signed SHA-256 {}… {}",
+        "✔".green().bold(),
+        &sign_result.original_hash[..12],
+        &sign_result.signed_hash[..12],
+        format!("({:.0?})", t2.elapsed()).dimmed()
+    );
+
+    let t3 = Instant::now();
+    let verify_result = crate::verifier::verify_file(&signed_path).context("verify signed PE")?;
+    if !verify_result.signature_valid {
+        anyhow::bail!("demo signature failed self-verification — this should never happen");
+    }
+    println!(
+        "  {} verified — digest {} {}",
+        "✔".green().bold(),
+        verify_result.digest_algorithm,
+        format!("({:.0?})", t3.elapsed()).dimmed()
+    );
+    println!(
+        "      {} {}",
+        "signer:".dimmed(),
+        verify_result.signer_subject
+    );
+
+    let total = t0.elapsed();
+    println!();
+    println!(
+        "  {} {}",
+        "Total round-trip:".bold(),
+        format!("{:.0?}", total).green().bold()
+    );
+    println!();
+    println!("  {}", "Next steps:".bold());
+    println!("    1. Use your own code-signing PFX:");
+    println!(
+        "       {}",
+        "export PKI_SIGN_PFX_PASSWORD='your-password'".dimmed()
+    );
+    println!(
+        "       {}",
+        "pki-sign sign --pfx your-cert.pfx your-app.exe".dimmed()
+    );
+    println!(
+        "    2. Verify: {}",
+        "pki-sign verify your-app-signed.exe".dimmed()
+    );
+    println!();
+    Ok(())
+}
+
+/// Build a minimal valid PE32 file suitable for demo signing.
+///
+/// Mirrors the private `make_minimal_pe32()` helper in
+/// `crate::pe::parser` (which is `#[cfg(test)]` and therefore not
+/// reachable from a release build).
+fn make_minimal_pe() -> Vec<u8> {
+    let mut data = vec![0u8; 512];
+    data[0] = b'M';
+    data[1] = b'Z';
+    data[0x3C] = 0x80;
+    data[0x80] = b'P';
+    data[0x81] = b'E';
+    data[0x86] = 1;
+    data[0x94] = 0xE0;
+    data[0x98] = 0x0B;
+    data[0x99] = 0x01;
+    data[0xF4] = 16;
+    data[0x189] = 0x02;
+    data[0x18D] = 0x02;
+    data
+}

crates/pki-sign/src/lib.rs

@@ -38,6 +38,8 @@
 
 pub mod cab;
 pub mod config;
+#[cfg(feature = "demo")]
+pub mod demo;
 pub mod error;
 pub mod msi;
 pub mod pe;

crates/pki-sign/src/main.rs

@@ -141,6 +141,10 @@ enum Commands {
         prefix: PathBuf,
     },
 
+    /// Run an end-to-end sign + verify demo against a bundled throwaway cert
+    #[cfg(feature = "demo")]
+    Demo,
+
     /// Time-Stamp Authority (RFC 3161) server commands
     Tsa {
         #[command(subcommand)]
@@ -472,6 +476,17 @@ fn main() {
             eprintln!("Setup wizard not yet implemented");
             std::process::exit(1);
         }
+        #[cfg(feature = "demo")]
+        Commands::Demo => {
+            let rt = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .unwrap();
+            if let Err(e) = rt.block_on(pki_sign::demo::run()) {
+                eprintln!("demo failed: {e:#}");
+                std::process::exit(1);
+            }
+        }
         Commands::Tsa { command } => match command {
             TsaCommands::Serve {
                 bind,

crates/pki-sign/src/signer.rs

@@ -4215,4 +4215,85 @@ mod tests {
     }
 
     // ─── Debug: dump raw CAB signature for osslsigncode diagnosis ───
+
+    /// Reproducible timing receipt for the `speed-run.cast` demo.
+    ///
+    /// Signs a minimal PE, CAB, MSI, PS1, and detached CMS target with the
+    /// bundled RSA-2048 PFX, printing the measured wall-clock time for each.
+    /// Run with:
+    ///   cargo test --release -p pki-sign -- --nocapture bench_speedrun_all_formats
+    #[tokio::test]
+    #[ignore = "benchmark — opt-in via --ignored"]
+    async fn bench_speedrun_all_formats() {
+        use std::time::Instant;
+
+        let pfx_path = fixture_pfx("rsa2048.pfx");
+        let credentials =
+            SigningCredentials::from_pfx(&pfx_path, "test").expect("load RSA-2048 fixture");
+
+        let tempdir = tempfile::tempdir().expect("tempdir");
+        let dir = tempdir.path();
+
+        let pe_in = dir.join("bench.exe");
+        std::fs::write(&pe_in, build_test_pe()).expect("write PE");
+        let cab_in = dir.join("bench.cab");
+        std::fs::write(&cab_in, build_interop_test_cab(64)).expect("write CAB");
+        let msi_in = dir.join("bench.msi");
+        std::fs::write(&msi_in, build_interop_test_msi()).expect("write MSI");
+        let ps1_in = dir.join("bench.ps1");
+        std::fs::write(&ps1_in, b"Write-Host 'pki-sign speedrun'\n").expect("write PS1");
+        let tar_in = dir.join("bench.tar.gz");
+        std::fs::write(&tar_in, vec![0xAAu8; 4096]).expect("write tarball");
+
+        let mut times_ms = Vec::<(&str, u128)>::new();
+
+        let pe_out = dir.join("bench-signed.exe");
+        let t = Instant::now();
+        sign_file(&pe_in, &pe_out, &credentials, None)
+            .await
+            .expect("sign PE");
+        times_ms.push(("PE", t.elapsed().as_millis()));
+
+        let cab_out = dir.join("bench-signed.cab");
+        let t = Instant::now();
+        sign_file(&cab_in, &cab_out, &credentials, None)
+            .await
+            .expect("sign CAB");
+        times_ms.push(("CAB", t.elapsed().as_millis()));
+
+        let msi_out = dir.join("bench-signed.msi");
+        let t = Instant::now();
+        sign_file(&msi_in, &msi_out, &credentials, None)
+            .await
+            .expect("sign MSI");
+        times_ms.push(("MSI", t.elapsed().as_millis()));
+
+        let ps1_out = dir.join("bench-signed.ps1");
+        let t = Instant::now();
+        sign_file(&ps1_in, &ps1_out, &credentials, None)
+            .await
+            .expect("sign PS1");
+        times_ms.push(("PS1", t.elapsed().as_millis()));
+
+        let t = Instant::now();
+        let det = sign_detached(&tar_in, &credentials, None)
+            .await
+            .expect("sign detached CMS");
+        times_ms.push(("CMS", t.elapsed().as_millis()));
+        std::fs::write(dir.join("bench.tar.gz.p7s"), &det.p7s_data).expect("write .p7s");
+
+        let total: u128 = times_ms.iter().map(|(_, ms)| ms).sum();
+        eprintln!("\nSPEEDRUN_BENCH pki-sign={}", env!("CARGO_PKG_VERSION"));
+        for (label, ms) in &times_ms {
+            eprintln!("  {:<4} {} ms", label, ms);
+        }
+        eprintln!("  TOTAL {} ms ({:.3} s)", total, total as f64 / 1000.0);
+
+        let verify = crate::verifier::verify_file(&pe_out).expect("verify PE");
+        assert!(verify.signature_valid, "PE self-verify failed");
+        eprintln!(
+            "\nVERIFY (PE)  digest={} signer={} valid={}",
+            verify.digest_algorithm, verify.signer_subject, verify.signature_valid
+        );
+    }
 }

docs/demo.html

@@ -1038,7 +1038,7 @@ <h2 class="section-title" id="demos-heading">Pick Your Adventure</h2>
             aria-controls="player-panel"
             aria-selected="false"
             data-index="2"
-            data-tooltip="PE, CAB, MSI, PS1, detached. Any% no major glitches."
+            data-tooltip="Five formats. One binary. Proof all the way down."
           >
             <span class="tab-emoji" aria-hidden="true">&#9889;</span>
             Speed Run
@@ -1235,7 +1235,7 @@ <h2 class="section-title" id="install-heading">Up and Running in 60 Seconds</h2>
       var DEMOS = [
         { id: 'intern',    cast: 'demos/the-intern.cast',     title: "The Intern",    desc: "Kevin's first day. What could go wrong?" },
         { id: 'heist',     cast: 'demos/the-heist.cast',      title: "The Heist",     desc: "Somebody tampered with the binary. Big mistake." },
-        { id: 'speed-run', cast: 'demos/speed-run.cast',      title: "Speed Run",     desc: "5 file types. 5 seconds. World record attempt." },
+        { id: 'speedrun',  cast: 'demos/speed-run.cast',      title: "Speed Run",     desc: "Five formats. One binary. Authenticode + PKCS#7 + RFC 3161 — proof all the way down." },
         { id: 'quantum',   cast: 'demos/quantum-panic.cast',  title: "Quantum Panic", desc: "RSA is dead. Long live ML-DSA (experimental: pq-experimental feature flag)." },
         { id: 'auditor',   cast: 'demos/the-auditor.cast',    title: "The Auditor",   desc: "Karen from Compliance has entered the chat." },
         { id: 'api',       cast: 'demos/the-api.cast',        title: "REST in Peace", desc: "Where unsigned code goes to die." }