v0.7.1: walk the ladder once ever — persistent learned modes, rule pins, same-boot iPXE recovery

Answers the operational question 'can a machine try all three boot
binaries in one go?' The protocol can't carry three NBPs in one cycle
(one boot file per DHCP round, the Secure-Boot refusal happens after
handoff with no error report, and the broken-NIC case specifically needs
the firmware itself to load builtin-driver iPXE — GRUB's network rides
the same broken firmware stack). What we CAN do is make the walk a
once-per-machine-ever event and give operators a way to skip it:

- Learned driver modes persist (<work_dir>/driver_modes.json). A MAC
  that reaches the Shim rung, or confirms an iPXE handoff at Builtin,
  is pinned to disk: immune to the 30-min TTL, reloaded at startup.
  The file only carries exceptions — a healthy fleet never writes it.
  Corrupt file starts empty (standard crash-cache policy).
- Boot rules gain an optional driver_mode pin (auto/firmware/builtin/
  shim), consulted by the DHCP proxy BEFORE the escalation ladder:
  'this OUI is a Secure Boot rack -> serve shim immediately' = zero
  failed cycles. Mode-only rules coexist with target rules (a pin
  doesn't shadow a later target match). Editor column on Hosts tab.
- grub.cfg now tries to chainload all-drivers iPXE before showing the
  signed menu: with SB off the chainload succeeds and the client gets
  the full iPXE feature set back in the SAME boot (self-healing for
  mis-escalations, and the handoff then pins the working mode); with
  SB on, shim's verifier refuses it inline — no reboot — and the
  signed menu appears.

DhcpProxyServer now takes the escalation table + rules store from main
(persistence path comes from the configured work dir).

Validation: clippy clean, fmt clean, 299 workspace tests green (+9:
persistence round-trip across restart, Shim pin survives TTL, learned
Builtin survives TTL, corrupt-file recovery, default-mode-never-
persisted, rule-pin matching incl. unknown-mode tolerance and
pin/target coexistence, GRUB chainload-before-menu ordering, API
round-trip of the driver_mode field).

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

.gitignore

@@ -11,3 +11,6 @@ data/work/
 .claude/settings.local.json
 .claude/worktrees/
 .claude/scheduled_tasks.lock
+
+# local editor / agent settings (not part of the project)
+.claude/

Cargo.toml

@@ -12,7 +12,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.5.1"
+version = "0.7.1"
 edition = "2021"
 rust-version = "1.95"
 license = "MIT OR Apache-2.0"
@@ -20,41 +20,45 @@ repository = "https://gitea.milesward.dev/mward4/OpenPXE"
 authors = ["OpenPXE contributors"]
 
 [workspace.dependencies]
-tokio = { version = "1.40", features = ["full"] }
+tokio = { version = "1.52", features = ["full"] }
 tokio-util = { version = "0.7", features = ["io"] }
 tokio-stream = { version = "0.1", features = ["sync"] }
 futures = "0.3"
 async-trait = "0.1"
 
-dhcproto = "0.12"
+# v0.6.2: dhcproto 0.15 drops the deprecated trust-dns-proto dependency
-socket2 = { version = "0.5", features = ["all"] }
+# (replaced by hickory-proto) and carries three releases of DHCP option
+# coverage accumulated upstream — both directly relevant to the proxy core.
+dhcproto = "0.15"
+socket2 = { version = "0.6", features = ["all"] }
 bytes = "1.7"
-nom = "7.1"
 
-axum = { version = "0.7", features = ["macros", "multipart", "http2"] }
+axum = { version = "0.8", features = ["macros", "multipart", "http2"] }
 tower = "0.5"
 tower-http = { version = "0.6", features = ["fs", "trace", "cors", "limit"] }
-hyper = "1.4"
+hyper = "1.9"
 reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "stream", "json"] }
-mime = "0.3"
-mime_guess = "2.0"
 
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 toml = "0.8"
+# v0.5.4: layered config (TOML file + env). Pure-Rust, no C deps; keeps the
+# static-musl build OpenSSL-free. Replaces the hand-rolled apply_env mapping.
+figment = { version = "0.10", features = ["toml", "env"] }
 
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 
 anyhow = "1.0"
-thiserror = "1.0"
+thiserror = "2.0"
 clap = { version = "4.5", features = ["derive", "env"] }
 uuid = { version = "1.10", features = ["v4", "serde"] }
 time = { version = "0.3", features = ["serde", "serde-human-readable", "formatting", "macros"] }
+# sha2 stays 0.10 deliberately: bergshamra-crypto requires ^0.10, and
+# bumping to 0.11 would split the RustCrypto digest stack in the tree.
 sha2 = "0.10"
 hex = "0.4"
-bcrypt = "0.15"
+bcrypt = "0.19"
-once_cell = "1.19"
 parking_lot = "0.12"
 rust-embed = { version = "8.5", features = ["include-exclude"] }
 
@@ -76,7 +80,7 @@ lettre = { version = "0.11", default-features = false, features = ["smtp-transpo
 # C deps), so the static musl binary stays OpenSSL-free — samael was
 # rejected precisely because it hard-requires OpenSSL. We build the thin
 # SP layer (AuthnRequest, metadata parse, SAMLResponse semantics) on top.
-bergshamra = "0.4"
+bergshamra = "0.5"
 roxmltree = "0.21"
 quick-xml = "0.40"
 x509-parser = "0.18"
@@ -85,6 +89,31 @@ x509-parser = "0.18"
 flate2 = "1.1"
 base64 = "0.22"
 
+# v0.5.5: pure-Rust SSH/SFTP client for reading remote ISO libraries
+# over SFTP without a kernel mount.
+#
+# CRITICAL #1 — crypto backend: `default-features = false` +
+# `features = ["ring"]`. russh's *default* backend is `aws-lc-rs`, which
+# pulls `aws-lc-sys` (C code, fiddly under musl); the `ring` feature
+# instead reuses `ring 0.17` — the exact crate+version already in the
+# binary via rustls + bergshamra — so SFTP adds ZERO new C/crypto deps
+# and the static-musl build stays OpenSSL-free.
+#
+# CRITICAL #2 — history: this was pinned to =0.55.0 from v0.5.5 until
+# v0.6.3 because bergshamra-crypto pinned release-candidate RustCrypto
+# crates that conflicted with the stable generation russh 0.56+ pulls.
+# bergshamra 0.5 (2026-06) moved to the stable generation (pkcs8 0.11),
+# lifting the pin. v0.6.3 bumps to 0.61+, which also closes a batch of
+# RUSTSEC advisories reachable from the SFTP *client* path (unbounded
+# allocations in packet parsing — CVE-2026-48110/-46702/-46673 et al.)
+# and drops mlock on non-secret buffers (~21% SSH throughput upstream).
+#
+# SCP was deliberately rejected: the protocol is sequential-only (no
+# random access → no HTTP Range, unlike SFTP/NFS) and the mature SCP
+# crates wrap libssh2 (C + OpenSSL), which would break this build.
+russh = { version = "0.61", default-features = false, features = ["ring"] }
+russh-sftp = "2.3"
+
 openpxe-core = { path = "crates/core" }
 openpxe-dhcp-proxy = { path = "crates/dhcp-proxy" }
 openpxe-tftp = { path = "crates/tftp" }

README.md

@@ -1,301 +1,270 @@
-# OpenPXE
+<p align="center">
+  <img src="docs/openpxe-logo.svg" alt="OpenPXE" width="104" height="104" />
+</p>
 
-Container-native PXE boot server. A Rust reimplementation of
+<h1 align="center">OpenPXE</h1>
-[iVentoy (ventoy/PXE)](https://github.com/ventoy/PXE), designed from scratch
-for Docker/OCI and OpenShift. Upload `.iso` files via the web UI; network
-clients PXE-boot them.
 
-> **Status:** v0.4.1 / pre-beta. Phases 1–5 complete: full PXE stack,
+<p align="center">
-> Queued Deployment queue, NFS-share ISO sources, live tracing log + an
+  <strong>Container-native network boot &amp; OS deployment — built in Rust.</strong>
-> operator terminal, per-MAC host bindings, Prometheus `/metrics`,
+</p>
-> light/dark theme toggle, animated OpenPXE imaging-progress widget,
-> chunked ISO uploads, and per-ISO boot passwords. The test suite and
-> clippy are part of the release checklist. Ready for real-hardware validation.
 
-## Design non-negotiables
+<p align="center">
+  Drag in an ISO. PXE-boot and image an entire fleet from a browser.<br/>
+  No iPXE scripting. No <code>dnsmasq</code> + <code>tftpd</code> + Samba glue. No glibc. No garbage collector.
+</p>
 
-1. **Fully offline / air-gap deployable.** Zero CDN assets. Zero external
+<p align="center">
-   HTTP calls from the server, the browser, or the generated iPXE scripts.
+  <img alt="release"   src="https://img.shields.io/badge/release-v0.6.0-2874d7" />
-   Build the container once, run forever disconnected.
+  <img alt="license"   src="https://img.shields.io/badge/license-MIT%20%7C%20Apache--2.0-59824f" />
-2. **iPXE is a backend implementation detail.** No `.ipxe` upload path, no
+  <img alt="rust"      src="https://img.shields.io/badge/built%20with-Rust-fb8841?logo=rust&logoColor=white" />
-   manual script editing, no iPXE terminology in the UI. Every knob in the
+  <img alt="container" src="https://img.shields.io/badge/container--native-OCI%20%C2%B7%20OpenShift-2496ED?logo=docker&logoColor=white" />
-   web UI maps to a specific script-generation behavior inside the binary.
+  <img alt="binary"    src="https://img.shields.io/badge/static-musl%20%C2%B7%20~18MB-330f1f" />
-3. **The client trust store is off-limits.** No test-signed drivers, no
+</p>
-   `bcdedit /set testsigning on`, no certificates injected into WinPE or
-   the target OS.
 
-## What it does
+---
 
-1. **DHCP proxy** (RFC 4578). Coexists with your existing DHCP server —
+OpenPXE turns bare-metal provisioning into a single container with a web UI. It's a
-   never assigns IPs. Listens on UDP 67 + UDP 4011.
+ground-up Rust reimplementation of [iVentoy (ventoy/PXE)](https://github.com/ventoy/PXE),
-2. **TFTP server** (RFC 1350 + RFC 2347/2348/2349/7440 option negotiation)
+designed for Docker/OCI and OpenShift instead of a Windows desktop — so it drops onto
-   that serves architecture-specific iPXE binaries to firmware PXE ROMs.
+an Unraid box, a Linux server, or a Kubernetes cluster and just runs.
-3. **HTTP server** that serves the web UI, the generated iPXE boot scripts,
-   raw ISOs (with Range), and files inside ISOs without prior extraction.
-4. **ISO introspection**: auto-detects the distro family and generates the
-   appropriate kernel+initrd or wimboot chain. No manual config.
-5. **Hierarchical PXE menu** mirroring the Phase 2 spec:
-   ```
-   Default        > Boot from Local HDD
-   Installers     > Linux Installers  / Windows Installers
-   Tools          > Utilities / OpenPXE Shell / Network Card Info
-   Queued Deployment
-   ```
-6. **Queued Deployment queue** — the coordinated launch flow. A client that
-   selects *Queued Deployment* gets a numbered position and waits. The
-   operator picks an ISO in the web UI and fires it to every waiting
-   client simultaneously.
-7. **Web UI** (Netbox-style): sidebar nav (Dashboard / Network / Queue /
-   Storage / Hosts / Terminal / About), light + dark themes
-   (toggle top-right or press `T`), animated OpenPXE progress
-   widget when devices are imaging. All assets served from the binary —
-   no external requests.
-8. **Per-MAC host bindings.** Pin a MAC to a boot target and the client
-   skips the menu, chains straight through.
-9. **Prometheus metrics** at `/metrics` — DHCP replies by arch, TFTP
-   transfer counts and bytes, HTTP request counts by route, queue /
-   imaging gauges, uptime, build info. Plain text exposition format,
-   no external metrics framework dependency.
-8. **Settings API** lets you change the default boot-menu timeout (default
-   600s), the timeout action (stay / Local HDD / Queued Deployment), and
-   feature toggles like Windows ISO support. The iPXE scripts regenerate
-   on every request using current settings.
 
-### Architectures supported on day one
+Upload `.iso` files (or point at a remote share), and any machine on the network boots
+them — Linux installers, live tools, or stock Windows setup — with **zero iPXE knowledge
+required by the operator.**
 
-| DHCP option 93 | Architecture    | Binary served           |
+> **Status — v0.6.0, late pre-beta.** The full PXE stack, web UI, remote ISO libraries
-|----------------|-----------------|-------------------------|
+> (SMB/NFS/SFTP), Windows deployment, queued fleet rollout, SAML SSO, and Prometheus
-| `0x0000`       | Legacy x86 BIOS | `undionly.kpxe`         |
+> metrics are implemented and test-covered. The release checklist gates every tag on the
-| `0x0006`       | IA32 UEFI       | `snponly-i386.efi`      |
+> full test suite + `clippy`. Currently in real-hardware validation.
-| `0x0007`/`0x0009` | x86_64 UEFI  | `snponly.efi`           |
-| `0x000B`       | ARM64 UEFI      | `snponly-arm64.efi`     |
 
-UEFI firmware that sends `HTTPClient` in option 60 is handled too — we
+## Why OpenPXE
-skip TFTP and respond with an HTTP URL.
 
-## Quick start — MVP container (recommended)
+Standing up network boot the traditional way means hand-wiring `dnsmasq`, a TFTP daemon,
+hand-written iPXE menu scripts, an HTTP server, and Samba — then keeping that fragile
+stack alive, and discovering none of it containerizes cleanly (kernel-mount NFS, raw
+sockets, `CAP_SYS_ADMIN`). iVentoy solved the UX beautifully, but it's a Windows GUI app.
+
+OpenPXE collapses that whole stack into **one statically-linked binary in one container**:
+
+- **A web UI does everything.** iPXE is an internal implementation detail — there is no
+  script upload, no `.ipxe` editing, no PXE jargon in the interface.
+- **It runs anywhere a container runs.** No kernel modules, no privileged mode — proxy-mode
+  DHCP + `NET_BIND_SERVICE` is the entire requirement. Verified on Unraid, plain Docker,
+  and OpenShift's restricted SCC.
+- **It's air-gap native.** Zero CDN assets, zero outbound calls from the server, browser,
+  or generated boot scripts. Build the image once, run it forever, disconnected.
+
+## Highlights
+
+#### Boot stack
+- **DHCP proxy** (RFC 4578) that coexists with your existing DHCP — it never hands out IPs.
+- **TFTP** (RFC 1350 + 2347/2348/2349/7440 option negotiation) serving arch-correct iPXE firmware.
+- **HTTP** serving the UI, generated boot scripts, raw ISOs (with byte-range), and files
+  *inside* ISOs with no prior extraction.
+- **Graphical iPXE boot menu** built from your uploads, with a PNG background and a clean
+  hierarchy — generated fresh on every request from current settings.
+
+#### ISO management & remote libraries
+- **Drag-and-drop chunked uploads** that don't 502 on multi-GB images.
+- **Automatic introspection** — detects the distro family and generates the right
+  kernel+initrd or Windows `wimboot` chain. No manual config.
+- **Remote ISO libraries, streamed on demand** (no local cache) over **SMB, NFS, or SFTP** —
+  see the table below.
+
+#### Fleet deployment
+- **Queued Deployment** — clients join a queue and wait; the operator fires one image at
+  every waiting machine simultaneously.
+- **Per-MAC host bindings** — pin a MAC straight to a target (with optional auto hostname,
+  auto IP, and an unattended answer file); it skips the menu and chains through.
+- **Unattended installs** — upload Kickstart / Preseed / Autoinstall / Windows answer files;
+  they're templated per-host (hostname / IP / MAC) and served only to booting clients.
+- **Windows deployment** from a stock Microsoft ISO — **every binary the client runs stays
+  Microsoft-signed** (details below).
+
+#### Operations & access
+- **SAML 2.0 single sign-on** (pure-Rust SP, no OpenSSL/xmlsec) alongside local accounts.
+- **Custom branding** — light / dark / PXE-client logos and favicon.
+- **Notifications** — Slack / Teams / Discord webhooks and SMTP email on boot events.
+- **Prometheus `/metrics`**, a built-in operator **terminal**, live tracing log, and
+  `/healthz` · `/readyz` probes.
+- **Layered config** — defaults → TOML file → `OPENPXE_*` env, in that order.
+
+## Built in Rust
+
+Rust isn't a checkbox here — it's why OpenPXE deploys the way it does:
+
+- **One static binary, ~18 MB.** Compiled to `x86_64-unknown-linux-musl` — no glibc, no
+  interpreter, no sidecar runtime. The runtime image is "binary + a few CLI tools."
+- **No garbage collector, async throughout.** A Tokio runtime drives DHCP, TFTP, HTTP, and
+  many concurrent multi-GB ISO streams on a tiny, predictable memory footprint — it idles
+  near-zero and never GC-pauses mid-transfer.
+- **Memory-safe by construction.** `unsafe` is **denied workspace-wide**; the only
+  exceptions are two small, individually-audited FFI calls (`statvfs` for disk usage and a
+  Samba `SIGHUP`).
+- **OpenSSL-free, pure-Rust crypto.** TLS via `rustls`/`ring`; the SAML Service Provider
+  does XML-DSig verification with RustCrypto — no `xmlsec`, no `libxml2`, no C crypto to
+  CVE-patch. Even the SMB/NFS/SFTP clients avoid C libraries.
+- **Sub-minute, reproducible container builds.** Cross-compiled with `cargo-zigbuild`
+  (zig as the linker) — a full image builds in well under a minute on a warm cache, with
+  no QEMU emulation.
+
+## Quick start
+
+### Run the container
 
 ```bash
-# 1. Pull bundled iPXE binaries (~2 MB, one-time).
+# Build the self-contained image (iPXE binaries are fetched + built inside the Dockerfile).
-./scripts/fetch-ipxe.sh
+docker build -f deploy/docker/Dockerfile -t openpxe:0.5.5 .
 
-# 2. Build the container image (~3 min first time).
+# Run it on the box plugged into your PXE network. Host networking is required in
-docker buildx build -f deploy/docker/Dockerfile -t openpxe:0.4.1 --load .
+# proxy mode so the container sees DHCPDISCOVER broadcasts; set PUBLIC_IP to this
-
+# host's LAN address so advertised boot URLs are reachable.
-# 3. Run it on the box plugged into your PXE network. Set PUBLIC_IP to
+docker run -d --name openpxe --network host \
-#    this host's LAN address so advertised iPXE URLs are reachable.
-docker run -d --name openpxe \
-  --network host \
   -e OPENPXE_PUBLIC_IP=10.0.0.5 \
   -e OPENPXE_DHCP_MODE=proxy \
   -v $PWD/data/isos:/var/lib/openpxe/isos \
   -v $PWD/data/work:/var/lib/openpxe/work \
-  openpxe:0.4.1
+  openpxe:0.5.5
 
-# 4. Open the UI and drop an ISO in.
+# Open the UI and drop an ISO in.
 open http://10.0.0.5
 ```
 
-Host networking is required in proxy mode so the container sees DHCPDISCOVER
+> On macOS/Windows, Docker runs inside a Linux VM, so "host network" means the VM — use
-broadcasts from the PXE VLAN. On macOS/Windows hosts Docker runs in a Linux
+> the `openpxe-dev` service in `docker-compose.yml` for API-only testing on a laptop:
-VM, so "host" means the VM — use `openpxe-dev` in `docker-compose.yml` for
+> `OPENPXE_PUBLIC_IP=127.0.0.1 docker compose up openpxe-dev`.
-API-only testing on a laptop.
 
-### Quick start — docker compose
+### Build from source
 
 ```bash
-# MVP / API testing on a laptop (no DHCP, high ports):
+./scripts/fetch-ipxe.sh          # populate assets/ipxe/ (embedded at compile time)
-OPENPXE_PUBLIC_IP=127.0.0.1 docker compose up openpxe-dev
+cargo run --release              # needs root or CAP_NET_BIND_SERVICE for :80/:69
-# Real PXE deployment on a Linux host (host network, DHCP proxy on):
-OPENPXE_PUBLIC_IP=10.0.0.5  docker compose up openpxe
 ```
 
-### Multi-arch build + push
+### Pre-seed ISOs from a directory
-
-For deploying to x86_64 servers, build both arches in one manifest:
-
-```bash
-# One-time: bootstrap a multi-arch builder.
-docker buildx create --name openpxe-multi --driver docker-container --use
-
-# Build + push both linux/amd64 and linux/arm64 under one tag.
-docker buildx build --builder openpxe-multi \
-  --platform linux/amd64,linux/arm64 \
-  -t ghcr.io/YOUR-ORG/openpxe:0.4.1 \
-  --push \
-  -f deploy/docker/Dockerfile .
-```
-
-On an Apple Silicon host, the amd64 stage runs under QEMU emulation (~10-15 min for a cold cache). On a Linux x86_64 host, both arches build natively at normal speed. CI runners on GitHub Actions with `docker/build-push-action@v5` handle this cleanly.
-
-### Build from source (no container)
-
-```bash
-./scripts/fetch-ipxe.sh
-cargo run --release            # needs NET_BIND_SERVICE or root for :80/:69
-```
-
-### Container health probes
-
-| Endpoint    | Purpose                                                       |
-|-------------|---------------------------------------------------------------|
-| `/healthz`  | Liveness — HTTP stack alive. Always 200.                      |
-| `/readyz`   | Readiness — 200 only if iPXE binaries bundled + ISO dir OK.   |
-| `/api/status` | Full JSON status: versions, assets, counts, live settings, SMB state. |
-
-### Pre-seeding ISOs from a directory
-
-For CI, pre-baked homelab deployments, or a fresh PVC, the binary has a
-`seed` subcommand that imports every `*.iso` from a host path through the
-same pipeline the web UI uses (introspection + boot-entry generation):
 
 ```bash
 docker run --rm \
   -v /my/iso-library:/seed:ro \
   -v openpxe-data:/var/lib/openpxe/isos \
   -e OPENPXE_PUBLIC_IP=10.0.0.5 \
-  openpxe:0.4.1 seed --from /seed
+  openpxe:0.5.5 seed --from /seed          # add --dry-run to preview
-
-# Dry run first to see what would be imported:
-docker run --rm -v /my/iso-library:/seed:ro openpxe:0.4.1 seed --from /seed --dry-run
 ```
 
-### Environment overrides
+## Remote ISO libraries
 
-| Var                    | Default                     | Meaning                                |
+Point OpenPXE at a NAS and boot ISOs straight off it — **read on demand, no local copy**,
-|------------------------|-----------------------------|----------------------------------------|
+so a 50-ISO library costs zero disk on the OpenPXE host. All three clients are userspace
-| `OPENPXE_HTTP_PORT`   | `80`                        | Web UI + boot script HTTP port         |
+(no kernel mounts, no `CAP_SYS_ADMIN`); pick whichever your storage speaks.
-| `OPENPXE_TFTP_PORT`   | `69`                        | TFTP port                              |
-| `OPENPXE_DHCP_PORT`   | `67`                        | DHCP server-side port                  |
-| `OPENPXE_DHCP_MODE`   | `proxy`                     | `proxy` or `disabled`                  |
-| `OPENPXE_PUBLIC_IP`   | auto-detect                 | Advertised IP for clients. Startup **fails** if unset and auto-detect returns loopback. |
-| `OPENPXE_ISO_DIR`     | `/var/lib/openpxe/isos`    | Where uploaded ISOs live               |
-| `OPENPXE_WORK_DIR`    | `/var/lib/openpxe/work`    | Scratch + runtime settings             |
-| `OPENPXE_LOG`         | `info,openpxe=debug`       | `tracing` filter                       |
 
-## What the boot menu looks like on a real client
+| Protocol | Implementation | Auth | HTTP Range¹ |
+|----------|----------------|------|-------------|
+| **NFS** (v3) | Pure-Rust in-process client | Client-IP (server export list) | ✅ |
+| **SFTP** (SSH) | Pure-Rust in-process client (`russh`) | Password **or** SSH key · host-key TOFU | ✅ |
+| **SMB** / CIFS | Userspace `smbclient` | Guest or username/password | — |
+
+¹ Range support lets clients seek into a multi-GB ISO without downloading what comes
+before it — needed for kernel/initrd extraction and `httpdisk`-style boots. NFS and SFTP
+expose explicit offsets; the SMB CLI streams sequentially, so SMB-sourced ISOs serve whole-file.
+
+## Supported client architectures
+
+| DHCP option 93 | Architecture | Firmware served |
+|----------------|--------------|-----------------|
+| `0x0000` | Legacy x86 BIOS | `undionly.kpxe` |
+| `0x0006` | IA32 UEFI | `snponly-i386.efi` |
+| `0x0007` / `0x0009` | x86_64 UEFI | `snponly.efi` |
+| `0x000B` | ARM64 UEFI | `snponly-arm64.efi` |
+
+UEFI firmware that advertises `HTTPClient` (option 60) skips TFTP entirely and is handed an HTTP URL.
+
+## The boot menu, on a real client
 
 ```
-                        OpenPXE - network boot menu
+                        OpenPXE — network boot menu
 
  ------------------------- Default -------------------------
  Boot from Local HDD
- ----------------------- Installers -----------------------
+ ----------------------- Installers ------------------------
  Linux Installers   >
  Windows Installers >                (only if enabled in Settings)
  -------------------------- Tools --------------------------
- Tools              >                Utilities / Shell /
+ Tools              >    Utilities / OpenPXE Shell / NIC Info / Reboot
-                                     NIC Info / Reboot /
-                                     Exit and continue BIOS
  ---------------------- Queued Deployment ------------------
  Queued Deployment   (join queue)
 ```
 
-Linux/Windows submenus show file sizes iVentoy-style:
+Linux/Windows submenus list images iVentoy-style with sizes:
 
 ```
-                   OpenPXE - Linux Installers
+                   OpenPXE — Linux Installers
 
- [  4376 MB]  CentOS-7-x86_64-DVD-1810
- [  2002 MB]  Fedora-Workstation-Live-x86_64-38-1.6
  [  4699 MB]  ubuntu-22.04.2-desktop-amd64
+ [  2002 MB]  Fedora-Workstation-Live-x86_64-38-1.6
             < Back to main menu
 ```
 
-iPXE never appears in the UI — the whole hierarchy above is generated from
+The entire hierarchy is generated from what you upload and toggle — iPXE never surfaces.
-ISOs you upload via drag-and-drop in the web UI plus toggles in Settings.
+
+## Windows deployment
+
+Enable **Windows ISO support** in Settings, then upload a **stock, unmodified** Microsoft ISO:
+
+1. On upload, OpenPXE uses `wimlib-imagex` to inject exactly two plain-text files into the
+   WinPE image (`winpeshl.ini` + `startnet.cmd`) — no drivers, no certificates.
+2. The container's Samba `smbd` serves the extracted install tree on `:445`.
+3. The client chainloads `wimboot` → patched WinPE → Windows Setup running off the share.
+
+**Every executable the client runs is stock Microsoft-signed.** OpenPXE never ships
+drivers, never installs certificates into the client trust store, and never recommends
+`bcdedit /set testsigning on`. The SMB approach is adapted (re-implemented, not copied)
+from [Bootimus](https://github.com/garybowers/bootimus) (Apache-2.0). Port `445` must be
+directly reachable from clients; Windows 10/11 client SKUs are the tested target.
+
+## Configuration
+
+All settings have defaults and layer **defaults → TOML (`--config` / `OPENPXE_CONFIG`) →
+`OPENPXE_*` env**. The common knobs:
+
+| Var | Default | Meaning |
+|-----|---------|---------|
+| `OPENPXE_PUBLIC_IP` | auto-detect | IP advertised to clients. **Startup fails** if unset and auto-detect yields loopback. |
+| `OPENPXE_DHCP_MODE` | `proxy` | `proxy` or `disabled` |
+| `OPENPXE_HTTP_PORT` | `80` | Web UI + boot-script HTTP port |
+| `OPENPXE_TFTP_PORT` | `69` | TFTP port |
+| `OPENPXE_DHCP_PORT` | `67` | DHCP server-side port |
+| `OPENPXE_ISO_DIR` | `/var/lib/openpxe/isos` | Uploaded ISOs |
+| `OPENPXE_WORK_DIR` | `/var/lib/openpxe/work` | Scratch, settings, share + branding state |
+| `OPENPXE_LOG` | `info,openpxe=info` | `tracing` filter |
 
 ## OpenShift
 
 ```bash
 oc apply -f deploy/openshift/
-oc -n openpxe get all
 oc -n openpxe get route openpxe -o jsonpath='{.spec.host}'
 ```
 
-### Why a custom SCC?
+The bundled `openpxe-scc` grants exactly `hostNetwork` (CNI overlays don't deliver L2
+broadcast into pod netns) and `NET_BIND_SERVICE` (to bind ports <1024) — nothing else.
+No raw sockets, no privileged mode. The Route covers `80/TCP`; PXE clients reach UDP
+67/69/4011 on the node's host IP directly.
 
-The default `restricted-v2` blocks `hostNetwork` and all capabilities. PXE
+## Health & observability
-cannot work without host network (CNI overlays don't deliver L2 broadcast
-into pod netns), and we need `NET_BIND_SERVICE` to bind <1024. The custom
-`openpxe-scc` grants exactly those two and nothing else. No raw sockets,
-no privileged mode — proxy-mode DHCP sidesteps the usual requirements.
 
-### What's on host ports
+| Endpoint | Purpose |
-
+|----------|---------|
-| Port     | Proto | Purpose                         |
+| `/healthz` | Liveness — always 200 if the HTTP stack is up. |
-|----------|-------|---------------------------------|
+| `/readyz` | Readiness — 200 only once iPXE firmware is bundled and the ISO dir is reachable. |
-| 67       | UDP   | DHCP server (proxy replies)     |
+| `/api/status` | Full JSON: version, assets, counts, live settings, share + SMB state. |
-| 69       | UDP   | TFTP                            |
+| `/metrics` | Prometheus text format — DHCP replies by arch, TFTP/HTTP counts, queue gauges, uptime. |
-| 4011     | UDP   | PXE Boot Server discovery       |
-| 80       | TCP   | Web UI + HTTP boot assets       |
-
-The OpenShift Route only covers 80/TCP. Clients on the PXE network talk to
-the node's host IP directly for UDP.
-
-## Windows support
-
-Enabled by toggling **Windows ISO support** under Settings. The flow:
-
-1. Upload a stock Microsoft Windows install ISO (vanilla, no pre-processing).
-2. On upload, OpenPXE extracts the ISO and uses `wimlib-imagex` to rewrite
-   image index 2 (WinPE) of `sources/boot.wim`. It injects exactly two
-   plain-text files:
-   - `Windows/System32/winpeshl.ini` — tells WinPE to run `startnet.cmd`.
-   - `Windows/System32/startnet.cmd` — runs `wpeinit`, waits for the SMB
-     host to be reachable, `net use Z: \\<server>\<share> /user:guest`,
-     then `Z:\setup.exe`.
-3. The container's Samba `smbd` serves the extracted install tree on :445.
-4. The client gets chainloaded into wimboot → patched WinPE → Windows Setup
-   running off the SMB share. **Every binary the client executes is stock
-   Microsoft-signed.**
-
-### What we never do
-
-- Ship drivers — signed, test-signed, or otherwise — that load on the client.
-- Install certificates into the target's trust store or WinPE boot policy.
-- Recommend `bcdedit /set testsigning on` or any equivalent signing-policy
-  weakening.
-
-### Credit & limitations
-
-The SMB-based approach is adapted from [Bootimus](https://github.com/garybowers/bootimus)
-(Apache-2.0). Re-implemented in Rust; no code was copied verbatim. Known
-operational constraints inherited from the design:
-
-- **Port 445 must be directly reachable from PXE clients.** `net use`
-  ignores alternate ports. In OpenShift this means `hostPort: 445` on the
-  deployment; on a host that already runs SMB it will collide.
-- Windows 10/11 client SKUs are the tested target. Server SKUs untested.
-- Hardware with NICs/storage controllers missing from WinPE's bundled
-  drivers will need a driver-pack injection step (not yet implemented).
-
-## Queued Deployment
-
-The coordinated launch flow, end to end:
-
-1. A client boots and picks **Queued Deployment** in the PXE menu (or falls
-   through on timeout with the default `timeout_action`).
-2. The client joins the queue, gets a numbered queue position, and enters a
-   long-poll loop (25s per request, auto-renewed).
-3. In the web UI's **Queued Deployment** tab, the operator sees each waiting
-   client with its MAC, IP, arch, and position.
-4. The operator selects an image and clicks **Launch for all waiting**.
-   The server broadcasts the assignment to every queued client via a
-   `tokio::sync::Notify`; each client's next poll returns the boot script
-   for the chosen image.
-5. Every client chains the same image at effectively the same moment. The
-   queue stays visible until the operator releases entries, which keeps a
-   useful audit trail during hardware testing.
-
-No user-facing iPXE anywhere in this flow. The client only ever runs
-scripts we generate; the operator only interacts with the web UI.
 
 ## Architecture
 
-See [`docs/architecture.md`](docs/architecture.md) for the protocol stack,
+Workspace of focused crates — `core`, `dhcp-proxy`, `tftp`, `http-api`, `iso-store`,
-crate layout, and the full decision log.
+`ipxe-assets`, `webui`, and the `openpxe` binary. See
+[`docs/architecture.md`](docs/architecture.md) for the protocol stack, crate layout, and
+the full decision log.
 
-## Licence
+## License
 
-MIT OR Apache-2.0.
+Dual-licensed under **MIT OR Apache-2.0** — use whichever fits your project.

crates/core/Cargo.toml

@@ -13,6 +13,7 @@ workspace = true
 serde.workspace = true
 serde_json.workspace = true
 toml.workspace = true
+figment.workspace = true
 thiserror.workspace = true
 anyhow.workspace = true
 tracing.workspace = true
@@ -38,6 +39,9 @@ base64.workspace = true
 
 [dev-dependencies]
 tempfile = "3.12"
+# v0.5.4: figment's `Jail` (hermetic env/file sandbox) for the config
+# loader tests lives behind the `test` feature.
+figment = { workspace = true, features = ["test"] }
 # v0.5.1: generate a throwaway self-signed signing cert/key so SAML
 # verification tests can produce genuinely signed SAMLResponses.
 rcgen = "0.13"

crates/core/src/arch.rs

@@ -23,6 +23,36 @@ pub enum ClientArch {
     Unknown(u16),
 }
 
+/// Which boot binary family to advertise to a client (v0.6.1, extended
+/// v0.7.0).
+///
+/// OpenPXE serves [`DriverMode::Firmware`] first (the firmware's own NIC
+/// stack, via `snponly`/`undionly`) and escalates a specific MAC
+/// automatically when a boot never completes its handoff:
+/// `Firmware → Builtin → Shim`. There is no operator toggle — the DHCP
+/// proxy decides per client.
+///
+/// The `Shim` rung (v0.7.0) covers Secure Boot: firmware with SB enabled
+/// downloads our unsigned iPXE fine but refuses to *execute* it, which
+/// looks exactly like a failed chainload. After both iPXE builds go
+/// unconfirmed, the client is offered the Microsoft-signed shim, which
+/// loads the signed GRUB, which fetches a server-rendered menu — a fully
+/// signed chain that boots signed distro kernels with SB still on.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DriverMode {
+    /// Reuse the firmware UNDI/SNP NIC stack (`snponly.efi`, `undionly.kpxe`).
+    /// Default, smallest, most reliable for chainloading.
+    #[default]
+    Firmware,
+    /// iPXE's own bundled NIC drivers (`ipxe.efi`, `ipxe.pxe`). Fallback for
+    /// hardware whose firmware NIC stack is missing or buggy.
+    Builtin,
+    /// Microsoft-signed shim + GRUB chain (`shimx64.efi`). Final fallback
+    /// for Secure-Boot-enabled UEFI clients that refuse unsigned iPXE.
+    Shim,
+}
+
 impl ClientArch {
     #[must_use]
     pub fn from_option_93(value: u16) -> Self {
@@ -39,21 +69,73 @@ impl ClientArch {
     /// Default iPXE binary filename to return via TFTP for this architecture.
     /// Uses `snponly` variants which reuse the firmware's UNDI/SNP network
     /// stack — smaller binaries and broader hardware compatibility than the
-    /// all-drivers-included `ipxe.efi`.
+    /// all-drivers-included `ipxe.efi`. Equivalent to
+    /// [`Self::ipxe_bootfile_mode`] with [`DriverMode::Firmware`]; kept as a
+    /// convenience for the common firmware-net path.
     #[must_use]
     pub fn ipxe_bootfile(self) -> Option<&'static str> {
-        Some(match self {
+        self.ipxe_bootfile_mode(DriverMode::Firmware)
-            Self::LegacyX86 => "undionly.kpxe",
+    }
-            Self::Ia32Uefi => "snponly-i386.efi",
+
-            Self::X64Uefi => "snponly.efi",
+    /// iPXE binary filename for this architecture under a given network
-            // ARM32 UEFI: upstream boot.ipxe.org does not publish a prebuilt
+    /// [`DriverMode`].
-            // snponly variant for this arch. We return None so the DHCP
+    ///
-            // proxy declines rather than advertising a file we can't serve.
+    /// * [`DriverMode::Firmware`] — the `snponly`/`undionly` builds that reuse
-            Self::Arm32Uefi | Self::Unknown(_) => return None,
+    ///   the firmware's UNDI/SNP NIC stack. Smallest, and the most reliable
-            Self::Arm64Uefi => "snponly-arm64.efi",
+    ///   choice for chainloading because the firmware just proved its network
+    ///   works by downloading the NBP. This is the default first attempt.
+    /// * [`DriverMode::Builtin`] — the all-drivers `ipxe.efi`/`ipxe.pxe`
+    ///   builds that carry iPXE's *own* NIC drivers. The automatic fallback
+    ///   for clients whose firmware NIC stack is missing or buggy (v0.6.1):
+    ///   the DHCP proxy escalates a MAC to this mode when a firmware-net boot
+    ///   never completes the iPXE handoff. iPXE still includes the `snp`
+    ///   driver here too, so it degrades gracefully.
+    #[must_use]
+    pub fn ipxe_bootfile_mode(self, mode: DriverMode) -> Option<&'static str> {
+        Some(match (self, mode) {
+            // Legacy x86 BIOS: UNDI (firmware) vs full native-driver build.
+            (Self::LegacyX86, DriverMode::Firmware) => "undionly.kpxe",
+            (Self::LegacyX86, DriverMode::Builtin) => "ipxe.pxe",
+            // IA32 UEFI.
+            (Self::Ia32Uefi, DriverMode::Firmware) => "snponly-i386.efi",
+            (Self::Ia32Uefi, DriverMode::Builtin) => "ipxe-i386.efi",
+            // No signed Shim chain for BIOS (no Secure Boot there) or
+            // IA32 UEFI (Fedora publishes no 32-bit shim; SB-on IA32
+            // clients are vanishingly rare). Same outcome as the
+            // no-binary arches below, listed separately for the comment.
+            #[allow(clippy::match_same_arms)]
+            (Self::LegacyX86 | Self::Ia32Uefi, DriverMode::Shim) => return None,
+            // x86_64 UEFI — the overwhelmingly common modern client.
+            (Self::X64Uefi, DriverMode::Firmware) => "snponly.efi",
+            (Self::X64Uefi, DriverMode::Builtin) => "ipxe.efi",
+            (Self::X64Uefi, DriverMode::Shim) => "shimx64.efi",
+            // ARM64 UEFI.
+            (Self::Arm64Uefi, DriverMode::Firmware) => "snponly-arm64.efi",
+            (Self::Arm64Uefi, DriverMode::Builtin) => "ipxe-arm64.efi",
+            (Self::Arm64Uefi, DriverMode::Shim) => "shimaa64.efi",
+            // ARM32 UEFI: upstream boot.ipxe.org publishes no prebuilt binary
+            // for this arch in any mode. Unknown arches likewise. Return
+            // None so the DHCP proxy declines rather than advertising a file
+            // we can't serve.
+            (Self::Arm32Uefi | Self::Unknown(_), _) => return None,
         })
     }
 
+    /// Like [`Self::ipxe_bootfile_mode`], but walks back down the
+    /// escalation ladder (`Shim → Builtin → Firmware`) when the requested
+    /// mode has no binary for this arch — e.g. a BIOS client whose
+    /// escalation state reached `Shim` (BIOS has no Secure Boot) falls
+    /// back to the all-drivers build instead of being ignored.
+    #[must_use]
+    pub fn bootfile_with_fallback(self, mode: DriverMode) -> Option<&'static str> {
+        let ladder: &[DriverMode] = match mode {
+            DriverMode::Shim => &[DriverMode::Shim, DriverMode::Builtin, DriverMode::Firmware],
+            DriverMode::Builtin => &[DriverMode::Builtin, DriverMode::Firmware],
+            DriverMode::Firmware => &[DriverMode::Firmware],
+        };
+        ladder.iter().find_map(|m| self.ipxe_bootfile_mode(*m))
+    }
+
     #[must_use]
     pub fn as_str(self) -> &'static str {
         match self {
@@ -133,6 +215,103 @@ mod tests {
         assert_eq!(ClientArch::Unknown(0xFFFF).ipxe_bootfile(), None);
     }
 
+    #[test]
+    fn bootfile_default_is_firmware_mode() {
+        // The convenience method must equal the explicit Firmware mode.
+        for a in [
+            ClientArch::LegacyX86,
+            ClientArch::Ia32Uefi,
+            ClientArch::X64Uefi,
+            ClientArch::Arm64Uefi,
+            ClientArch::Arm32Uefi,
+            ClientArch::Unknown(0x99),
+        ] {
+            assert_eq!(
+                a.ipxe_bootfile(),
+                a.ipxe_bootfile_mode(DriverMode::Firmware)
+            );
+        }
+    }
+
+    #[test]
+    fn builtin_mode_maps_to_all_drivers_binaries() {
+        assert_eq!(
+            ClientArch::LegacyX86.ipxe_bootfile_mode(DriverMode::Builtin),
+            Some("ipxe.pxe")
+        );
+        assert_eq!(
+            ClientArch::X64Uefi.ipxe_bootfile_mode(DriverMode::Builtin),
+            Some("ipxe.efi")
+        );
+        assert_eq!(
+            ClientArch::Ia32Uefi.ipxe_bootfile_mode(DriverMode::Builtin),
+            Some("ipxe-i386.efi")
+        );
+        assert_eq!(
+            ClientArch::Arm64Uefi.ipxe_bootfile_mode(DriverMode::Builtin),
+            Some("ipxe-arm64.efi")
+        );
+        // No binary for ARM32 / unknown in either mode.
+        assert_eq!(
+            ClientArch::Arm32Uefi.ipxe_bootfile_mode(DriverMode::Builtin),
+            None
+        );
+        assert_eq!(
+            ClientArch::Unknown(0x99).ipxe_bootfile_mode(DriverMode::Builtin),
+            None
+        );
+    }
+
+    #[test]
+    fn driver_mode_default_is_firmware() {
+        assert_eq!(DriverMode::default(), DriverMode::Firmware);
+    }
+
+    #[test]
+    fn shim_mode_maps_to_signed_chain_on_uefi_only() {
+        assert_eq!(
+            ClientArch::X64Uefi.ipxe_bootfile_mode(DriverMode::Shim),
+            Some("shimx64.efi")
+        );
+        assert_eq!(
+            ClientArch::Arm64Uefi.ipxe_bootfile_mode(DriverMode::Shim),
+            Some("shimaa64.efi")
+        );
+        // No Secure Boot on BIOS, no published 32-bit shim.
+        assert_eq!(
+            ClientArch::LegacyX86.ipxe_bootfile_mode(DriverMode::Shim),
+            None
+        );
+        assert_eq!(
+            ClientArch::Ia32Uefi.ipxe_bootfile_mode(DriverMode::Shim),
+            None
+        );
+    }
+
+    #[test]
+    fn fallback_walks_down_the_ladder() {
+        // BIOS escalated to Shim → falls back to the all-drivers build.
+        assert_eq!(
+            ClientArch::LegacyX86.bootfile_with_fallback(DriverMode::Shim),
+            Some("ipxe.pxe")
+        );
+        // UEFI x64 at Shim gets the real shim.
+        assert_eq!(
+            ClientArch::X64Uefi.bootfile_with_fallback(DriverMode::Shim),
+            Some("shimx64.efi")
+        );
+        // Plain modes are unchanged.
+        assert_eq!(
+            ClientArch::X64Uefi.bootfile_with_fallback(DriverMode::Firmware),
+            Some("snponly.efi")
+        );
+        // Arches with nothing stay None.
+        assert_eq!(
+            ClientArch::Arm32Uefi.bootfile_with_fallback(DriverMode::Shim),
+            None
+        );
+    }
+
     #[test]
     fn firmware_class_detects_ipxe_over_pxeclient() {
         let c = FirmwareClass::classify(Some(b"PXEClient:Arch:00007"), Some(b"iPXE"));

crates/core/src/auth.rs

@@ -125,9 +125,7 @@ impl AdminStore {
         {
             let mut g = self.inner.write();
             if g.admin.is_some() {
-                return Err(Error::Invalid(
+                return Err(Error::Invalid("admin account already configured".into()));
-                    "admin account already configured".into(),
-                ));
             }
             g.admin = Some(admin.clone());
         }
@@ -346,7 +344,7 @@ mod tests {
         assert!(s.bootstrap("", "hunter2hunter2").is_err());
         assert!(s.bootstrap("ad:min", "hunter2hunter2").is_err()); // ':' reserved
         assert!(s.bootstrap("admin", "short").is_err()); // <8 chars
-        // 65-char username is too long.
+                                                         // 65-char username is too long.
         let long = "a".repeat(65);
         assert!(s.bootstrap(&long, "hunter2hunter2").is_err());
     }

crates/core/src/boot_rules.rs

@@ -0,0 +1,369 @@
+//! Label-based boot rules + boot-decision webhook (v0.7.0).
+//!
+//! Generalizes [`crate::host_bindings::HostBindings`] (exact-MAC pins)
+//! into ordered, first-match-wins rules over what the boot chain knows
+//! about a client — MAC prefix (OUI or longer) and firmware
+//! architecture — plus an optional outbound webhook so external
+//! automation (CMDB, netbox, a shell script) can decide the boot target
+//! per machine, pixiecore-style.
+//!
+//! Decision order in the boot script handler, most-specific first:
+//!   1. exact per-MAC host binding (operator pin)
+//!   2. first matching enabled rule here
+//!   3. webhook, if configured (fail-open: timeout/error → menu)
+//!   4. interactive menu
+//!
+//! With no rules and no webhook configured the behavior is byte-for-byte
+//! what it was before this feature existed — no toggles to flip.
+//!
+//! Persisted to `<work_dir>/boot_rules.json` with the same "in-memory
+//! authoritative, disk is a crash cache, corruption falls back to empty"
+//! policy as the host bindings — a bad rules file must never block PXE.
+
+use crate::host_bindings::normalize_mac;
+use parking_lot::RwLock;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+/// One ordered rule. All present (non-empty) selectors must match —
+/// empty selector fields match anything, so a rule with only `arch` set
+/// applies to every client of that architecture.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BootRule {
+    /// Case-insensitive MAC prefix, `:`-separated (e.g. `dc:a6:32` for
+    /// an OUI, or longer). Empty = any MAC.
+    #[serde(default)]
+    pub mac_prefix: String,
+    /// Client architecture selector — matches `ClientArch::as_str()`
+    /// (`bios`, `uefi-x64`, `uefi-ia32`, `uefi-arm64`). Empty = any.
+    #[serde(default)]
+    pub arch: String,
+    /// Boot entry id (a `BootEntry::id`) or reserved menu name
+    /// (`_local`, `_queue`, …) to chain to when this rule matches.
+    /// May be empty for a rule that only pins a driver mode.
+    #[serde(default)]
+    pub target: String,
+    /// v0.7.1: optional first-boot binary pin — `""` (auto: let the
+    /// escalation ladder decide), `"firmware"`, `"builtin"`, or
+    /// `"shim"`. Lets an operator declare "this rack is all Secure
+    /// Boot → serve the signed chain immediately", skipping the
+    /// learn-by-failing walk entirely for known fleets.
+    #[serde(default)]
+    pub driver_mode: String,
+    /// Rules can be parked without deleting them.
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    /// Operator note shown in the UI (`"all Pi 4s"`, `"QA rack"`).
+    #[serde(default)]
+    pub note: String,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+/// The whole persisted config: ordered rules + optional webhook.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(default)]
+pub struct BootRulesConfig {
+    pub rules: Vec<BootRule>,
+    /// Optional boot-decision webhook URL. When set, unmatched boots GET
+    /// `<url>?mac=<mac>&arch=<arch>` and a `200 {"target": "<id>"}`
+    /// reply chains to that target. Anything else (404, timeout, bad
+    /// JSON) falls through to the menu. Empty = disabled.
+    pub webhook_url: String,
+}
+
+/// Store for the rules config. Cheap to clone; locks held briefly.
+#[derive(Debug, Clone)]
+pub struct BootRulesStore {
+    path: Arc<PathBuf>,
+    inner: Arc<RwLock<BootRulesConfig>>,
+}
+
+impl BootRulesStore {
+    /// Load from `work_dir/boot_rules.json`, or start empty if absent /
+    /// unreadable.
+    #[must_use]
+    pub fn load_or_default(work_dir: &std::path::Path) -> Self {
+        let path = work_dir.join("boot_rules.json");
+        let inner = match std::fs::read_to_string(&path) {
+            Ok(text) => match serde_json::from_str::<BootRulesConfig>(&text) {
+                Ok(cfg) => cfg,
+                Err(e) => {
+                    tracing::warn!(
+                        target: "openpxe::boot_rules",
+                        "boot_rules.json present but unreadable ({e}); starting empty"
+                    );
+                    BootRulesConfig::default()
+                }
+            },
+            Err(_) => BootRulesConfig::default(),
+        };
+        Self {
+            path: Arc::new(path),
+            inner: Arc::new(RwLock::new(inner)),
+        }
+    }
+
+    /// Current config snapshot (for the API / UI).
+    #[must_use]
+    pub fn snapshot(&self) -> BootRulesConfig {
+        self.inner.read().clone()
+    }
+
+    /// Replace the whole config (the UI saves the full table at once —
+    /// rules are ordered, so partial updates would be ambiguous).
+    pub fn replace(&self, mut cfg: BootRulesConfig) {
+        for r in &mut cfg.rules {
+            r.mac_prefix = normalize_mac(&r.mac_prefix);
+            r.arch = r.arch.trim().to_ascii_lowercase();
+            r.target = r.target.trim().to_string();
+            r.driver_mode = r.driver_mode.trim().to_ascii_lowercase();
+            r.note = r.note.trim().to_string();
+        }
+        cfg.webhook_url = cfg.webhook_url.trim().to_string();
+        *self.inner.write() = cfg;
+        self.persist();
+    }
+
+    /// Webhook URL, when configured.
+    #[must_use]
+    pub fn webhook_url(&self) -> Option<String> {
+        let g = self.inner.read();
+        if g.webhook_url.is_empty() {
+            None
+        } else {
+            Some(g.webhook_url.clone())
+        }
+    }
+
+    /// First enabled rule matching `(mac, arch)`, in stored order.
+    /// `arch` is the `ClientArch::as_str()` form when the boot chain
+    /// passed one along, `None` otherwise (older chains).
+    #[must_use]
+    pub fn match_target(&self, mac: &str, arch: Option<&str>) -> Option<String> {
+        self.first_match(mac, arch, |r| {
+            (!r.target.is_empty()).then(|| r.target.clone())
+        })
+    }
+
+    /// v0.7.1: first enabled rule that pins a driver mode for `(mac,
+    /// arch)`. Consulted by the DHCP proxy *before* the automatic
+    /// escalation ladder — an operator who knows a rack is all Secure
+    /// Boot pins it to `shim` and those machines never walk the ladder.
+    /// Unknown mode strings are ignored (forward compatibility).
+    #[must_use]
+    pub fn driver_mode_hint(&self, mac: &str, arch: Option<&str>) -> Option<crate::DriverMode> {
+        self.first_match(mac, arch, |r| match r.driver_mode.as_str() {
+            "firmware" => Some(crate::DriverMode::Firmware),
+            "builtin" => Some(crate::DriverMode::Builtin),
+            "shim" => Some(crate::DriverMode::Shim),
+            _ => None,
+        })
+    }
+
+    /// Shared rule-matching walk: returns the first `extract` result from
+    /// an enabled rule whose selectors match. Rules that match but yield
+    /// `None` from `extract` (e.g. no target set, or no driver mode set)
+    /// don't stop the walk — target rules and mode-pin rules coexist.
+    fn first_match<T>(
+        &self,
+        mac: &str,
+        arch: Option<&str>,
+        extract: impl Fn(&BootRule) -> Option<T>,
+    ) -> Option<T> {
+        let mac = normalize_mac(mac);
+        let g = self.inner.read();
+        for r in &g.rules {
+            if !r.enabled {
+                continue;
+            }
+            if !r.mac_prefix.is_empty() && !mac.starts_with(r.mac_prefix.as_str()) {
+                continue;
+            }
+            if !r.arch.is_empty() {
+                // An arch-selective rule can only match when the chain
+                // told us the client's arch.
+                match arch {
+                    Some(a) if a.eq_ignore_ascii_case(&r.arch) => {}
+                    _ => continue,
+                }
+            }
+            if let Some(v) = extract(r) {
+                return Some(v);
+            }
+        }
+        None
+    }
+
+    fn persist(&self) {
+        let snap = self.inner.read().clone();
+        let body = match serde_json::to_vec_pretty(&snap) {
+            Ok(b) => b,
+            Err(e) => {
+                tracing::warn!(target: "openpxe::boot_rules", "serialize boot_rules.json: {e}");
+                return;
+            }
+        };
+        if let Some(parent) = self.path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        let tmp = self.path.with_extension("json.tmp");
+        if let Err(e) = std::fs::write(&tmp, body) {
+            tracing::warn!(target: "openpxe::boot_rules", "write boot_rules.json tmp: {e}");
+            return;
+        }
+        if let Err(e) = std::fs::rename(&tmp, self.path.as_path()) {
+            tracing::warn!(target: "openpxe::boot_rules", "rename boot_rules.json: {e}");
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    fn rule(mac_prefix: &str, arch: &str, target: &str) -> BootRule {
+        BootRule {
+            mac_prefix: mac_prefix.into(),
+            arch: arch.into(),
+            target: target.into(),
+            driver_mode: String::new(),
+            enabled: true,
+            note: String::new(),
+        }
+    }
+
+    #[test]
+    fn driver_mode_hint_pins_known_modes_and_ignores_unknown() {
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        let mut sb_rack = rule("aa:bb:cc", "", "");
+        sb_rack.driver_mode = "SHIM".into(); // normalized on replace
+        let mut weird = rule("11:22:33", "", "");
+        weird.driver_mode = "quantum".into(); // unknown → ignored
+        s.replace(BootRulesConfig {
+            rules: vec![sb_rack, weird],
+            webhook_url: String::new(),
+        });
+        assert_eq!(
+            s.driver_mode_hint("aa:bb:cc:00:00:01", None),
+            Some(crate::DriverMode::Shim)
+        );
+        assert_eq!(s.driver_mode_hint("11:22:33:00:00:01", None), None);
+        assert_eq!(s.driver_mode_hint("99:99:99:00:00:01", None), None);
+    }
+
+    #[test]
+    fn mode_pin_rule_does_not_shadow_later_target_rule() {
+        // A mode-only rule and a target rule can both apply to the same
+        // client: the mode pin must not consume the target walk.
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        let mut pin = rule("aa:bb", "", "");
+        pin.driver_mode = "builtin".into();
+        s.replace(BootRulesConfig {
+            rules: vec![pin, rule("aa:bb", "", "rack-image")],
+            webhook_url: String::new(),
+        });
+        assert_eq!(
+            s.driver_mode_hint("aa:bb:00:00:00:01", None),
+            Some(crate::DriverMode::Builtin)
+        );
+        assert_eq!(
+            s.match_target("aa:bb:00:00:00:01", None).as_deref(),
+            Some("rack-image")
+        );
+    }
+
+    #[test]
+    fn empty_config_matches_nothing() {
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        assert!(s
+            .match_target("aa:bb:cc:dd:ee:ff", Some("uefi-x64"))
+            .is_none());
+        assert!(s.webhook_url().is_none());
+    }
+
+    #[test]
+    fn first_match_wins_in_order() {
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        s.replace(BootRulesConfig {
+            rules: vec![
+                rule("aa:bb:cc", "", "rack-image"),
+                rule("", "", "catch-all"),
+            ],
+            webhook_url: String::new(),
+        });
+        assert_eq!(
+            s.match_target("AA-BB-CC-00-00-01", None).as_deref(),
+            Some("rack-image")
+        );
+        assert_eq!(
+            s.match_target("11:22:33:44:55:66", None).as_deref(),
+            Some("catch-all")
+        );
+    }
+
+    #[test]
+    fn arch_selector_requires_known_arch() {
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        s.replace(BootRulesConfig {
+            rules: vec![rule("", "uefi-arm64", "arm-image")],
+            webhook_url: String::new(),
+        });
+        assert_eq!(
+            s.match_target("aa:bb:cc:00:00:01", Some("uefi-arm64"))
+                .as_deref(),
+            Some("arm-image")
+        );
+        // Wrong arch, or arch unknown to the chain → no match.
+        assert!(s.match_target("aa:bb:cc:00:00:01", Some("bios")).is_none());
+        assert!(s.match_target("aa:bb:cc:00:00:01", None).is_none());
+    }
+
+    #[test]
+    fn disabled_rules_are_skipped() {
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        let mut r = rule("", "", "x");
+        r.enabled = false;
+        s.replace(BootRulesConfig {
+            rules: vec![r],
+            webhook_url: String::new(),
+        });
+        assert!(s.match_target("aa:bb:cc:00:00:01", None).is_none());
+    }
+
+    #[test]
+    fn config_round_trips_to_disk() {
+        let dir = tempdir().unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        s.replace(BootRulesConfig {
+            rules: vec![rule("DC-A6-32", "", "pi-image")],
+            webhook_url: "  http://automation/boot  ".into(),
+        });
+        drop(s);
+        let s2 = BootRulesStore::load_or_default(dir.path());
+        // Prefix was normalized on replace, webhook trimmed.
+        assert_eq!(
+            s2.match_target("dc:a6:32:01:02:03", None).as_deref(),
+            Some("pi-image")
+        );
+        assert_eq!(s2.webhook_url().as_deref(), Some("http://automation/boot"));
+    }
+
+    #[test]
+    fn corrupt_file_falls_back_to_empty() {
+        let dir = tempdir().unwrap();
+        std::fs::write(dir.path().join("boot_rules.json"), b"{nope").unwrap();
+        let s = BootRulesStore::load_or_default(dir.path());
+        assert!(s.snapshot().rules.is_empty());
+    }
+}

crates/core/src/boot_tokens.rs

@@ -0,0 +1,138 @@
+//! One-time(ish) access tokens for unattended answer files (v0.7.0).
+//!
+//! Why: answer files routinely embed credentials (local admin passwords,
+//! domain-join accounts, root hashes). Serving them to anyone who can
+//! GET `/unattended/<id>` is exactly the exposure that got WDS
+//! hands-free deployment disabled upstream (CVE-2026-0386 hardening
+//! guidance). OpenPXE generates every answer-file URL it injects into a
+//! boot chain, so it can scope each URL to the boot that requested it:
+//! when a boot script is rendered, a short-lived token is minted and
+//! appended; the serving endpoint requires it (or a logged-in operator
+//! session, so browser testing keeps working).
+//!
+//! Deliberately multi-use within the TTL rather than strictly one-shot:
+//! real installers fetch the same file more than once (initramfs +
+//! installer stage, cloud-init retries), and the token's job is to stop
+//! *unrelated* hosts from harvesting credentials, not to count fetches.
+//!
+//! In-memory only. A server restart invalidates outstanding tokens —
+//! acceptable because a restart also interrupts the ISO streaming an
+//! in-flight install depends on, and the next boot mints fresh ones.
+
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+use uuid::Uuid;
+
+/// Long enough to cover a slow OS install end-to-end (the answer file is
+/// fetched early, but cloud-init can re-read late), short enough that a
+/// leaked URL goes stale the same afternoon.
+const TOKEN_TTL: Duration = Duration::from_hours(4);
+
+/// Hard cap on outstanding tokens; past it the oldest is evicted. Tokens
+/// are minted once per boot-script render, so this only matters under
+/// abuse, and serving must never become a memory-growth vector.
+const MAX_TOKENS: usize = 4096;
+
+#[derive(Debug, Clone)]
+struct Grant {
+    file_id: String,
+    issued: Instant,
+}
+
+/// In-memory token table. Cheap to clone (`Arc`-shared).
+#[derive(Debug, Clone, Default)]
+pub struct BootTokens {
+    inner: std::sync::Arc<Mutex<HashMap<String, Grant>>>,
+}
+
+impl BootTokens {
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Mint a token granting access to unattended file `file_id` for the
+    /// next [`TOKEN_TTL`]. Returns the opaque token value to embed in the
+    /// generated URL.
+    #[must_use]
+    pub fn mint(&self, file_id: &str) -> String {
+        self.mint_at(file_id, Instant::now())
+    }
+
+    /// Is `token` a live grant for `file_id`?
+    #[must_use]
+    pub fn check(&self, token: &str, file_id: &str) -> bool {
+        self.check_at(token, file_id, Instant::now())
+    }
+
+    fn mint_at(&self, file_id: &str, now: Instant) -> String {
+        let token = Uuid::new_v4().simple().to_string();
+        let mut g = self.inner.lock();
+        g.retain(|_, gr| now.duration_since(gr.issued) < TOKEN_TTL);
+        if g.len() >= MAX_TOKENS {
+            if let Some(oldest) = g
+                .iter()
+                .min_by_key(|(_, gr)| gr.issued)
+                .map(|(k, _)| k.clone())
+            {
+                g.remove(&oldest);
+            }
+        }
+        g.insert(
+            token.clone(),
+            Grant {
+                file_id: file_id.to_string(),
+                issued: now,
+            },
+        );
+        token
+    }
+
+    fn check_at(&self, token: &str, file_id: &str, now: Instant) -> bool {
+        let g = self.inner.lock();
+        g.get(token)
+            .is_some_and(|gr| gr.file_id == file_id && now.duration_since(gr.issued) < TOKEN_TTL)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mint_then_check_round_trip() {
+        let t = BootTokens::new();
+        let tok = t.mint("ks-1");
+        assert!(t.check(&tok, "ks-1"));
+        // Multi-use within TTL: a second fetch still passes.
+        assert!(t.check(&tok, "ks-1"));
+        // Wrong file id never passes, even with a live token.
+        assert!(!t.check(&tok, "ks-2"));
+        // Unknown token never passes.
+        assert!(!t.check("nope", "ks-1"));
+    }
+
+    #[test]
+    fn token_expires_after_ttl() {
+        let t = BootTokens::new();
+        let now = Instant::now();
+        let tok = t.mint_at("ks-1", now);
+        let just_before = TOKEN_TTL.checked_sub(Duration::from_secs(1)).unwrap();
+        assert!(t.check_at(&tok, "ks-1", now + just_before));
+        assert!(!t.check_at(&tok, "ks-1", now + TOKEN_TTL + Duration::from_secs(1)));
+    }
+
+    #[test]
+    fn table_is_capped() {
+        let t = BootTokens::new();
+        let now = Instant::now();
+        let first = t.mint_at("f", now);
+        for i in 0..MAX_TOKENS {
+            let _ = t.mint_at(&format!("f{i}"), now + Duration::from_secs(1));
+        }
+        // The oldest grant was evicted to stay within the cap.
+        assert!(!t.check_at(&first, "f", now + Duration::from_secs(2)));
+        assert!(t.inner.lock().len() <= MAX_TOKENS);
+    }
+}

crates/core/src/branding.rs

@@ -1,11 +1,23 @@
 //! Operator-controlled branding overrides.
 //!
-//! The browser tab's logo (`/assets/logo.svg`) defaults to the bundled
+//! v0.5.2 splits the single brand mark into **three independent slots**,
-//! rainbow-horizon mark. Operators who deploy OpenPXE behind their own
+//! FleetDM-style:
-//! branding can upload a replacement that lives at
+//!
-//! `<work_dir>/branding/logo.<ext>` and is served in preference to the
+//! * `light` — shown in the WebUI top-left and on the form-login page
-//! bundled SVG when present. Borrowed-from-FleetDM: tenant chrome, same
+//!   when the active theme is light.
-//! product.
+//! * `dark` — same surfaces, when the active theme is dark.
+//! * `client` — the raster painted above the iPXE boot menu entries
+//!   (`/branding/pxe-logo`), i.e. what a PXE client sees on the screen.
+//!
+//! Each slot lives at `<work_dir>/branding/logo-<slot>.<ext>` and is
+//! served in preference to the bundled rainbow-horizon mark when present.
+//! Borrowed-from-FleetDM: tenant chrome, same product.
+//!
+//! Legacy continuity: a pre-v0.5.2 single `logo.<ext>` (recorded under
+//! the old `logo_filename`/`logo_mime` keys) is migrated on first load
+//! into both the `dark` and `client` slots — that preserves the previous
+//! behaviour (one mark fed both the dark WebUI and the PXE screen) until
+//! the operator uploads dedicated variants.
 //!
 //! Storage policy mirrors `HostBindings` / `BootLog`: in-memory cache is
 //! authoritative for the current process, disk is the source of truth on
@@ -35,27 +47,104 @@ pub const ALLOWED_LOGO_MIMES: &[&str] = &[
 /// puts a clear bound on memory + serialization cost.
 pub const MAX_LOGO_BYTES: usize = 2 * 1024 * 1024;
 
+/// Which branded surface a logo upload targets.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LogoSlot {
+    /// WebUI + form-login page, light theme.
+    Light,
+    /// WebUI + form-login page, dark theme.
+    Dark,
+    /// iPXE boot-menu background seen by PXE clients.
+    Client,
+}
+
+impl LogoSlot {
+    #[must_use]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            LogoSlot::Light => "light",
+            LogoSlot::Dark => "dark",
+            LogoSlot::Client => "client",
+        }
+    }
+
+    /// Parse a slot name from the URL path segment. Case-insensitive.
+    #[must_use]
+    pub fn parse(s: &str) -> Option<Self> {
+        match s.trim().to_ascii_lowercase().as_str() {
+            "light" => Some(LogoSlot::Light),
+            "dark" => Some(LogoSlot::Dark),
+            "client" => Some(LogoSlot::Client),
+            _ => None,
+        }
+    }
+}
+
+/// One brand-mark slot: a filename (relative to the branding dir) plus
+/// the MIME we cached at upload time so the HTTP layer can set the
+/// Content-Type without re-sniffing.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+struct Slot {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    filename: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    mime: Option<String>,
+}
+
+impl Slot {
+    fn clear_file(&mut self, dir: &Path) {
+        if let Some(name) = self.filename.take() {
+            let _ = std::fs::remove_file(dir.join(name));
+        }
+        self.mime = None;
+    }
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 struct Inner {
-    /// File name (relative to the branding dir) for the active logo, if
+    #[serde(default)]
-    /// any. Always under `<work_dir>/branding/`; never an absolute path
+    light: Slot,
-    /// from the operator.
+    #[serde(default)]
-    logo_filename: Option<String>,
+    dark: Slot,
-    /// MIME of the active logo, mirroring `logo_filename`. Cached here
+    #[serde(default)]
-    /// so the HTTP layer can set Content-Type without re-sniffing.
+    client: Slot,
-    logo_mime: Option<String>,
+    /// Monotonic counter bumped on every set/clear (any slot). Surfaces
-    /// Monotonic counter bumped on every set/clear. Surfaces as a
+    /// as a cache-bust token (`/assets/logo.svg?r=<rev>`) so the browser
-    /// cache-bust token (`/assets/logo.svg?r=<rev>`) so the browser
+    /// fetches the new bytes the moment the operator swaps a logo — the
-    /// fetches the new bytes the moment the operator swaps the logo —
+    /// app version alone can't do this since it doesn't change on upload.
-    /// the app version alone can't do this since it doesn't change on
+    /// Persisted so the token stays stable across restarts and keeps
-    /// upload. Persisted so the token stays stable across restarts and
+    /// climbing across multiple swaps.
-    /// keeps climbing across multiple swaps.
     #[serde(default)]
     rev: u64,
+    // ── Legacy (pre-v0.5.2) single-logo keys ──────────────────────────
+    // Read on load for one-way migration into `dark` + `client`, then
+    // dropped from the persisted form (skip_serializing_if).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    logo_filename: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    logo_mime: Option<String>,
+}
+
+impl Inner {
+    fn slot(&self, slot: LogoSlot) -> &Slot {
+        match slot {
+            LogoSlot::Light => &self.light,
+            LogoSlot::Dark => &self.dark,
+            LogoSlot::Client => &self.client,
+        }
+    }
+
+    fn slot_mut(&mut self, slot: LogoSlot) -> &mut Slot {
+        match slot {
+            LogoSlot::Light => &mut self.light,
+            LogoSlot::Dark => &mut self.dark,
+            LogoSlot::Client => &mut self.client,
+        }
+    }
 }
 
 /// In-memory + on-disk override registry. Cheap to clone; locks are
-/// brief. The `branding.json` cache lives alongside the active asset
+/// brief. The `branding.json` cache lives alongside the active assets
 /// inside `<work_dir>/branding/`.
 #[derive(Debug, Clone)]
 pub struct BrandingStore {
@@ -67,7 +156,8 @@ pub struct BrandingStore {
 impl BrandingStore {
     /// Load (or initialise empty) from `<work_dir>/branding/`. Tolerates
     /// missing directories, partial state, and corrupt JSON — a bad
-    /// cache should never block PXE for the network.
+    /// cache should never block PXE for the network. Migrates a legacy
+    /// single-logo file into the dark + client slots.
     #[must_use]
     pub fn load_or_default(work_dir: &Path) -> Self {
         let dir = work_dir.join("branding");
@@ -75,25 +165,7 @@ impl BrandingStore {
         let mut inner = Inner::default();
         if let Ok(text) = std::fs::read_to_string(&path) {
             match serde_json::from_str::<Inner>(&text) {
-                Ok(parsed) => {
+                Ok(parsed) => inner = parsed,
-                    // Sanity: if the JSON says we have a logo but the
-                    // file is gone, clear the in-memory pointer so
-                    // /assets/logo.svg falls back to the bundled SVG
-                    // rather than 500ing on a missing file.
-                    if let Some(name) = parsed.logo_filename.as_deref() {
-                        if dir.join(name).is_file() {
-                            inner = parsed;
-                        } else {
-                            tracing::warn!(
-                                target: "openpxe::branding",
-                                file = %name,
-                                "branding.json points at missing file; clearing"
-                            );
-                        }
-                    } else {
-                        inner = parsed;
-                    }
-                }
                 Err(e) => {
                     tracing::warn!(
                         target: "openpxe::branding",
@@ -102,102 +174,242 @@ impl BrandingStore {
                 }
             }
         }
-        Self {
+        let store = Self {
             dir: Arc::new(dir),
             inner: Arc::new(RwLock::new(inner)),
+        };
+        store.migrate_legacy();
+        store.prune_missing();
+        store
+    }
+
+    /// One-way migration: a pre-v0.5.2 `logo.<ext>` becomes the dark +
+    /// client slots (the old single mark fed both the dark WebUI and the
+    /// PXE screen). Best-effort; failures leave the legacy file in place
+    /// rather than blocking startup.
+    fn migrate_legacy(&self) {
+        let (legacy_name, legacy_mime) = {
+            let g = self.inner.read();
+            (g.logo_filename.clone(), g.logo_mime.clone())
+        };
+        let Some(name) = legacy_name else { return };
+        let src = self.dir.join(&name);
+        if !src.is_file() {
+            // Legacy pointer is stale — just drop it.
+            let mut g = self.inner.write();
+            g.logo_filename = None;
+            g.logo_mime = None;
+            drop(g);
+            self.persist();
+            return;
         }
-    }
+        let mime = legacy_mime.unwrap_or_else(|| "image/svg+xml".to_string());
-
+        let ext = ext_for_mime(&mime).unwrap_or("bin");
-    /// Absolute path to the active logo, if one is set and present on
+        if let Ok(bytes) = std::fs::read(&src) {
-    /// disk. `None` means the HTTP layer should serve the bundled SVG.
+            // Seed dark + client only when those slots are still empty so
-    #[must_use]
+            // a re-run (or a manual edit) never clobbers operator intent.
-    pub fn logo_path(&self) -> Option<PathBuf> {
+            let needs_dark = self.inner.read().dark.filename.is_none();
-        let g = self.inner.read();
+            let needs_client = self.inner.read().client.filename.is_none();
-        g.logo_filename.as_deref().map(|n| self.dir.join(n))
+            if needs_dark {
-    }
+                let _ = self.write_slot(LogoSlot::Dark, &mime, ext, &bytes);
-
+            }
-    /// MIME of the active logo, if any. The HTTP layer pairs this with
+            if needs_client {
-    /// the bytes returned by [`Self::logo_path`].
+                let _ = self.write_slot(LogoSlot::Client, &mime, ext, &bytes);
-    #[must_use]
-    pub fn logo_mime(&self) -> Option<String> {
-        self.inner.read().logo_mime.clone()
-    }
-
-    /// Replace the active logo. Returns the chosen on-disk filename so
-    /// the caller can echo it back in the API response. Old logos are
-    /// removed best-effort.
-    pub fn set_logo(&self, mime: &str, ext: &str, bytes: &[u8]) -> std::io::Result<String> {
-        std::fs::create_dir_all(self.dir.as_path())?;
-        // Single canonical filename per upload — overwriting the old one
-        // (after clearing it) keeps the directory tidy and avoids any
-        // path-traversal concern: the operator never supplies the name.
-        let safe_ext = sanitize_ext(ext);
-        let filename = format!("logo.{safe_ext}");
-        let final_path = self.dir.join(&filename);
-        // Atomic write: tmp -> rename. Guarantees the file is either
-        // entirely the old logo or entirely the new one.
-        let tmp = final_path.with_extension(format!("{safe_ext}.tmp"));
-        std::fs::write(&tmp, bytes)?;
-        std::fs::rename(&tmp, &final_path)?;
-        // Clean up any sibling logo.<otherext> so there's exactly one
-        // canonical file at any time.
-        if let Ok(entries) = std::fs::read_dir(self.dir.as_path()) {
-            for e in entries.flatten() {
-                let p = e.path();
-                let name = p
-                    .file_name()
-                    .and_then(|s| s.to_str())
-                    .unwrap_or("");
-                if name.starts_with("logo.") && name != filename {
-                    let _ = std::fs::remove_file(&p);
-                }
             }
         }
-
+        let _ = std::fs::remove_file(&src);
         {
             let mut g = self.inner.write();
-            g.logo_filename = Some(filename.clone());
+            g.logo_filename = None;
-            g.logo_mime = Some(mime.to_string());
+            g.logo_mime = None;
-            g.rev = g.rev.wrapping_add(1);
         }
         self.persist();
         tracing::info!(
             target: "openpxe::branding",
-            file = %filename, mime = %mime, size = bytes.len(),
+            "migrated legacy single logo into dark + client slots"
+        );
+    }
+
+    /// Drop in-memory slot pointers whose backing file vanished from disk
+    /// so the HTTP layer falls back to the bundled mark instead of 500ing.
+    fn prune_missing(&self) {
+        let mut changed = false;
+        {
+            let mut g = self.inner.write();
+            for slot in [LogoSlot::Light, LogoSlot::Dark, LogoSlot::Client] {
+                let present = g
+                    .slot(slot)
+                    .filename
+                    .as_deref()
+                    .is_some_and(|n| self.dir.join(n).is_file());
+                if !present && g.slot(slot).filename.is_some() {
+                    g.slot_mut(slot).filename = None;
+                    g.slot_mut(slot).mime = None;
+                    changed = true;
+                }
+            }
+        }
+        if changed {
+            self.persist();
+        }
+    }
+
+    /// Absolute path to the logo for `slot`, if set and present on disk.
+    #[must_use]
+    pub fn slot_path(&self, slot: LogoSlot) -> Option<PathBuf> {
+        let g = self.inner.read();
+        g.slot(slot).filename.as_deref().map(|n| self.dir.join(n))
+    }
+
+    /// MIME of the logo for `slot`, if any.
+    #[must_use]
+    pub fn slot_mime(&self, slot: LogoSlot) -> Option<String> {
+        self.inner.read().slot(slot).mime.clone()
+    }
+
+    /// Resolve the WebUI logo for a theme, with fallback: light falls
+    /// back to dark and vice-versa, so a single uploaded variant still
+    /// shows on both themes. Returns `(path, mime)` or `None` (→ bundled).
+    #[must_use]
+    pub fn web_logo(&self, theme_is_light: bool) -> Option<(PathBuf, String)> {
+        let (primary, secondary) = if theme_is_light {
+            (LogoSlot::Light, LogoSlot::Dark)
+        } else {
+            (LogoSlot::Dark, LogoSlot::Light)
+        };
+        let g = self.inner.read();
+        let chosen = if g.slot(primary).filename.is_some() {
+            primary
+        } else {
+            secondary
+        };
+        let s = g.slot(chosen);
+        s.filename.as_deref().map(|n| {
+            (
+                self.dir.join(n),
+                s.mime
+                    .clone()
+                    .unwrap_or_else(|| "image/svg+xml".to_string()),
+            )
+        })
+    }
+
+    /// Resolve the PXE client logo (no theme fallback — the PXE screen
+    /// has a single mark). Returns `(path, mime)` or `None` (→ default
+    /// composed background).
+    #[must_use]
+    pub fn client_logo(&self) -> Option<(PathBuf, String)> {
+        let g = self.inner.read();
+        let s = &g.client;
+        s.filename.as_deref().map(|n| {
+            (
+                self.dir.join(n),
+                s.mime
+                    .clone()
+                    .unwrap_or_else(|| "application/octet-stream".to_string()),
+            )
+        })
+    }
+
+    /// Replace the logo for `slot`. Returns the chosen on-disk filename so
+    /// the caller can echo it back in the API response.
+    pub fn set_logo(
+        &self,
+        slot: LogoSlot,
+        mime: &str,
+        ext: &str,
+        bytes: &[u8],
+    ) -> std::io::Result<String> {
+        let filename = self.write_slot(slot, mime, ext, bytes)?;
+        self.persist();
+        tracing::info!(
+            target: "openpxe::branding",
+            slot = slot.as_str(), file = %filename, mime = %mime, size = bytes.len(),
             "custom logo installed"
         );
         Ok(filename)
     }
 
-    /// Drop the override and return to the bundled SVG.
+    /// Write the bytes for a slot and update the in-memory pointer + rev,
-    pub fn clear_logo(&self) -> std::io::Result<()> {
+    /// without persisting (the caller decides when to flush). Cleans up
-        let removed = {
+    /// any sibling `logo-<slot>.*` so there's exactly one file per slot.
+    fn write_slot(
+        &self,
+        slot: LogoSlot,
+        mime: &str,
+        ext: &str,
+        bytes: &[u8],
+    ) -> std::io::Result<String> {
+        std::fs::create_dir_all(self.dir.as_path())?;
+        let safe_ext = sanitize_ext(ext);
+        let stem = format!("logo-{}", slot.as_str());
+        let filename = format!("{stem}.{safe_ext}");
+        let final_path = self.dir.join(&filename);
+        // Atomic write: tmp -> rename.
+        let tmp = final_path.with_extension(format!("{safe_ext}.tmp"));
+        std::fs::write(&tmp, bytes)?;
+        std::fs::rename(&tmp, &final_path)?;
+        // Clean up any sibling `logo-<slot>.<otherext>`.
+        if let Ok(entries) = std::fs::read_dir(self.dir.as_path()) {
+            for e in entries.flatten() {
+                let p = e.path();
+                let name = p.file_name().and_then(|s| s.to_str()).unwrap_or("");
+                if name.starts_with(&format!("{stem}.")) && name != filename {
+                    let _ = std::fs::remove_file(&p);
+                }
+            }
+        }
+        let mut g = self.inner.write();
+        let s = g.slot_mut(slot);
+        s.filename = Some(filename.clone());
+        s.mime = Some(mime.to_string());
+        g.rev = g.rev.wrapping_add(1);
+        Ok(filename)
+    }
+
+    /// Drop the override for `slot` and return to the bundled / default.
+    pub fn clear_logo(&self, slot: LogoSlot) -> std::io::Result<()> {
+        {
             let mut g = self.inner.write();
-            let removed = g.logo_filename.take();
+            let dir = self.dir.as_path();
-            g.logo_mime = None;
+            g.slot_mut(slot).clear_file(dir);
             g.rev = g.rev.wrapping_add(1);
-            removed
-        };
-        if let Some(name) = removed {
-            let p = self.dir.join(&name);
-            let _ = std::fs::remove_file(&p);
-            tracing::info!(target: "openpxe::branding", file = %name, "custom logo cleared");
         }
         self.persist();
+        tracing::info!(target: "openpxe::branding", slot = slot.as_str(), "custom logo cleared");
         Ok(())
     }
 
-    /// Convenience: true if a custom logo is configured. Surfaces on
+    /// True if a custom logo is configured for `slot`.
-    /// `/api/status` so the WebUI can show "Custom logo: yes" without
-    /// fetching the asset itself.
     #[must_use]
-    pub fn has_logo(&self) -> bool {
+    pub fn has_logo(&self, slot: LogoSlot) -> bool {
-        self.inner.read().logo_filename.is_some()
+        self.inner.read().slot(slot).filename.is_some()
     }
 
-    /// Cache-bust token for the logo asset URL. Changes on every
+    /// True if either WebUI theme slot has a custom logo — drives the
+    /// FleetDM-style full-width brand block (and the `has-custom-logo`
+    /// class) on the sidebar + login page.
+    #[must_use]
+    pub fn has_any_web_logo(&self) -> bool {
+        let g = self.inner.read();
+        g.light.filename.is_some() || g.dark.filename.is_some()
+    }
+
+    /// Presence triple `(light, dark, client)` for the `/api/me` and
+    /// `/api/status` bootstrap payloads.
+    #[must_use]
+    pub fn presence(&self) -> (bool, bool, bool) {
+        let g = self.inner.read();
+        (
+            g.light.filename.is_some(),
+            g.dark.filename.is_some(),
+            g.client.filename.is_some(),
+        )
+    }
+
+    /// Cache-bust token for the logo asset URLs. Changes on every
     /// set/clear so `/assets/logo.svg?r=<rev>` resolves to a fresh URL
-    /// whenever the operator swaps the brand mark. Stable otherwise.
+    /// whenever the operator swaps a brand mark. Stable otherwise.
     #[must_use]
     pub fn logo_rev(&self) -> u64 {
         self.inner.read().rev
@@ -267,47 +479,87 @@ mod tests {
     fn empty_after_load_when_no_branding_dir() {
         let dir = tempdir().unwrap();
         let b = BrandingStore::load_or_default(dir.path());
-        assert!(!b.has_logo());
+        assert!(!b.has_logo(LogoSlot::Light));
-        assert!(b.logo_path().is_none());
+        assert!(!b.has_logo(LogoSlot::Dark));
-        assert!(b.logo_mime().is_none());
+        assert!(!b.has_logo(LogoSlot::Client));
+        assert!(b.web_logo(false).is_none());
+        assert!(b.client_logo().is_none());
+        assert!(!b.has_any_web_logo());
     }
 
     #[test]
     fn set_clear_round_trip_persists() {
         let dir = tempdir().unwrap();
         let b = BrandingStore::load_or_default(dir.path());
-        let name = b.set_logo("image/png", "png", b"\x89PNG\r\n\x1a\nfake").unwrap();
+        let name = b
-        assert_eq!(name, "logo.png");
+            .set_logo(LogoSlot::Dark, "image/png", "png", b"\x89PNG\r\n\x1a\nfake")
-        assert!(b.has_logo());
+            .unwrap();
-        assert_eq!(b.logo_mime().as_deref(), Some("image/png"));
+        assert_eq!(name, "logo-dark.png");
-        let p = b.logo_path().unwrap();
+        assert!(b.has_logo(LogoSlot::Dark));
+        assert_eq!(b.slot_mime(LogoSlot::Dark).as_deref(), Some("image/png"));
+        let (p, _) = b.web_logo(false).unwrap();
         assert!(p.is_file());
 
         // Re-open and confirm the override survives a restart.
         drop(b);
         let b2 = BrandingStore::load_or_default(dir.path());
-        assert!(b2.has_logo());
+        assert!(b2.has_logo(LogoSlot::Dark));
-        assert_eq!(b2.logo_mime().as_deref(), Some("image/png"));
+        assert_eq!(b2.slot_mime(LogoSlot::Dark).as_deref(), Some("image/png"));
 
         // Clear; the file goes away and has_logo flips off.
-        b2.clear_logo().unwrap();
+        b2.clear_logo(LogoSlot::Dark).unwrap();
-        assert!(!b2.has_logo());
+        assert!(!b2.has_logo(LogoSlot::Dark));
         assert!(!p.exists());
     }
 
     #[test]
-    fn replacing_logo_removes_old_extension_sibling() {
+    fn web_logo_falls_back_across_themes() {
-        // PNG then SVG; only the SVG should remain on disk.
         let dir = tempdir().unwrap();
         let b = BrandingStore::load_or_default(dir.path());
-        b.set_logo("image/png", "png", b"\x89PNG\r\n\x1a\nfake").unwrap();
+        // Only dark uploaded — light theme falls back to it.
-        b.set_logo("image/svg+xml", "svg", br#"<svg xmlns="http://www.w3.org/2000/svg"/>"#).unwrap();
+        b.set_logo(LogoSlot::Dark, "image/png", "png", b"dark")
+            .unwrap();
+        let (p_light, _) = b.web_logo(true).expect("light falls back to dark");
+        assert!(p_light.ends_with("logo-dark.png"));
+        // Upload a distinct light — now light theme uses its own.
+        b.set_logo(LogoSlot::Light, "image/png", "png", b"light")
+            .unwrap();
+        let (p_light2, _) = b.web_logo(true).unwrap();
+        assert!(p_light2.ends_with("logo-light.png"));
+        // Client is independent and still unset.
+        assert!(b.client_logo().is_none());
+    }
+
+    #[test]
+    fn replacing_slot_removes_old_extension_sibling() {
+        let dir = tempdir().unwrap();
+        let b = BrandingStore::load_or_default(dir.path());
+        b.set_logo(
+            LogoSlot::Client,
+            "image/png",
+            "png",
+            b"\x89PNG\r\n\x1a\nfake",
+        )
+        .unwrap();
+        b.set_logo(
+            LogoSlot::Client,
+            "image/svg+xml",
+            "svg",
+            br#"<svg xmlns="http://www.w3.org/2000/svg"/>"#,
+        )
+        .unwrap();
         let entries: Vec<_> = std::fs::read_dir(dir.path().join("branding"))
             .unwrap()
             .filter_map(|e| e.ok().map(|e| e.file_name().to_string_lossy().into_owned()))
             .collect();
-        assert!(entries.iter().any(|n| n == "logo.svg"), "got {entries:?}");
+        assert!(
-        assert!(!entries.iter().any(|n| n == "logo.png"), "stale PNG left over: {entries:?}");
+            entries.iter().any(|n| n == "logo-client.svg"),
+            "got {entries:?}"
+        );
+        assert!(
+            !entries.iter().any(|n| n == "logo-client.png"),
+            "stale PNG left over: {entries:?}"
+        );
     }
 
     #[test]
@@ -315,54 +567,92 @@ mod tests {
         let dir = tempdir().unwrap();
         let b = BrandingStore::load_or_default(dir.path());
         assert_eq!(b.logo_rev(), 0);
-        b.set_logo("image/png", "png", b"\x89PNG\r\n\x1a\nfake").unwrap();
+        b.set_logo(LogoSlot::Light, "image/png", "png", b"a")
+            .unwrap();
         assert_eq!(b.logo_rev(), 1);
-        b.set_logo("image/png", "png", b"\x89PNG\r\n\x1a\nfake2").unwrap();
+        b.set_logo(LogoSlot::Dark, "image/png", "png", b"b")
+            .unwrap();
         assert_eq!(b.logo_rev(), 2);
-        b.clear_logo().unwrap();
+        b.clear_logo(LogoSlot::Light).unwrap();
         assert_eq!(b.logo_rev(), 3);
-        // Survives a restart.
         drop(b);
         let b2 = BrandingStore::load_or_default(dir.path());
         assert_eq!(b2.logo_rev(), 3);
     }
 
+    #[test]
+    fn legacy_single_logo_migrates_to_dark_and_client() {
+        // A pre-v0.5.2 branding.json + logo.png migrates on load.
+        let dir = tempdir().unwrap();
+        let brand_dir = dir.path().join("branding");
+        std::fs::create_dir_all(&brand_dir).unwrap();
+        std::fs::write(brand_dir.join("logo.png"), b"\x89PNG\r\n\x1a\nlegacy").unwrap();
+        // Hand-write the old shape (logo_filename/logo_mime, no slots).
+        std::fs::write(
+            brand_dir.join("branding.json"),
+            br#"{"logo_filename":"logo.png","logo_mime":"image/png","rev":4}"#,
+        )
+        .unwrap();
+        let b = BrandingStore::load_or_default(dir.path());
+        assert!(b.has_logo(LogoSlot::Dark), "dark seeded from legacy");
+        assert!(b.has_logo(LogoSlot::Client), "client seeded from legacy");
+        assert!(!b.has_logo(LogoSlot::Light), "light stays empty");
+        // The old logo.png is gone; per-slot files exist.
+        assert!(!brand_dir.join("logo.png").exists());
+        assert!(brand_dir.join("logo-dark.png").is_file());
+        assert!(brand_dir.join("logo-client.png").is_file());
+        // rev carried over from the legacy file and advanced as the two
+        // slots were seeded (each write bumps it), so it never regresses.
+        let migrated_rev = b.logo_rev();
+        assert!(
+            migrated_rev >= 4,
+            "rev should not regress below legacy: {migrated_rev}"
+        );
+        // And the migration is sticky across a restart (no re-migrate, no
+        // further rev churn).
+        drop(b);
+        let b2 = BrandingStore::load_or_default(dir.path());
+        assert!(b2.has_logo(LogoSlot::Dark));
+        assert!(b2.has_logo(LogoSlot::Client));
+        assert!(!b2.has_logo(LogoSlot::Light));
+        assert_eq!(b2.logo_rev(), migrated_rev, "restart must not re-migrate");
+    }
+
     #[test]
     fn sanitize_ext_strips_separators_and_path_chars() {
         assert_eq!(sanitize_ext("svg"), "svg");
-        // Path separators and non-alphanumerics filter out, leaving just
-        // letters. The remaining "etcpasswd" exceeds the 5-char cap so
-        // it collapses to `bin` rather than producing `etcpa`.
         assert_eq!(sanitize_ext("../etc/passwd"), "bin");
-        // Short alphanumeric strip-through stays itself.
         assert_eq!(sanitize_ext("../svg"), "svg");
         assert_eq!(sanitize_ext(""), "bin");
         assert_eq!(sanitize_ext("PNG"), "png");
-        // Anything past five chars is suspicious — collapse to `bin`.
         assert_eq!(sanitize_ext("svgvvvv"), "bin");
     }
 
     #[test]
     fn missing_file_referenced_by_json_resolves_to_empty() {
-        // If the operator nukes the file out from under the JSON cache,
-        // we should silently fall back to no-override rather than
-        // hanging on to a bogus path.
         let dir = tempdir().unwrap();
         let brand_dir = dir.path().join("branding");
         std::fs::create_dir_all(&brand_dir).unwrap();
-        // Hand-write a branding.json claiming logo.png exists.
+        // branding.json claims a dark slot whose file doesn't exist.
-        let inner = Inner {
-            logo_filename: Some("logo.png".into()),
-            logo_mime: Some("image/png".into()),
-            rev: 0,
-        };
         std::fs::write(
             brand_dir.join("branding.json"),
-            serde_json::to_vec_pretty(&inner).unwrap(),
+            br#"{"dark":{"filename":"logo-dark.png","mime":"image/png"},"rev":1}"#,
         )
         .unwrap();
         let b = BrandingStore::load_or_default(dir.path());
-        assert!(!b.has_logo(), "should fall back when referenced file is missing");
+        assert!(
+            !b.has_logo(LogoSlot::Dark),
+            "should fall back when referenced file is missing"
+        );
+    }
+
+    #[test]
+    fn slot_parse_round_trips() {
+        assert_eq!(LogoSlot::parse("light"), Some(LogoSlot::Light));
+        assert_eq!(LogoSlot::parse("DARK"), Some(LogoSlot::Dark));
+        assert_eq!(LogoSlot::parse(" client "), Some(LogoSlot::Client));
+        assert_eq!(LogoSlot::parse("nope"), None);
+        assert_eq!(LogoSlot::Light.as_str(), "light");
     }
 
     #[test]

crates/core/src/client.rs

@@ -12,11 +12,9 @@ use time::OffsetDateTime;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ClientEvent {
     DhcpDiscover,
-    DhcpRequest,
     PxeBootServerRequest,
     TftpRead { file: String },
     HttpScriptFetch { target: String },
-    HttpIsoAsset { file: String },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -32,8 +30,6 @@ pub struct ClientSnapshot {
     // Events are left with default serialization (9-tuple) — they're
     // diagnostic only and not consumed by the UI today.
     pub events: Vec<(OffsetDateTime, ClientEvent)>,
-    /// The boot target (ISO id) last selected via the iPXE menu, if any.
-    pub selected_target: Option<String>,
 }
 
 #[derive(Debug, Default)]
@@ -66,7 +62,6 @@ impl ClientRegistry {
                 first_seen: now,
                 last_seen: now,
                 events: Vec::new(),
-                selected_target: None,
             });
         entry.last_seen = now;
         if ip.is_some() {
@@ -84,13 +79,6 @@ impl ClientRegistry {
         }
     }
 
-    pub fn set_selected_target(&self, mac: &str, target: Option<String>) {
-        let mut guard = self.inner.write();
-        if let Some(c) = guard.get_mut(mac) {
-            c.selected_target = target;
-        }
-    }
-
     #[must_use]
     pub fn list(&self) -> Vec<ClientSnapshot> {
         let guard = self.inner.read();
@@ -99,9 +87,4 @@ impl ClientRegistry {
         v.sort_by_key(|c| std::cmp::Reverse(c.last_seen));
         v
     }
-
-    #[must_use]
-    pub fn get(&self, mac: &str) -> Option<ClientSnapshot> {
-        self.inner.read().get(mac).cloned()
-    }
 }

crates/core/src/config.rs

@@ -1,3 +1,5 @@
+use figment::providers::{Env, Format, Serialized, Toml};
+use figment::Figment;
 use serde::{Deserialize, Serialize};
 use std::net::{IpAddr, Ipv4Addr};
 use std::path::{Path, PathBuf};
@@ -38,10 +40,6 @@ pub struct NetworkConfig {
     pub dhcp_port: u16,
     /// UDP port for PXE Boot Server discovery. Standard is 4011.
     pub pxe_port: u16,
-    /// Optional allowlist of client MAC prefixes (OUI). Empty = serve everyone.
-    pub mac_allowlist: Vec<String>,
-    /// Optional allowlist of subnets (CIDR). Empty = serve everyone.
-    pub subnet_allowlist: Vec<String>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
@@ -56,6 +54,9 @@ pub enum DhcpMode {
     /// Disabled — rely on an external DHCP server that has been manually
     /// configured with `next-server` / `filename`. OpenPXE only serves TFTP
     /// + HTTP in this mode. Useful for home routers that can be pre-set.
+    // `off`/`none` are accepted as aliases for backward-compat with the old
+    // hand-rolled `apply_env`, which mapped them to Disabled.
+    #[serde(alias = "off", alias = "none")]
     Disabled,
 }
 
@@ -74,6 +75,11 @@ pub struct Paths {
     /// Only used when `settings.windows_enabled = true`. Defaults to
     /// `/var/lib/openpxe/smb` in the container image.
     pub smb_dir: PathBuf,
+    /// v0.5.2: directory holding uploaded unattended-install answer files
+    /// (Kickstart / Preseed / Autoinstall / Windows answer files). Kept
+    /// separate from `iso_dir` so answer files never appear in the ISO
+    /// listing or the PXE menu. Defaults to `/var/lib/openpxe/unattended`.
+    pub unattended_dir: PathBuf,
 }
 
 impl Default for ServerConfig {
@@ -95,8 +101,6 @@ impl Default for NetworkConfig {
             dhcp_bind: IpAddr::V4(Ipv4Addr::UNSPECIFIED),
             dhcp_port: 67,
             pxe_port: 4011,
-            mac_allowlist: Vec::new(),
-            subnet_allowlist: Vec::new(),
         }
     }
 }
@@ -109,6 +113,7 @@ impl Default for Paths {
             ipxe_dir: PathBuf::from("/usr/share/openpxe/ipxe"),
             wimboot_path: None,
             smb_dir: PathBuf::from("/var/lib/openpxe/smb"),
+            unattended_dir: PathBuf::from("/var/lib/openpxe/unattended"),
         }
     }
 }
@@ -123,48 +128,162 @@ impl Config {
         toml::from_str(&text).map_err(|e| crate::Error::Config(e.to_string()))
     }
 
-    /// Apply environment variable overrides. Env var names follow the pattern
+    /// Load configuration with layered precedence (v0.5.4, via `figment`):
-    /// `OPENPXE_<SECTION>_<FIELD>`, uppercase. Unknown vars are ignored.
+    /// built-in [`Default`] → optional TOML file → `OPENPXE_*` environment
-    /// Call this after loading the TOML file so env takes precedence.
+    /// (highest). Replaces the old `from_toml_file` + `apply_env` two-step
-    pub fn apply_env(&mut self) {
+    /// and now covers **every** field automatically (the previous hand-rolled
-        if let Ok(v) = std::env::var("OPENPXE_HTTP_PORT") {
+    /// mapping silently skipped `unattended_dir`, the bind addresses, etc.).
-            if let Ok(p) = v.parse() {
+    ///
-                self.server.http_port = p;
+    /// The env layer preserves the historical flat names
+    /// (`OPENPXE_HTTP_PORT`, `OPENPXE_ISO_DIR`, …) so existing deployments
+    /// (the Unraid template, `entrypoint.sh`) keep working unchanged, and
+    /// additionally accepts the explicit nested form
+    /// `OPENPXE_<SECTION>__<FIELD>` (double underscore).
+    pub fn load(path: Option<&Path>) -> crate::Result<Self> {
+        let mut fig = Figment::from(Serialized::defaults(Config::default()));
+        if let Some(p) = path {
+            if p.exists() {
+                fig = fig.merge(Toml::file(p));
             }
         }
-        if let Ok(v) = std::env::var("OPENPXE_TFTP_PORT") {
+        fig = fig.merge(env_provider());
-            if let Ok(p) = v.parse() {
+        fig.extract()
-                self.server.tftp_port = p;
+            .map_err(|e| crate::Error::Config(e.to_string()))
-            }
+    }
-        }
+}
-        if let Ok(v) = std::env::var("OPENPXE_DHCP_PORT") {
+
-            if let Ok(p) = v.parse() {
+/// The `OPENPXE_*` environment provider. Maps the historical flat variable
-                self.network.dhcp_port = p;
+/// names onto the nested [`Config`] fields, and also accepts the explicit
-            }
+/// `OPENPXE_SECTION__FIELD` nested form. Keys that match nothing (e.g.
-        }
+/// `OPENPXE_CONFIG`, `OPENPXE_UID` from the entrypoint) become stray
-        if let Ok(v) = std::env::var("OPENPXE_PUBLIC_IP") {
+/// top-level keys that `Config` ignores on extract.
-            if let Ok(ip) = v.parse() {
+fn env_provider() -> Env {
-                self.server.public_ip = Some(ip);
+    Env::prefixed("OPENPXE_")
-            }
+        .map(|key| {
-        }
+            // Lowercase so the match is robust regardless of how the OS
-        if let Ok(v) = std::env::var("OPENPXE_DHCP_MODE") {
+            // reports the var's case.
-            self.network.dhcp_mode = match v.to_ascii_lowercase().as_str() {
+            let k = key.as_str().to_ascii_lowercase();
-                "proxy" => DhcpMode::Proxy,
+            let mapped = match k.as_str() {
-                "disabled" | "off" | "none" => DhcpMode::Disabled,
+                "http_port" => "server.http_port",
-                _ => self.network.dhcp_mode,
+                "http_bind" => "server.http_bind",
+                "tftp_port" => "server.tftp_port",
+                "tftp_bind" => "server.tftp_bind",
+                "public_ip" => "server.public_ip",
+                "dhcp_port" => "network.dhcp_port",
+                "dhcp_bind" => "network.dhcp_bind",
+                "dhcp_mode" => "network.dhcp_mode",
+                "pxe_port" => "network.pxe_port",
+                "iso_dir" => "paths.iso_dir",
+                "work_dir" => "paths.work_dir",
+                "ipxe_dir" => "paths.ipxe_dir",
+                "smb_dir" => "paths.smb_dir",
+                "wimboot_path" => "paths.wimboot_path",
+                "unattended_dir" => "paths.unattended_dir",
+                // Unknown: support the explicit nested form
+                // (OPENPXE_SERVER__HTTP_PORT). `replace` is a no-op for the
+                // already-handled flat names above.
+                other => return other.replace("__", ".").into(),
             };
-        }
+            mapped.into()
-        if let Ok(v) = std::env::var("OPENPXE_ISO_DIR") {
+        })
-            self.paths.iso_dir = PathBuf::from(v);
+        .split(".")
-        }
+}
-        if let Ok(v) = std::env::var("OPENPXE_WORK_DIR") {
+
-            self.paths.work_dir = PathBuf::from(v);
+#[cfg(test)]
-        }
+mod tests {
-        if let Ok(v) = std::env::var("OPENPXE_IPXE_DIR") {
+    // figment's `Jail::expect_with` closure returns `Result<(), figment::Error>`
-            self.paths.ipxe_dir = PathBuf::from(v);
+    // and `figment::Error` is large; that's the library's API, not ours.
-        }
+    #![allow(clippy::result_large_err)]
-        if let Ok(v) = std::env::var("OPENPXE_SMB_DIR") {
+    use super::*;
-            self.paths.smb_dir = PathBuf::from(v);
+
-        }
+    #[test]
+    fn defaults_load_when_no_file_or_env() {
+        figment::Jail::expect_with(|_jail| {
+            let c = Config::load(None).expect("load defaults");
+            assert_eq!(c.server.http_port, 80);
+            assert_eq!(c.network.dhcp_mode, DhcpMode::Proxy);
+            assert_eq!(c.paths.iso_dir, PathBuf::from("/var/lib/openpxe/isos"));
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn legacy_flat_env_vars_still_apply() {
+        figment::Jail::expect_with(|jail| {
+            jail.set_env("OPENPXE_HTTP_PORT", "8123");
+            jail.set_env("OPENPXE_TFTP_PORT", "6900");
+            jail.set_env("OPENPXE_DHCP_PORT", "6767");
+            jail.set_env("OPENPXE_PXE_PORT", "4444");
+            jail.set_env("OPENPXE_PUBLIC_IP", "10.20.30.40");
+            jail.set_env("OPENPXE_DHCP_MODE", "disabled");
+            jail.set_env("OPENPXE_ISO_DIR", "/data/isos");
+            jail.set_env("OPENPXE_WORK_DIR", "/data/work");
+            jail.set_env("OPENPXE_IPXE_DIR", "/data/ipxe");
+            jail.set_env("OPENPXE_SMB_DIR", "/data/smb");
+            // v0.5.4: a field the old apply_env never covered.
+            jail.set_env("OPENPXE_UNATTENDED_DIR", "/data/unattended");
+            let c = Config::load(None).expect("load with env");
+            assert_eq!(c.server.http_port, 8123);
+            assert_eq!(c.server.tftp_port, 6900);
+            assert_eq!(c.network.dhcp_port, 6767);
+            assert_eq!(c.network.pxe_port, 4444);
+            assert_eq!(c.server.public_ip, Some("10.20.30.40".parse().unwrap()));
+            assert_eq!(c.network.dhcp_mode, DhcpMode::Disabled);
+            assert_eq!(c.paths.iso_dir, PathBuf::from("/data/isos"));
+            assert_eq!(c.paths.work_dir, PathBuf::from("/data/work"));
+            assert_eq!(c.paths.ipxe_dir, PathBuf::from("/data/ipxe"));
+            assert_eq!(c.paths.smb_dir, PathBuf::from("/data/smb"));
+            assert_eq!(c.paths.unattended_dir, PathBuf::from("/data/unattended"));
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn dhcp_mode_off_alias_maps_to_disabled() {
+        figment::Jail::expect_with(|jail| {
+            jail.set_env("OPENPXE_DHCP_MODE", "off");
+            let c = Config::load(None).unwrap();
+            assert_eq!(c.network.dhcp_mode, DhcpMode::Disabled);
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn nested_double_underscore_form_also_works() {
+        figment::Jail::expect_with(|jail| {
+            jail.set_env("OPENPXE_SERVER__HTTP_PORT", "9001");
+            let c = Config::load(None).unwrap();
+            assert_eq!(c.server.http_port, 9001);
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn env_overrides_toml_file() {
+        figment::Jail::expect_with(|jail| {
+            jail.create_file(
+                "openpxe.toml",
+                "[server]\nhttp_port = 8080\n[paths]\niso_dir = \"/from/toml\"\n",
+            )?;
+            jail.set_env("OPENPXE_HTTP_PORT", "8443");
+            let c = Config::load(Some(Path::new("openpxe.toml"))).unwrap();
+            // env wins over TOML…
+            assert_eq!(c.server.http_port, 8443);
+            // …but TOML-only values still apply.
+            assert_eq!(c.paths.iso_dir, PathBuf::from("/from/toml"));
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn unrelated_openpxe_env_vars_are_ignored() {
+        figment::Jail::expect_with(|jail| {
+            // entrypoint.sh sets these; they must not break config load.
+            jail.set_env("OPENPXE_UID", "10001");
+            jail.set_env("OPENPXE_CONFIG", "/etc/openpxe.toml");
+            let c = Config::load(None).expect("stray vars ignored");
+            assert_eq!(c.server.http_port, 80);
+            Ok(())
+        });
     }
 }

crates/core/src/encoding.rs

@@ -0,0 +1,65 @@
+//! Small, dependency-free encoding helpers shared across crates.
+//!
+//! v0.5.4: `pct_encode` and `xml_escape` were duplicated in the SAML
+//! modules and the HTTP layer; they live here now. They're deliberately
+//! hand-rolled rather than pulling in `percent-encoding` / `url`: the
+//! unreserved set below is exactly the RFC 3986 set that iPXE's
+//! `:uristring` modifier and the SAML HTTP-Redirect binding both expect,
+//! and a general-purpose URL crate escapes a different set.
+
+use std::fmt::Write as _;
+
+/// Percent-encode `s` per RFC 3986: the unreserved set
+/// (`A-Z` `a-z` `0-9` `-` `_` `.` `~`) passes through unchanged; every
+/// other byte becomes `%XX` (uppercase hex).
+#[must_use]
+pub fn pct_encode(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for b in s.bytes() {
+        match b {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                out.push(b as char);
+            }
+            _ => {
+                let _ = write!(out, "%{b:02X}");
+            }
+        }
+    }
+    out
+}
+
+/// Escape the five XML predefined entities so `s` is safe inside element
+/// text or a double-quoted attribute value.
+#[must_use]
+pub fn xml_escape(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '&' => out.push_str("&"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            '"' => out.push_str("&quot;"),
+            '\'' => out.push_str("&apos;"),
+            _ => out.push(c),
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pct_encode_unreserved_passthrough_else_hex() {
+        assert_eq!(pct_encode("node-7.lab_1~"), "node-7.lab_1~");
+        assert_eq!(pct_encode("aa:bb cc/?&="), "aa%3Abb%20cc%2F%3F%26%3D");
+        assert_eq!(pct_encode(""), "");
+    }
+
+    #[test]
+    fn xml_escape_all_five_entities() {
+        assert_eq!(xml_escape("a&b<c>\"d'e"), "a&amp;b&lt;c&gt;&quot;d&apos;e");
+        assert_eq!(xml_escape("plain text"), "plain text");
+    }
+}

crates/core/src/host_bindings.rs

@@ -21,6 +21,8 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use time::OffsetDateTime;
 
+use crate::profile::DeployProfile;
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct HostBinding {
     /// Lowercase, colon-separated MAC (e.g. `aa:bb:cc:dd:ee:ff`). The
@@ -35,6 +37,11 @@ pub struct HostBinding {
     /// `"rack-3 spine"`). Empty if unset.
     #[serde(default)]
     pub label: String,
+    /// v0.5.2: optional unattended-install hints (auto hostname / IP /
+    /// answer-file id). Flattened into the binding JSON so pre-v0.5.2
+    /// `hosts.json` files (which lack these keys) still deserialize.
+    #[serde(default, flatten)]
+    pub profile: DeployProfile,
     #[serde(with = "time::serde::rfc3339")]
     pub created_at: OffsetDateTime,
     #[serde(with = "time::serde::rfc3339")]
@@ -94,20 +101,31 @@ impl HostBindings {
     }
 
     /// Insert or update. Returns the resulting binding (with timestamps).
-    pub fn upsert(&self, mac: &str, target: &str, label: &str) -> HostBinding {
+    /// The `profile` carries optional unattended-install hints (v0.5.2);
+    /// pass `DeployProfile::default()` for a plain pin.
+    pub fn upsert(
+        &self,
+        mac: &str,
+        target: &str,
+        label: &str,
+        profile: DeployProfile,
+    ) -> HostBinding {
         let key = normalize_mac(mac);
         let now = OffsetDateTime::now_utc();
+        let profile = profile.normalized();
         let binding = {
             let mut g = self.inner.write();
             let entry = g.by_mac.entry(key.clone()).or_insert_with(|| HostBinding {
                 mac: key.clone(),
                 target: target.to_string(),
                 label: label.to_string(),
+                profile: profile.clone(),
                 created_at: now,
                 updated_at: now,
             });
             entry.target = target.to_string();
             entry.label = label.to_string();
+            entry.profile = profile.clone();
             entry.updated_at = now;
             entry.clone()
         };
@@ -179,6 +197,10 @@ mod tests {
     use super::*;
     use tempfile::tempdir;
 
+    fn np() -> DeployProfile {
+        DeployProfile::default()
+    }
+
     #[test]
     fn normalize_handles_case_and_dashes() {
         assert_eq!(normalize_mac("AA:BB:CC:DD:EE:FF"), "aa:bb:cc:dd:ee:ff");
@@ -191,7 +213,12 @@ mod tests {
         let dir = tempdir().unwrap();
         let h = HostBindings::load_or_default(dir.path());
         assert!(h.is_empty());
-        h.upsert("AA:BB:CC:00:00:01", "ubuntu-24-04-linux", "rack-3 spine");
+        h.upsert(
+            "AA:BB:CC:00:00:01",
+            "ubuntu-24-04-linux",
+            "rack-3 spine",
+            np(),
+        );
         let found = h.lookup("aa-bb-cc-00-00-01").expect("lookup");
         assert_eq!(found.target, "ubuntu-24-04-linux");
         assert_eq!(found.label, "rack-3 spine");
@@ -202,8 +229,8 @@ mod tests {
     fn upsert_replaces_existing_target() {
         let dir = tempdir().unwrap();
         let h = HostBindings::load_or_default(dir.path());
-        h.upsert("aa:bb:cc:00:00:01", "old-target", "label1");
+        h.upsert("aa:bb:cc:00:00:01", "old-target", "label1", np());
-        h.upsert("aa:bb:cc:00:00:01", "new-target", "label2");
+        h.upsert("aa:bb:cc:00:00:01", "new-target", "label2", np());
         assert_eq!(h.len(), 1);
         let b = h.lookup("aa:bb:cc:00:00:01").unwrap();
         assert_eq!(b.target, "new-target");
@@ -214,7 +241,7 @@ mod tests {
     fn remove_works_and_reports_outcome() {
         let dir = tempdir().unwrap();
         let h = HostBindings::load_or_default(dir.path());
-        h.upsert("aa:bb:cc:00:00:01", "x", "");
+        h.upsert("aa:bb:cc:00:00:01", "x", "", np());
         assert!(h.remove("AA:BB:CC:00:00:01"));
         assert!(!h.remove("aa:bb:cc:00:00:01")); // already gone
         assert!(h.is_empty());
@@ -224,11 +251,44 @@ mod tests {
     fn round_trip_persists_to_disk() {
         let dir = tempdir().unwrap();
         let h = HostBindings::load_or_default(dir.path());
-        h.upsert("aa:bb:cc:00:00:01", "ubuntu-linux", "rack-3");
+        h.upsert("aa:bb:cc:00:00:01", "ubuntu-linux", "rack-3", np());
-        h.upsert("aa:bb:cc:00:00:02", "_local", "tom-laptop");
+        h.upsert("aa:bb:cc:00:00:02", "_local", "tom-laptop", np());
         drop(h);
         let h2 = HostBindings::load_or_default(dir.path());
         assert_eq!(h2.len(), 2);
         assert_eq!(h2.lookup("aa:bb:cc:00:00:02").unwrap().target, "_local");
     }
+
+    #[test]
+    fn profile_round_trips_to_disk() {
+        let dir = tempdir().unwrap();
+        let h = HostBindings::load_or_default(dir.path());
+        let prof = DeployProfile {
+            auto_hostname: Some("node-7".into()),
+            auto_ip: Some("10.0.0.7".into()),
+            unattended_file: Some("ubuntu-ks".into()),
+        };
+        h.upsert("aa:bb:cc:00:00:09", "ubuntu-linux", "lab", prof);
+        drop(h);
+        let h2 = HostBindings::load_or_default(dir.path());
+        let b = h2.lookup("aa:bb:cc:00:00:09").unwrap();
+        assert_eq!(b.profile.auto_hostname.as_deref(), Some("node-7"));
+        assert_eq!(b.profile.auto_ip.as_deref(), Some("10.0.0.7"));
+        assert_eq!(b.profile.unattended_file.as_deref(), Some("ubuntu-ks"));
+    }
+
+    #[test]
+    fn legacy_hosts_json_without_profile_still_loads() {
+        // A pre-v0.5.2 hosts.json has no profile keys at all.
+        let dir = tempdir().unwrap();
+        std::fs::write(
+            dir.path().join("hosts.json"),
+            br#"[{"mac":"aa:bb:cc:00:00:01","target":"_local","label":"old","created_at":"2024-01-01T00:00:00Z","updated_at":"2024-01-01T00:00:00Z"}]"#,
+        )
+        .unwrap();
+        let h = HostBindings::load_or_default(dir.path());
+        let b = h.lookup("aa:bb:cc:00:00:01").unwrap();
+        assert_eq!(b.target, "_local");
+        assert!(b.profile.is_empty());
+    }
 }

crates/core/src/lib.rs

@@ -5,24 +5,30 @@
 pub mod arch;
 pub mod auth;
 pub mod boot_log;
+pub mod boot_rules;
+pub mod boot_tokens;
 pub mod branding;
 pub mod client;
 pub mod config;
+pub mod encoding;
 pub mod error;
 pub mod host_bindings;
 pub mod log_bus;
 pub mod metrics;
 pub mod notify;
+pub mod profile;
 pub mod queue;
 pub mod saml;
 pub mod settings;
 pub mod sso;
 pub mod wol;
 
-pub use arch::{ClientArch, FirmwareClass};
+pub use arch::{ClientArch, DriverMode, FirmwareClass};
 pub use auth::{AdminAccount, AdminPublic, AdminStore};
 pub use boot_log::{BootEvent, BootLog};
-pub use branding::{ext_for_mime, BrandingStore, ALLOWED_LOGO_MIMES, MAX_LOGO_BYTES};
+pub use boot_rules::{BootRule, BootRulesConfig, BootRulesStore};
+pub use boot_tokens::BootTokens;
+pub use branding::{ext_for_mime, BrandingStore, LogoSlot, ALLOWED_LOGO_MIMES, MAX_LOGO_BYTES};
 pub use client::{ClientEvent, ClientRegistry, ClientSnapshot};
 pub use config::{Config, DhcpMode, NetworkConfig, Paths, ServerConfig};
 pub use error::{Error, Result};
@@ -30,7 +36,8 @@ pub use host_bindings::{normalize_mac, HostBinding, HostBindings};
 pub use log_bus::{LogBus, LogBusLayer, LogLine};
 pub use metrics::{HttpRoute, Metrics};
 pub use notify::{NotifyConfig, NotifyKind, NotifyStore};
+pub use profile::DeployProfile;
 pub use queue::{DeploymentQueue, QueueEntry};
 pub use saml::{IdpMetadata, SamlError, SpParams, VerifiedPrincipal, VerifiedResponse};
 pub use settings::{Settings, SettingsStore, TimeoutAction};
-pub use sso::{SsoConfig, SsoStore};
+pub use sso::{SsoConfig, SsoLoginInfo, SsoStore};

crates/core/src/notify.rs

@@ -303,7 +303,10 @@ mod tests {
             smtp_host: "smtp.example.com".into(),
             ..Default::default()
         });
-        assert!(matches!(r, Err(Error::Invalid(_))), "missing recipient should reject");
+        assert!(
+            matches!(r, Err(Error::Invalid(_))),
+            "missing recipient should reject"
+        );
         s.replace(NotifyConfig {
             enabled: true,
             kind: NotifyKind::Smtp,

crates/core/src/profile.rs

@@ -0,0 +1,122 @@
+//! Per-host deployment profile.
+//!
+//! v0.5.2: a small, optional bundle of "what should this machine do when
+//! it images" attached to either a pinned host binding ([`crate::HostBinding`])
+//! or a queued device ([`crate::QueueEntry`]). All three fields are
+//! optional and independent:
+//!
+//! * `auto_hostname` — substituted into the served unattended answer file
+//!   (`{{HOSTNAME}}`) so the installer sets the machine name.
+//! * `auto_ip` — substituted as `{{IP}}`. OpenPXE is a DHCP **proxy** and
+//!   does not hand out leases, so this is applied by the installer as a
+//!   static-network directive inside the answer file, not by DHCP.
+//! * `unattended_file` — the id of an uploaded file in the unattended
+//!   store (Kickstart / Preseed / Autoinstall / Windows answer file). When
+//!   set, the boot chain injects the appropriate kernel argument so the
+//!   install runs unattended.
+
+use serde::{Deserialize, Serialize};
+
+/// Optional deployment hints carried on a host pin or a queue entry.
+///
+/// The fields are flattened into `HostBinding` / `QueueEntry` on the wire
+/// (so existing JSON stays compatible via `#[serde(default)]`); this type
+/// is the in-code bundle the boot chain consumes.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DeployProfile {
+    /// Hostname to set on the imaged machine (`{{HOSTNAME}}`). Empty/None
+    /// leaves the installer default.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub auto_hostname: Option<String>,
+    /// Static IPv4/IPv6 the installer should configure (`{{IP}}`). Stored
+    /// as a free-form string — validated lightly at the HTTP layer.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub auto_ip: Option<String>,
+    /// Id of an uploaded file in the unattended store. Empty/None means
+    /// "no unattended install — boot interactively".
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub unattended_file: Option<String>,
+}
+
+/// Cap on the stored hostname / IP strings — generous for any real value
+/// but bounds what an operator can stuff into the JSON.
+pub const MAX_PROFILE_FIELD_LEN: usize = 255;
+
+impl DeployProfile {
+    /// True when nothing is set — lets call sites skip work entirely.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.auto_hostname.is_none() && self.auto_ip.is_none() && self.unattended_file.is_none()
+    }
+
+    /// True when an unattended file is selected (drives boot-chain injection).
+    #[must_use]
+    pub fn has_unattended(&self) -> bool {
+        self.unattended_file
+            .as_deref()
+            .is_some_and(|s| !s.trim().is_empty())
+    }
+
+    /// Normalise: trim every field and collapse empty strings to `None`
+    /// so persisted JSON never carries `""` for an unset value.
+    #[must_use]
+    pub fn normalized(mut self) -> Self {
+        fn clean(v: Option<String>) -> Option<String> {
+            v.map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .map(|s| s.chars().take(MAX_PROFILE_FIELD_LEN).collect())
+        }
+        self.auto_hostname = clean(self.auto_hostname);
+        self.auto_ip = clean(self.auto_ip);
+        self.unattended_file = clean(self.unattended_file);
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_profile_is_empty() {
+        assert!(DeployProfile::default().is_empty());
+        assert!(!DeployProfile::default().has_unattended());
+    }
+
+    #[test]
+    fn normalize_trims_and_nulls_empty() {
+        let p = DeployProfile {
+            auto_hostname: Some("  node-7  ".into()),
+            auto_ip: Some("   ".into()),
+            unattended_file: Some(String::new()),
+        }
+        .normalized();
+        assert_eq!(p.auto_hostname.as_deref(), Some("node-7"));
+        assert_eq!(p.auto_ip, None);
+        assert_eq!(p.unattended_file, None);
+        assert!(!p.is_empty());
+    }
+
+    #[test]
+    fn has_unattended_detects_real_id() {
+        let p = DeployProfile {
+            unattended_file: Some("ubuntu-ks".into()),
+            ..Default::default()
+        };
+        assert!(p.has_unattended());
+    }
+
+    #[test]
+    fn long_field_is_capped() {
+        let long = "a".repeat(1000);
+        let p = DeployProfile {
+            auto_hostname: Some(long),
+            ..Default::default()
+        }
+        .normalized();
+        assert_eq!(
+            p.auto_hostname.as_deref().map(str::len),
+            Some(MAX_PROFILE_FIELD_LEN)
+        );
+    }
+}

crates/core/src/queue.rs

@@ -21,6 +21,7 @@ use time::OffsetDateTime;
 use tokio::sync::Notify;
 use uuid::Uuid;
 
+use crate::profile::DeployProfile;
 use crate::ClientArch;
 
 /// Per-client queue state visible to the WebUI.
@@ -37,6 +38,11 @@ pub struct QueueEntry {
     #[serde(with = "time::serde::rfc3339")]
     pub last_poll_at: OffsetDateTime,
     pub assigned_target: Option<String>,
+    /// v0.5.2: optional per-device deployment profile set via the queue
+    /// "Profile" button (auto hostname / IP / unattended file). Flattened
+    /// so the JSON stays flat alongside the other queue fields.
+    #[serde(default, flatten)]
+    pub profile: DeployProfile,
 }
 
 #[derive(Debug)]
@@ -49,6 +55,7 @@ struct QueueEntryInner {
     joined_at: OffsetDateTime,
     last_poll_at: OffsetDateTime,
     assigned_target: Option<String>,
+    profile: DeployProfile,
     /// Broadcast primitive that wakes the long-poll as soon as an
     /// assignment lands — no polling on our side, no sleep-loops.
     notify: Arc<Notify>,
@@ -65,6 +72,7 @@ impl QueueEntryInner {
             joined_at: self.joined_at,
             last_poll_at: self.last_poll_at,
             assigned_target: self.assigned_target.clone(),
+            profile: self.profile.clone(),
         }
     }
 }
@@ -110,6 +118,7 @@ impl DeploymentQueue {
             joined_at: now,
             last_poll_at: now,
             assigned_target: None,
+            profile: DeployProfile::default(),
             notify: Arc::new(Notify::new()),
         };
         let snap = inner.snapshot();
@@ -133,6 +142,29 @@ impl DeploymentQueue {
         Some(g.snapshot())
     }
 
+    /// Operator sets (or clears) the deployment profile for a queued
+    /// device via the WebUI "Profile" button. Returns the updated
+    /// snapshot, or `None` if the entry has since been released.
+    pub fn set_profile(&self, entry_id: &str, profile: DeployProfile) -> Option<QueueEntry> {
+        let mut guard = self.inner.write();
+        let g = guard.get_mut(entry_id)?;
+        g.profile = profile.normalized();
+        Some(g.snapshot())
+    }
+
+    /// Look up the deployment profile for a queued MAC, if any. Used by
+    /// the boot chain to inject an unattended file / template the
+    /// hostname + IP when an assigned device chains to its target.
+    #[must_use]
+    pub fn profile_for_mac(&self, mac: &str) -> Option<DeployProfile> {
+        let guard = self.inner.read();
+        guard
+            .values()
+            .find(|g| g.mac == mac)
+            .map(|g| g.profile.clone())
+            .filter(|p| !p.is_empty())
+    }
+
     /// Operator assigns an ISO entry (boot_entry id) to one or more clients.
     /// Returns the number of queue entries that were updated. Entries not in the
     /// queue are silently skipped.

crates/core/src/saml/authn_request.rs

@@ -5,7 +5,6 @@
 //! appended as the `SAMLRequest` query parameter. AuthnRequests are sent
 //! unsigned in this release (the IdP must not require client signatures).
 
-use std::fmt::Write as _;
 use std::io::Write as _;
 
 use base64::Engine;
@@ -15,6 +14,7 @@ use time::format_description::well_known::Rfc3339;
 use time::OffsetDateTime;
 
 use super::{SamlError, SpParams};
+use crate::encoding::{pct_encode, xml_escape};
 
 const NS_PROTOCOL: &str = "urn:oasis:names:tc:SAML:2.0:protocol";
 const NS_ASSERTION: &str = "urn:oasis:names:tc:SAML:2.0:assertion";
@@ -79,37 +79,8 @@ fn deflate_base64(xml: &str) -> Result<String, SamlError> {
     Ok(base64::engine::general_purpose::STANDARD.encode(compressed))
 }
 
-/// Percent-encode a query-string component (RFC 3986 unreserved set passes
+// `pct_encode` + `xml_escape` now live in `openpxe_core::encoding` (v0.5.4)
-/// through; everything else is `%XX`).
+// — imported above.
-fn pct_encode(s: &str) -> String {
-    let mut out = String::with_capacity(s.len() * 3);
-    for b in s.bytes() {
-        match b {
-            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
-                out.push(b as char);
-            }
-            _ => {
-                let _ = write!(out, "%{b:02X}");
-            }
-        }
-    }
-    out
-}
-
-fn xml_escape(s: &str) -> String {
-    let mut out = String::with_capacity(s.len());
-    for c in s.chars() {
-        match c {
-            '&' => out.push_str("&amp;"),
-            '<' => out.push_str("&lt;"),
-            '>' => out.push_str("&gt;"),
-            '"' => out.push_str("&quot;"),
-            '\'' => out.push_str("&apos;"),
-            _ => out.push(c),
-        }
-    }
-    out
-}
 
 #[cfg(test)]
 mod tests {

crates/core/src/saml/metadata.rs

@@ -7,6 +7,7 @@
 use base64::Engine;
 
 use super::{SamlError, SpParams};
+use crate::encoding::xml_escape;
 
 /// SAML 2.0 binding URIs.
 pub const BINDING_REDIRECT: &str = "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect";
@@ -148,21 +149,7 @@ fn node_text(n: &roxmltree::Node<'_, '_>) -> String {
         .collect()
 }
 
-/// Minimal XML attribute/text escaping for the values we interpolate.
+// `xml_escape` now lives in `openpxe_core::encoding` (v0.5.4) — imported above.
-fn xml_escape(s: &str) -> String {
-    let mut out = String::with_capacity(s.len());
-    for c in s.chars() {
-        match c {
-            '&' => out.push_str("&amp;"),
-            '<' => out.push_str("&lt;"),
-            '>' => out.push_str("&gt;"),
-            '"' => out.push_str("&quot;"),
-            '\'' => out.push_str("&apos;"),
-            _ => out.push(c),
-        }
-    }
-    out
-}
 
 #[cfg(test)]
 mod tests {

crates/core/src/sso.rs

@@ -73,6 +73,23 @@ impl SsoConfig {
     }
 }
 
+/// The minimal, non-sensitive slice of the SSO config that the **pre-auth**
+/// login screen needs to render the "Sign in with …" button. Carries only
+/// the display affordances — never the metadata XML/URL or entity ID, which
+/// stay behind the auth-gated `/api/sso`. Served as part of the public
+/// `/api/me` so the button renders reliably whether or not anyone is signed
+/// in (v0.5.9: fixes the button vanishing because `/api/sso` 401s pre-auth).
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct SsoLoginInfo {
+    /// True only when SSO is *usable* (enabled AND a metadata source is
+    /// present) — i.e. clicking the button will actually reach an IdP.
+    pub enabled: bool,
+    /// Button label, e.g. "STC AD". Empty falls back to "SSO" in the UI.
+    pub idp_name: String,
+    /// Optional IdP logo rendered on the button. Empty = no image.
+    pub idp_logo_url: String,
+}
+
 /// In-memory + on-disk SSO settings registry.
 #[derive(Debug, Clone)]
 pub struct SsoStore {
@@ -111,6 +128,19 @@ impl SsoStore {
         self.inner.read().clone()
     }
 
+    /// Public, non-sensitive descriptor for the login screen. Safe to
+    /// expose pre-auth — it's exactly what the "Sign in with …" button
+    /// keys off, with no metadata/entity-ID leakage. v0.5.9.
+    #[must_use]
+    pub fn login_info(&self) -> SsoLoginInfo {
+        let cfg = self.inner.read();
+        SsoLoginInfo {
+            enabled: cfg.is_usable(),
+            idp_name: cfg.idp_name.clone(),
+            idp_logo_url: cfg.idp_logo_url.clone(),
+        }
+    }
+
     /// Replace the whole config in one shot. Light validation: metadata
     /// XML and URL are length-capped so an operator can't OOM us by
     /// pasting a 10 GiB blob; the IdP UI tab clamps the input visually,

crates/core/src/wol.rs

@@ -181,10 +181,7 @@ mod tests {
             Ipv4Addr::new(192, 168, 1, 255)
         );
         assert_eq!(
-            subnet_broadcast(
+            subnet_broadcast(Ipv4Addr::new(10, 5, 3, 7), Ipv4Addr::new(255, 255, 0, 0)),
-                Ipv4Addr::new(10, 5, 3, 7),
-                Ipv4Addr::new(255, 255, 0, 0)
-            ),
             Ipv4Addr::new(10, 5, 255, 255)
         );
     }
@@ -196,7 +193,8 @@ mod tests {
         // and confirm send_magic transmits the exact 102-byte packet.
         let rx = UdpSocket::bind(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0)).unwrap();
         let port = rx.local_addr().unwrap().port();
-        rx.set_read_timeout(Some(std::time::Duration::from_secs(2))).unwrap();
+        rx.set_read_timeout(Some(std::time::Duration::from_secs(2)))
+            .unwrap();
 
         let packet = magic_packet([0x0a, 0x1b, 0x2c, 0x3d, 0x4e, 0x5f]);
         let sent = send_magic(&packet, &[Ipv4Addr::LOCALHOST], port).unwrap();

crates/dhcp-proxy/Cargo.toml

@@ -18,3 +18,9 @@ tracing.workspace = true
 thiserror.workspace = true
 anyhow.workspace = true
 bytes.workspace = true
+parking_lot.workspace = true
+# v0.7.1: learned driver modes persist to <work_dir>/driver_modes.json.
+serde_json.workspace = true
+
+[dev-dependencies]
+tempfile = "3.12"

crates/dhcp-proxy/src/escalation.rs

@@ -0,0 +1,494 @@
+//! Automatic per-MAC boot-binary escalation (v0.6.1, extended v0.7.x).
+//!
+//! OpenPXE serves the firmware-net iPXE build (`snponly`/`undionly`) by
+//! default — it's the most reliable choice for chainloading because the
+//! firmware just proved its network works by downloading the NBP. Two
+//! classes of machine can't run it:
+//!
+//! * a minority of NICs have a missing or buggy firmware UNDI/SNP stack —
+//!   they TFTP the binary fine but iPXE can't bring the link up;
+//! * Secure-Boot firmware downloads it fine but refuses to *execute* an
+//!   unsigned image.
+//!
+//! Both look identical from here: the tell-tale second DHCP DISCOVER
+//! carrying the `iPXE` user-class never arrives and the machine
+//! re-PXE-boots. So a fresh firmware DISCOVER from a MAC whose previous
+//! attempt was never confirmed climbs one rung:
+//! `Firmware → Builtin → Shim` (the signed shim+GRUB chain). The decision
+//! is sticky; there is no operator toggle; the default path is unchanged
+//! so hardware that already boots never regresses.
+//!
+//! v0.7.1 — **learned modes persist**. Walking the ladder costs one or
+//! two failed boot cycles, so a machine should pay it once *ever*, not
+//! once per idle window or server restart. Two events pin a MAC's mode
+//! to disk (`<work_dir>/driver_modes.json`):
+//!
+//! * a confirmed iPXE handoff at a non-default mode (Builtin proved to
+//!   work — also Shim, via the GRUB→iPXE same-boot chainload);
+//! * reaching the terminal Shim rung (Secure-Boot machines never produce
+//!   an iPXE handoff from the signed menu, so escalation itself is the
+//!   best knowledge we'll ever have).
+//!
+//! Pinned entries are immune to the TTL and reload at startup. The
+//! operator escape hatch is a rules-level driver-mode pin (which
+//! overrides this table entirely) or deleting `driver_modes.json`.
+
+use openpxe_core::DriverMode;
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+/// Multiple DISCOVERs within this window belong to the *same* boot (DHCP
+/// retransmits, plus the :4011 PXE Boot Server query that follows the :67
+/// DISCOVER). They must not be mistaken for a failed-and-retried boot.
+const SAME_BOOT_DEBOUNCE: Duration = Duration::from_secs(8);
+
+/// Forget an *unpinned* MAC's state after this long with no activity, so
+/// a transient mid-walk state doesn't linger and the map stays bounded.
+/// Pinned (learned) entries are exempt — that's their whole point.
+const ENTRY_TTL: Duration = Duration::from_mins(30);
+
+/// Hard cap on tracked MACs. Past this we evict the least-recently-seen
+/// entry (unpinned first) — escalation is best-effort, never a
+/// memory-growth vector.
+const MAX_ENTRIES: usize = 4096;
+
+/// How often (at most) the whole map is swept for expired entries.
+/// Correctness doesn't depend on the sweep — a stale entry is also
+/// detected inline when its MAC next appears — so the sweep only bounds
+/// memory for MACs that never return, and amortizing it keeps the
+/// per-packet path O(1) instead of O(map).
+const PRUNE_INTERVAL: Duration = Duration::from_mins(1);
+
+#[derive(Debug, Clone, Copy)]
+struct Entry {
+    mode: DriverMode,
+    /// True once we've served `mode` and are waiting for the iPXE handoff to
+    /// confirm it worked. A *new* boot arriving while this is still true means
+    /// the previous attempt failed and we should escalate.
+    awaiting_confirm: bool,
+    /// Learned mode (v0.7.1): persisted to disk, exempt from the TTL.
+    pinned: bool,
+    last_seen: Instant,
+}
+
+#[derive(Debug)]
+struct Inner {
+    map: HashMap<String, Entry>,
+    /// When the last full TTL sweep ran — see [`PRUNE_INTERVAL`].
+    last_prune: Instant,
+}
+
+impl Default for Inner {
+    fn default() -> Self {
+        Self {
+            map: HashMap::new(),
+            last_prune: Instant::now(),
+        }
+    }
+}
+
+/// Tracks per-MAC driver-mode escalation. Cheap to share via `Arc`.
+#[derive(Debug, Default)]
+pub struct DriverEscalation {
+    inner: Mutex<Inner>,
+    /// Persistence target for learned modes; `None` = ephemeral (tests).
+    path: Option<Arc<PathBuf>>,
+}
+
+impl DriverEscalation {
+    /// Ephemeral instance (no persistence) — used by tests.
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Instance backed by `<work_dir>/driver_modes.json`. Learned modes
+    /// from previous runs are reloaded as pinned entries; a missing or
+    /// corrupt file starts empty (same crash-cache policy as every other
+    /// store — a bad file must never block PXE).
+    #[must_use]
+    pub fn load_or_default(work_dir: &Path) -> Self {
+        let path = work_dir.join("driver_modes.json");
+        let mut map = HashMap::new();
+        if let Ok(text) = std::fs::read_to_string(&path) {
+            match serde_json::from_str::<HashMap<String, DriverMode>>(&text) {
+                Ok(loaded) => {
+                    let now = Instant::now();
+                    for (mac, mode) in loaded {
+                        // Firmware is the default — persisting it would be
+                        // noise; tolerate it in the file but don't track it.
+                        if mode == DriverMode::Firmware {
+                            continue;
+                        }
+                        map.insert(
+                            mac,
+                            Entry {
+                                mode,
+                                awaiting_confirm: false,
+                                pinned: true,
+                                last_seen: now,
+                            },
+                        );
+                    }
+                    tracing::info!(
+                        target: "openpxe::dhcp",
+                        learned = map.len(),
+                        "loaded learned driver modes"
+                    );
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        target: "openpxe::dhcp",
+                        "driver_modes.json present but unreadable ({e}); starting empty"
+                    );
+                }
+            }
+        }
+        Self {
+            inner: Mutex::new(Inner {
+                map,
+                last_prune: Instant::now(),
+            }),
+            path: Some(Arc::new(path)),
+        }
+    }
+
+    /// Decide the driver mode for a firmware (PXEClient/HTTPClient) boot from
+    /// `mac`. `primary` is true for the main DHCP DISCOVER (:67) and false for
+    /// the PXE Boot Server query (:4011); only the primary path drives
+    /// escalation, and only when it's clearly a *new* boot (outside the
+    /// same-boot debounce). The :4011 path just echoes the current mode.
+    pub fn mode_for_firmware_attempt(&self, mac: &str, primary: bool) -> DriverMode {
+        self.decide_at(mac, primary, Instant::now())
+    }
+
+    /// Record that `mac` completed the iPXE handoff (a DISCOVER carrying the
+    /// `iPXE` user-class). The mode we last served worked, so stop awaiting
+    /// confirmation, keep it sticky, and — for non-default modes — pin it to
+    /// disk so the machine never re-walks the ladder (v0.7.1).
+    pub fn mark_ipxe_success(&self, mac: &str) {
+        self.confirm_at(mac, Instant::now());
+    }
+
+    fn decide_at(&self, mac: &str, primary: bool, now: Instant) -> DriverMode {
+        let (mode, snapshot) = {
+            let mut g = self.inner.lock();
+            if now.duration_since(g.last_prune) >= PRUNE_INTERVAL {
+                g.map
+                    .retain(|_, e| e.pinned || now.duration_since(e.last_seen) < ENTRY_TTL);
+                g.last_prune = now;
+            }
+            // Inline staleness check: an unpinned MAC whose entry outlived
+            // the TTL starts fresh even when the amortized sweep above
+            // hasn't caught it yet. Pinned entries never go stale.
+            if g.map
+                .get(mac)
+                .is_some_and(|e| !e.pinned && now.duration_since(e.last_seen) >= ENTRY_TTL)
+            {
+                g.map.remove(mac);
+            }
+
+            let mut newly_pinned = false;
+            let mode = match g.map.get_mut(mac) {
+                None => {
+                    g.map.insert(
+                        mac.to_owned(),
+                        Entry {
+                            mode: DriverMode::Firmware,
+                            // Only the primary DISCOVER opens a confirmation window.
+                            awaiting_confirm: primary,
+                            pinned: false,
+                            last_seen: now,
+                        },
+                    );
+                    if g.map.len() > MAX_ENTRIES {
+                        evict_oldest(&mut g.map);
+                    }
+                    DriverMode::Firmware
+                }
+                Some(entry) => {
+                    let recent = now.duration_since(entry.last_seen) < SAME_BOOT_DEBOUNCE;
+                    if primary && !recent {
+                        // A genuinely new boot. If the previous attempt was
+                        // never confirmed, the build we served failed → climb
+                        // one rung: Firmware (firmware NIC stack) → Builtin
+                        // (iPXE's own drivers) → Shim (signed shim+GRUB —
+                        // covers Secure Boot firmware that downloads our
+                        // unsigned iPXE but refuses to execute it). Shim is
+                        // terminal and pins to disk: SB machines never emit
+                        // an iPXE handoff from the signed menu, so reaching
+                        // the rung *is* the durable knowledge.
+                        if entry.awaiting_confirm {
+                            entry.mode = match entry.mode {
+                                DriverMode::Firmware => DriverMode::Builtin,
+                                DriverMode::Builtin | DriverMode::Shim => DriverMode::Shim,
+                            };
+                            if entry.mode == DriverMode::Shim && !entry.pinned {
+                                entry.pinned = true;
+                                newly_pinned = true;
+                            }
+                        }
+                        entry.awaiting_confirm = true;
+                    }
+                    entry.last_seen = now;
+                    entry.mode
+                }
+            };
+            (mode, newly_pinned.then(|| pinned_snapshot(&g.map)))
+        };
+        if let Some(s) = snapshot {
+            self.persist(&s);
+        }
+        mode
+    }
+
+    fn confirm_at(&self, mac: &str, now: Instant) {
+        let snapshot = {
+            let mut g = self.inner.lock();
+            let Some(e) = g.map.get_mut(mac) else {
+                return;
+            };
+            e.awaiting_confirm = false;
+            e.last_seen = now;
+            // A proven non-default mode is worth remembering forever —
+            // the machine demonstrably can't use the default path.
+            if e.mode != DriverMode::Firmware && !e.pinned {
+                e.pinned = true;
+                Some(pinned_snapshot(&g.map))
+            } else {
+                None
+            }
+        };
+        if let Some(s) = snapshot {
+            self.persist(&s);
+        }
+    }
+
+    /// Best-effort atomic write of the learned-mode table. No-op for
+    /// ephemeral instances. Failure logs and moves on — persistence is an
+    /// optimization, never a correctness requirement.
+    fn persist(&self, snapshot: &HashMap<String, DriverMode>) {
+        let Some(path) = &self.path else { return };
+        let body = match serde_json::to_vec_pretty(snapshot) {
+            Ok(b) => b,
+            Err(e) => {
+                tracing::warn!(target: "openpxe::dhcp", "serialize driver_modes.json: {e}");
+                return;
+            }
+        };
+        if let Some(parent) = path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        let tmp = path.with_extension("json.tmp");
+        if let Err(e) = std::fs::write(&tmp, body) {
+            tracing::warn!(target: "openpxe::dhcp", "write driver_modes.json tmp: {e}");
+            return;
+        }
+        if let Err(e) = std::fs::rename(&tmp, path.as_path()) {
+            tracing::warn!(target: "openpxe::dhcp", "rename driver_modes.json: {e}");
+        }
+    }
+}
+
+fn pinned_snapshot(map: &HashMap<String, Entry>) -> HashMap<String, DriverMode> {
+    map.iter()
+        .filter(|(_, e)| e.pinned)
+        .map(|(k, e)| (k.clone(), e.mode))
+        .collect()
+}
+
+fn evict_oldest(map: &mut HashMap<String, Entry>) {
+    // Prefer evicting an unpinned entry; only touch learned modes when
+    // the whole table is pinned (4096 learned machines — at that point
+    // the operator has bigger questions than our memory bound).
+    let pick = |pinned: bool| {
+        map.iter()
+            .filter(|(_, e)| e.pinned == pinned)
+            .min_by_key(|(_, e)| e.last_seen)
+            .map(|(k, _)| k.clone())
+    };
+    if let Some(oldest) = pick(false).or_else(|| pick(true)) {
+        map.remove(&oldest);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn firmware_first_then_escalates_on_unconfirmed_retry() {
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        // Boot 1, primary DISCOVER: firmware.
+        assert_eq!(e.decide_at("aa", true, t0), DriverMode::Firmware);
+        // Same boot's :4011 query (+1s, within debounce): still firmware, no escalation.
+        assert_eq!(
+            e.decide_at("aa", false, t0 + Duration::from_secs(1)),
+            DriverMode::Firmware
+        );
+        // Firmware net failed → no iPXE handoff → machine re-PXE-boots much
+        // later: escalate to builtin drivers.
+        assert_eq!(
+            e.decide_at("aa", true, t0 + Duration::from_mins(1)),
+            DriverMode::Builtin
+        );
+    }
+
+    #[test]
+    fn builtin_is_sticky_after_success() {
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        assert_eq!(e.decide_at("bb", true, t0), DriverMode::Firmware);
+        assert_eq!(
+            e.decide_at("bb", true, t0 + Duration::from_mins(1)),
+            DriverMode::Builtin
+        );
+        // Builtin worked this time — confirm the handoff.
+        e.confirm_at("bb", t0 + Duration::from_secs(61));
+        // Next cold boot goes straight to builtin (no wasted firmware attempt).
+        assert_eq!(
+            e.decide_at("bb", true, t0 + Duration::from_mins(2)),
+            DriverMode::Builtin
+        );
+    }
+
+    #[test]
+    fn confirmed_firmware_never_escalates() {
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        assert_eq!(e.decide_at("cc", true, t0), DriverMode::Firmware);
+        // snponly worked: handoff confirmed.
+        e.confirm_at("cc", t0 + Duration::from_secs(2));
+        // A later boot stays on firmware — no spurious escalation.
+        assert_eq!(
+            e.decide_at("cc", true, t0 + Duration::from_mins(5)),
+            DriverMode::Firmware
+        );
+    }
+
+    #[test]
+    fn third_unconfirmed_attempt_escalates_to_shim_and_stays() {
+        // v0.7.0: a Secure-Boot client downloads-but-refuses both unsigned
+        // iPXE builds; the third boot gets the signed shim chain, and the
+        // MAC stays there for subsequent boots.
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        assert_eq!(e.decide_at("ee", true, t0), DriverMode::Firmware);
+        assert_eq!(
+            e.decide_at("ee", true, t0 + Duration::from_mins(1)),
+            DriverMode::Builtin
+        );
+        assert_eq!(
+            e.decide_at("ee", true, t0 + Duration::from_mins(2)),
+            DriverMode::Shim
+        );
+        // Shim is terminal — a fourth unconfirmed boot stays on Shim.
+        assert_eq!(
+            e.decide_at("ee", true, t0 + Duration::from_mins(3)),
+            DriverMode::Shim
+        );
+    }
+
+    #[test]
+    fn stale_unpinned_entry_is_forgotten_and_resets_to_firmware() {
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        assert_eq!(e.decide_at("dd", true, t0), DriverMode::Firmware);
+        assert_eq!(
+            e.decide_at("dd", true, t0 + Duration::from_mins(1)),
+            DriverMode::Builtin
+        );
+        // After the TTL with no activity the (unpinned) Builtin walk is
+        // pruned → fresh firmware. (A *confirmed* Builtin would be pinned
+        // and survive — see learned_builtin_survives_ttl.)
+        let later = t0 + Duration::from_mins(1) + ENTRY_TTL + Duration::from_secs(1);
+        assert_eq!(e.decide_at("dd", true, later), DriverMode::Firmware);
+    }
+
+    #[test]
+    fn shim_pin_survives_ttl() {
+        // v0.7.1: reaching the Shim rung is durable knowledge — the
+        // machine must NOT re-walk the ladder after an idle period.
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        let _ = e.decide_at("ff", true, t0);
+        let _ = e.decide_at("ff", true, t0 + Duration::from_mins(1));
+        assert_eq!(
+            e.decide_at("ff", true, t0 + Duration::from_mins(2)),
+            DriverMode::Shim
+        );
+        let much_later = t0 + Duration::from_mins(2) + ENTRY_TTL + Duration::from_mins(5);
+        assert_eq!(e.decide_at("ff", true, much_later), DriverMode::Shim);
+    }
+
+    #[test]
+    fn learned_builtin_survives_ttl() {
+        let e = DriverEscalation::new();
+        let t0 = Instant::now();
+        let _ = e.decide_at("gg", true, t0);
+        assert_eq!(
+            e.decide_at("gg", true, t0 + Duration::from_mins(1)),
+            DriverMode::Builtin
+        );
+        // The handoff confirms Builtin → pinned.
+        e.confirm_at("gg", t0 + Duration::from_secs(61));
+        let much_later = t0 + ENTRY_TTL + Duration::from_mins(10);
+        assert_eq!(e.decide_at("gg", true, much_later), DriverMode::Builtin);
+    }
+
+    #[test]
+    fn learned_modes_persist_across_restart() {
+        let dir = tempdir().unwrap();
+        let t0 = Instant::now();
+        {
+            let e = DriverEscalation::load_or_default(dir.path());
+            // Walk one MAC to Shim (pins on escalation)...
+            let _ = e.decide_at("aa:01", true, t0);
+            let _ = e.decide_at("aa:01", true, t0 + Duration::from_mins(1));
+            assert_eq!(
+                e.decide_at("aa:01", true, t0 + Duration::from_mins(2)),
+                DriverMode::Shim
+            );
+            // ...and another to a confirmed Builtin (pins on handoff).
+            let _ = e.decide_at("aa:02", true, t0);
+            let _ = e.decide_at("aa:02", true, t0 + Duration::from_mins(1));
+            e.confirm_at("aa:02", t0 + Duration::from_secs(61));
+        }
+        // "Restart": a fresh instance from the same work_dir knows both.
+        let e2 = DriverEscalation::load_or_default(dir.path());
+        assert_eq!(e2.decide_at("aa:01", true, t0), DriverMode::Shim);
+        assert_eq!(e2.decide_at("aa:02", true, t0), DriverMode::Builtin);
+        // Unlearned MACs still start at the default.
+        assert_eq!(e2.decide_at("aa:03", true, t0), DriverMode::Firmware);
+    }
+
+    #[test]
+    fn corrupt_persistence_file_starts_empty() {
+        let dir = tempdir().unwrap();
+        std::fs::write(dir.path().join("driver_modes.json"), b"{broken").unwrap();
+        let e = DriverEscalation::load_or_default(dir.path());
+        assert_eq!(
+            e.decide_at("aa:bb", true, Instant::now()),
+            DriverMode::Firmware
+        );
+    }
+
+    #[test]
+    fn confirmed_firmware_is_not_persisted() {
+        // The default mode is never written — the file only carries
+        // exceptions, so a healthy fleet leaves it absent/empty.
+        let dir = tempdir().unwrap();
+        let t0 = Instant::now();
+        {
+            let e = DriverEscalation::load_or_default(dir.path());
+            let _ = e.decide_at("aa:09", true, t0);
+            e.confirm_at("aa:09", t0 + Duration::from_secs(2));
+        }
+        assert!(!dir.path().join("driver_modes.json").exists());
+    }
+}

crates/dhcp-proxy/src/lib.rs

@@ -17,7 +17,9 @@
 //!   clients silently drop them.
 #![forbid(unsafe_code)]
 
+pub mod escalation;
 pub mod reply;
 pub mod server;
 
+pub use escalation::DriverEscalation;
 pub use server::DhcpProxyServer;

crates/dhcp-proxy/src/reply.rs

@@ -9,7 +9,7 @@
 //!     pass, or the HTTP URL of the boot script once iPXE has chained.
 
 use dhcproto::v4::{DhcpOption, Message, MessageType, Opcode, OptionCode};
-use openpxe_core::{ClientArch, FirmwareClass};
+use openpxe_core::{ClientArch, DriverMode, FirmwareClass};
 use std::net::Ipv4Addr;
 
 /// Where the reply directs the client next.
@@ -31,6 +31,11 @@ pub struct ReplyContext<'a> {
     pub our_ip: Ipv4Addr,
     pub arch: ClientArch,
     pub class: FirmwareClass,
+    /// Which iPXE network backend to advertise for this client. The DHCP
+    /// proxy fills this from the automatic per-MAC escalation state: normally
+    /// [`DriverMode::Firmware`], escalated to [`DriverMode::Builtin`] for a
+    /// MAC whose firmware-net boot failed to chainload (v0.6.1).
+    pub driver_mode: DriverMode,
     /// Public base URL (scheme://host[:port]) used in HTTP directives.
     pub public_base_url: &'a str,
 }
@@ -44,17 +49,27 @@ pub fn decide(ctx: &ReplyContext<'_>) -> BootDirective {
             // Pass the client's MAC in the query string so the HTTP
             // layer can short-circuit to a per-MAC binding when one
             // exists. iPXE substitutes `${mac}` literally before issuing
-            // the GET, so this stays static across firmwares.
+            // the GET, so this stays static across firmwares. The arch is
+            // known *here* from option 93, so it's baked in literally
+            // (v0.7.0) — it lets boot rules select on architecture.
             url: format!(
-                "{}/boot.ipxe?mac=${{mac}}",
+                "{}/boot.ipxe?mac=${{mac}}&arch={}",
-                ctx.public_base_url.trim_end_matches('/')
+                ctx.public_base_url.trim_end_matches('/'),
+                ctx.arch.as_str()
             ),
         },
         FirmwareClass::HttpClient => {
             // UEFI HTTP boot: client wants an http:// URL in option 67
-            // pointing at an EFI executable. We serve ipxe.efi over HTTP;
+            // pointing at an EFI executable. We serve the iPXE EFI build for
-            // it'll then do the same script-fetch the iPXE path does.
+            // the negotiated driver mode over HTTP; it'll then do the same
-            let name = ctx.arch.ipxe_bootfile().unwrap_or("snponly.efi");
+            // script-fetch the iPXE path does.
+            // `bootfile_with_fallback` (v0.7.0) walks back down the
+            // escalation ladder when the negotiated mode has no binary
+            // for this arch (e.g. Shim on an arch with no signed chain).
+            let name = ctx
+                .arch
+                .bootfile_with_fallback(ctx.driver_mode)
+                .unwrap_or("snponly.efi");
             BootDirective::HttpScript {
                 url: format!(
                     "{}/ipxe/{}",
@@ -63,7 +78,7 @@ pub fn decide(ctx: &ReplyContext<'_>) -> BootDirective {
                 ),
             }
         }
-        FirmwareClass::PxeClient => match ctx.arch.ipxe_bootfile() {
+        FirmwareClass::PxeClient => match ctx.arch.bootfile_with_fallback(ctx.driver_mode) {
             Some(name) => BootDirective::TftpIpxe {
                 filename: name.to_string(),
             },

crates/dhcp-proxy/src/server.rs

@@ -1,10 +1,13 @@
 //! UDP listener loop for the DHCP proxy. Accepts on :67 (and :4011 on a
 //! second socket) and dispatches each datagram through the pure reply logic.
 
+use crate::escalation::DriverEscalation;
 use crate::reply::{build_reply, decide, BootDirective, ReplyContext};
 use dhcproto::v4::{DhcpOption, Message, OptionCode};
 use dhcproto::{Decodable, Decoder, Encodable, Encoder};
-use openpxe_core::{ClientArch, ClientEvent, ClientRegistry, FirmwareClass};
+use openpxe_core::{
+    BootRulesStore, ClientArch, ClientEvent, ClientRegistry, DriverMode, FirmwareClass,
+};
 use socket2::{Domain, Protocol, Socket, Type};
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::Arc;
@@ -18,9 +21,19 @@ pub struct DhcpProxyServer {
     public_base_url: String,
     clients: Arc<ClientRegistry>,
     metrics: openpxe_core::Metrics,
+    /// Automatic per-MAC NIC driver-mode escalation (v0.6.1; persistent
+    /// learned modes since v0.7.1). Shared across the :67 and :4011
+    /// listener tasks via the server `Arc`. Built by the caller so the
+    /// persistence path comes from the configured work dir.
+    escalation: DriverEscalation,
+    /// v0.7.1: boot rules — consulted for an operator driver-mode pin
+    /// (e.g. "this OUI is all Secure Boot → serve shim immediately")
+    /// before the automatic escalation ladder.
+    rules: BootRulesStore,
 }
 
 impl DhcpProxyServer {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         bind: IpAddr,
         dhcp_port: u16,
@@ -29,6 +42,8 @@ impl DhcpProxyServer {
         public_base_url: String,
         clients: Arc<ClientRegistry>,
         metrics: openpxe_core::Metrics,
+        escalation: DriverEscalation,
+        rules: BootRulesStore,
     ) -> Self {
         Self {
             bind,
@@ -38,6 +53,8 @@ impl DhcpProxyServer {
             public_base_url,
             clients,
             metrics,
+            escalation,
+            rules,
         }
     }
 
@@ -126,11 +143,38 @@ impl DhcpProxyServer {
             },
         );
 
+        // Automatic NIC driver-mode selection (v0.6.1). The default is
+        // firmware-net (snponly/undionly). A successful iPXE handoff confirms
+        // the current mode works for this MAC; a fresh firmware boot whose
+        // predecessor never handed off escalates the MAC to iPXE's built-in
+        // NIC drivers. No operator toggle — the firmware path is unchanged so
+        // hardware that already boots never regresses.
+        let driver_mode = match class {
+            FirmwareClass::IpxeUserClass => {
+                self.escalation.mark_ipxe_success(&mac);
+                DriverMode::Firmware // unused: this path serves the HTTP script
+            }
+            FirmwareClass::PxeClient | FirmwareClass::HttpClient => {
+                // v0.7.1: an operator rule pin wins over (and bypasses)
+                // the automatic escalation ladder — known Secure-Boot
+                // fleets boot the signed chain on the very first cycle.
+                if let Some(pinned) = self.rules.driver_mode_hint(&mac, Some(arch.as_str())) {
+                    pinned
+                } else {
+                    self.escalation
+                        .mode_for_firmware_attempt(&mac, label == "67")
+                }
+            }
+            // Unreachable: FirmwareClass::Other returned above.
+            FirmwareClass::Other => DriverMode::Firmware,
+        };
+
         let ctx = ReplyContext {
             request: &request,
             our_ip: self.our_ip,
             arch,
             class,
+            driver_mode,
             public_base_url: &self.public_base_url,
         };
         let directive = decide(&ctx);
@@ -154,7 +198,7 @@ impl DhcpProxyServer {
         sock.send_to(&out, dest).await?;
         tracing::info!(
             target: "openpxe::dhcp",
-            mac=%mac, arch=arch.as_str(), class=?class, dest=%dest, directive=?directive,
+            mac=%mac, arch=arch.as_str(), class=?class, driver=?driver_mode, dest=%dest, directive=?directive,
             "PXE reply sent"
         );
         Ok(())
@@ -213,11 +257,16 @@ fn bind_udp(bind: IpAddr, port: u16, broadcast: bool) -> anyhow::Result<UdpSocke
 }
 
 fn format_mac(chaddr: &[u8]) -> String {
-    let take = chaddr.iter().take(6).copied().collect::<Vec<_>>();
+    use std::fmt::Write;
-    take.iter()
+    // One allocation — this runs for every PXE datagram we answer.
-        .map(|b| format!("{b:02x}"))
+    let mut s = String::with_capacity(17);
-        .collect::<Vec<_>>()
+    for (i, b) in chaddr.iter().take(6).enumerate() {
-        .join(":")
+        if i > 0 {
+            s.push(':');
+        }
+        let _ = write!(s, "{b:02x}");
+    }
+    s
 }
 
 /// Walk raw DHCP options looking for option 93 (Client System Architecture)

crates/http-api/Cargo.toml

@@ -33,8 +33,6 @@ thiserror.workspace = true
 anyhow.workspace = true
 bytes.workspace = true
 futures.workspace = true
-mime.workspace = true
-mime_guess.workspace = true
 uuid.workspace = true
 # v0.4.5 Forms auth: lock-free session store and cookie helpers.
 parking_lot.workspace = true
@@ -61,3 +59,9 @@ image = { version = "0.25", default-features = false, features = ["png"] }
 # replay, and IdP-initiated-gating flows exercise real signatures.
 rcgen = "0.13"
 bergshamra = { workspace = true }
+# v0.5.4: snapshot the generated iPXE menu so any unintended drift (a
+# dropped line, reordered item) is caught and reviewed, not silently shipped.
+insta = "1.40"
+# v0.5.4: stand up a mock HTTP server to exercise the SAML metadata-URL
+# fetch path (previously untested because it did a real network GET).
+wiremock = "0.6"

crates/http-api/src/auth.rs

@@ -154,16 +154,28 @@ pub fn session_cookie(session: &str) -> String {
 
 fn parse_cookie(headers: &axum::http::HeaderMap) -> Option<String> {
     // `Cookie: a=b; c=d` parsing — small enough not to drag in a crate.
+    // Two-step strip (name, then '=') keeps this allocation-free per
+    // candidate and can't match a longer cookie name sharing the prefix.
     let raw = headers.get(header::COOKIE)?.to_str().ok()?;
     for part in raw.split(';') {
         let part = part.trim();
-        if let Some(v) = part.strip_prefix(&format!("{SESSION_COOKIE}=")) {
+        if let Some(v) = part
+            .strip_prefix(SESSION_COOKIE)
+            .and_then(|rest| rest.strip_prefix('='))
+        {
             return Some(v.to_string());
         }
     }
     None
 }
 
+/// Does this request carry a live operator session? Used by endpoints
+/// outside the `/api/*` middleware that still want to honor a logged-in
+/// operator (e.g. browser-testing a token-gated answer file, v0.7.0).
+pub(crate) fn session_authenticated(state: &AppState, headers: &axum::http::HeaderMap) -> bool {
+    parse_cookie(headers).is_some_and(|t| state.sessions.touch(&t).is_some())
+}
+
 // ── Middleware ────────────────────────────────────────────────────────────
 
 /// Return `true` if `path` is on the allowlist and should bypass the
@@ -246,7 +258,14 @@ pub async fn api_setup(State(state): State<AppState>, Json(body): Json<SetupBody
         )
             .into_response();
     }
-    match state.admin.bootstrap(&body.username, &body.password) {
+    // bcrypt hashing is ~100-200 ms of pure CPU (and `bootstrap` also
+    // persists to disk synchronously) — keep it off the async workers.
+    let admin = state.admin.clone();
+    let result =
+        tokio::task::spawn_blocking(move || admin.bootstrap(&body.username, &body.password))
+            .await
+            .unwrap_or_else(|e| Err(openpxe_core::Error::Other(e.into())));
+    match result {
         Ok(pub_) => {
             let session = state.sessions.create(&pub_.username);
             login_response(StatusCode::CREATED, &pub_, &session)
@@ -271,8 +290,13 @@ pub struct LoginBody {
 pub async fn api_login(State(state): State<AppState>, Json(body): Json<LoginBody>) -> Response {
     // Brief, deliberately vague — "invalid credentials" rather than
     // "no such user" / "wrong password". Same anti-enumeration posture
-    // as Sonarr/Radarr.
+    // as Sonarr/Radarr. The bcrypt verify is ~100-200 ms of pure CPU on
-    let pub_ = match state.admin.verify(&body.username, &body.password) {
+    // an unauthenticated endpoint, so it runs on the blocking pool.
+    let admin = state.admin.clone();
+    let verdict = tokio::task::spawn_blocking(move || admin.verify(&body.username, &body.password))
+        .await
+        .unwrap_or_else(|e| Err(openpxe_core::Error::Other(e.into())));
+    let pub_ = match verdict {
         Ok(Some(u)) => u,
         Ok(None) => {
             return (
@@ -317,8 +341,14 @@ pub async fn api_me(State(state): State<AppState>, headers: axum::http::HeaderMa
     // screens can render the FleetDM-style full-width custom logo (and
     // cache-bust it) without an extra round trip. `/api/me` is public,
     // and the logo asset is public, so this leaks nothing sensitive.
-    let has_custom_logo = state.branding.has_logo();
+    let has_custom_logo = state.branding.has_any_web_logo();
     let logo_rev = state.branding.logo_rev();
+    // v0.5.9: ship the non-sensitive SSO descriptor with every /api/me so
+    // the pre-auth login screen can render the "Sign in with …" button
+    // reliably. Previously the button keyed off the auth-gated /api/sso,
+    // which 401s when logged out — the button only survived on a stale
+    // in-memory config and vanished on any fresh login-page load.
+    let sso = state.sso.login_info();
     if !state.admin.is_configured() {
         return (
             StatusCode::OK,
@@ -327,6 +357,7 @@ pub async fn api_me(State(state): State<AppState>, headers: axum::http::HeaderMa
                 "authenticated": false,
                 "has_custom_logo": has_custom_logo,
                 "logo_rev": logo_rev,
+                "sso": sso,
             })),
         )
             .into_response();
@@ -343,6 +374,7 @@ pub async fn api_me(State(state): State<AppState>, headers: axum::http::HeaderMa
                 "session_user": u,
                 "has_custom_logo": has_custom_logo,
                 "logo_rev": logo_rev,
+                "sso": sso,
             })),
         )
             .into_response(),
@@ -353,6 +385,7 @@ pub async fn api_me(State(state): State<AppState>, headers: axum::http::HeaderMa
                 "authenticated": false,
                 "has_custom_logo": has_custom_logo,
                 "logo_rev": logo_rev,
+                "sso": sso,
             })),
         )
             .into_response(),
@@ -385,11 +418,18 @@ pub async fn api_update_credentials(
         )
             .into_response();
     }
-    let result = state.admin.update_credentials(
+    // Two bcrypt operations (verify current + hash new) plus a sync disk
-        &body.current_password,
+    // persist — run the lot on the blocking pool.
-        body.new_username.as_deref(),
+    let admin = state.admin.clone();
-        body.new_password.as_deref(),
+    let result = tokio::task::spawn_blocking(move || {
-    );
+        admin.update_credentials(
+            &body.current_password,
+            body.new_username.as_deref(),
+            body.new_password.as_deref(),
+        )
+    })
+    .await
+    .unwrap_or_else(|e| Err(openpxe_core::Error::Other(e.into())));
     match result {
         Ok(pub_) => {
             state.sessions.revoke_all();

crates/http-api/src/error.rs

@@ -0,0 +1,92 @@
+//! Uniform HTTP error mapping for the API layer (v0.5.4).
+//!
+//! Before this, ~40 handlers in `app.rs` hand-wrote
+//! `match … { Err(e) => (StatusCode::…, format!("{e}")).into_response() }`,
+//! and the `openpxe_core::Error` → status mapping drifted between them
+//! (e.g. `Invalid` → 400 in most places, 404 in one). [`AppError`] wraps
+//! `openpxe_core::Error` so a handler can return `Result<T, AppError>` and
+//! `?` its way out, getting one consistent status + body. The body stays
+//! plain-text (matching the previous `(StatusCode, String)` responses) so
+//! existing clients and tests see no shape change; 5xx detail is logged
+//! and returned verbatim exactly as before.
+//!
+//! Handlers with *intentional* domain-specific statuses (e.g. a duplicate
+//! share → 409, a still-open chunked upload → 409) keep their explicit
+//! returns — `AppError` is for the common case, not a straitjacket.
+
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Response};
+use openpxe_core::Error as CoreError;
+
+/// Newtype over [`openpxe_core::Error`] with a uniform [`IntoResponse`].
+#[derive(Debug)]
+pub struct AppError(pub CoreError);
+
+impl From<CoreError> for AppError {
+    fn from(e: CoreError) -> Self {
+        AppError(e)
+    }
+}
+
+impl From<std::io::Error> for AppError {
+    fn from(e: std::io::Error) -> Self {
+        AppError(CoreError::Io(e))
+    }
+}
+
+impl AppError {
+    /// The HTTP status this error maps to. Public so handlers (and tests)
+    /// can reason about the mapping in one place.
+    #[must_use]
+    pub fn status(&self) -> StatusCode {
+        match self.0 {
+            CoreError::NotFound(_) => StatusCode::NOT_FOUND,
+            CoreError::Invalid(_) => StatusCode::BAD_REQUEST,
+            CoreError::Config(_) | CoreError::Io(_) | CoreError::Other(_) => {
+                StatusCode::INTERNAL_SERVER_ERROR
+            }
+        }
+    }
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        let status = self.status();
+        // Match the prior hand-written responses: the 4xx arms returned the
+        // bare inner message (not the `Display` prefix), so a UI showing
+        // `await r.text()` reads "metadata too long", not "invalid input:
+        // metadata too long". 5xx keeps the full `Display` string.
+        let body = match &self.0 {
+            CoreError::Invalid(m) | CoreError::NotFound(m) => m.clone(),
+            other => other.to_string(),
+        };
+        if status.is_server_error() {
+            // Log the full detail server-side; the body still carries it
+            // (unchanged from the prior `format!("{e}")` behaviour), but the
+            // log line is what an operator greps for.
+            tracing::error!(target: "openpxe::http", error = %self.0, "request failed");
+        }
+        (status, body).into_response()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn status_mapping_is_consistent() {
+        assert_eq!(
+            AppError(CoreError::NotFound("x".into())).status(),
+            StatusCode::NOT_FOUND
+        );
+        assert_eq!(
+            AppError(CoreError::Invalid("x".into())).status(),
+            StatusCode::BAD_REQUEST
+        );
+        assert_eq!(
+            AppError(CoreError::Config("x".into())).status(),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+    }
+}

crates/http-api/src/grub_script.rs

@@ -0,0 +1,192 @@
+//! GRUB menu rendering for the Secure Boot chain (v0.7.0).
+//!
+//! Secure-Boot-enabled firmware refuses our unsigned iPXE, so those
+//! clients are automatically escalated (see `openpxe_dhcp_proxy::
+//! escalation`) to the Microsoft-signed Fedora `shim` → signed `grub`
+//! chain. GRUB then fetches `grub.cfg` from this server (TFTP `$prefix`
+//! resolution, or HTTP when the whole chain came over HTTP Boot) — and
+//! this module renders that config from the same boot-entry model that
+//! renders `boot.ipxe`.
+//!
+//! Scope: **Linux kernel entries only.** A signed GRUB will only execute
+//! kernels that pass shim verification — i.e. distro-signed kernels —
+//! which is exactly what `LinuxKernel` boot entries point at. `sanboot`
+//! ISO emulation and `wimboot` are iPXE mechanisms with no signed
+//! equivalent; those entries are omitted here, and the menu says so.
+//! (Windows deployment under Secure Boot has no legitimate unsigned
+//! path — per project policy we never ship test-signed binaries or touch
+//! client trust stores.)
+//!
+//! The kernel/initrd lines use GRUB's `(http,host:port)` device syntax;
+//! Fedora's signed netboot GRUB carries the `http`, `tftp` and `efinet`
+//! modules built in, so no unsigned module loading is required.
+
+use openpxe_iso_store::{BootKind, IsoMeta};
+use std::fmt::Write as _;
+
+/// Render the full `grub.cfg` for the signed-GRUB menu.
+///
+/// `base_url` is the public HTTP base (`http://10.0.0.5` or
+/// `http://10.0.0.5:8080`) — converted to GRUB's `(http,host:port)`
+/// device prefix for kernel/initrd fetches.
+#[must_use]
+pub fn render_grub_menu(isos: &[IsoMeta], base_url: &str) -> String {
+    let base = base_url.trim_end_matches('/');
+    let dev = grub_http_device(base);
+    let mut s = String::new();
+    let _ = writeln!(s, "# OpenPXE — Secure Boot menu (signed shim+GRUB chain)");
+    // v0.7.1: before showing the limited signed menu, try to hand the
+    // boot back to full iPXE *in this same boot cycle*. With Secure Boot
+    // OFF the chainload succeeds and the client gets the complete iPXE
+    // feature set (sanboot, wimboot, the full menu) despite having been
+    // escalated here. With Secure Boot ON, shim's verifier refuses the
+    // unsigned image INLINE — no reboot, no failed cycle — and execution
+    // falls through to the signed menu below. The all-drivers build is
+    // used because a MAC only lands here after the firmware-net build
+    // already failed once.
+    let _ = writeln!(s, "if [ \"$grub_cpu\" = \"arm64\" ]; then");
+    let _ = writeln!(s, "    set openpxe_ipxe=ipxe-arm64.efi");
+    let _ = writeln!(s, "else");
+    let _ = writeln!(s, "    set openpxe_ipxe=ipxe.efi");
+    let _ = writeln!(s, "fi");
+    let _ = writeln!(s, "if chainloader {dev}/ipxe/$openpxe_ipxe ; then");
+    let _ = writeln!(s, "    boot");
+    let _ = writeln!(s, "fi");
+    let _ = writeln!(s);
+    let _ = writeln!(s, "set timeout=30");
+    let _ = writeln!(s, "set default=0");
+    let _ = writeln!(s);
+
+    let mut entries = 0usize;
+    for iso in isos {
+        for entry in &iso.boot_entries {
+            let BootKind::LinuxKernel {
+                kernel_url,
+                initrd_urls,
+                args,
+            } = &entry.kind
+            else {
+                continue;
+            };
+            // GRUB menu titles: keep quotes out of the label.
+            let title = entry.title.replace('"', "'");
+            let cmdline = args.cmdline.replace("${base-url}", base);
+            let _ = writeln!(s, "menuentry \"{} — {title}\" {{", iso.filename);
+            let _ = writeln!(s, "    linux {dev}/{kernel_url} {cmdline}");
+            if !initrd_urls.is_empty() {
+                let _ = write!(s, "    initrd");
+                for u in initrd_urls {
+                    let _ = write!(s, " {dev}/{u}");
+                }
+                let _ = writeln!(s);
+            }
+            let _ = writeln!(s, "}}");
+            let _ = writeln!(s);
+            entries += 1;
+        }
+    }
+
+    if entries == 0 {
+        let _ = writeln!(
+            s,
+            "menuentry \"No Secure-Boot-bootable images on this server yet\" {{ true }}"
+        );
+        let _ = writeln!(s);
+    }
+    // Always give the operator a way off this screen.
+    let _ = writeln!(s, "menuentry \"Boot from local disk\" {{");
+    let _ = writeln!(s, "    exit");
+    let _ = writeln!(s, "}}");
+    s
+}
+
+/// `http://10.0.0.5:8080` → `(http,10.0.0.5:8080)`. GRUB wants the
+/// scheme as the device type and host[:port] as the device address.
+fn grub_http_device(base: &str) -> String {
+    let host = base
+        .trim_start_matches("http://")
+        .trim_start_matches("https://");
+    format!("(http,{host})")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use openpxe_iso_store::{BootEntry, IsoSource, KernelArgs};
+
+    fn linux_iso() -> IsoMeta {
+        IsoMeta {
+            id: "alp".into(),
+            filename: "alpine.iso".into(),
+            size_bytes: 1,
+            sha256_hex: None,
+            uploaded_at: time::OffsetDateTime::UNIX_EPOCH,
+            source: IsoSource::Local,
+            introspection: openpxe_iso_store::IntrospectionReport::default(),
+            boot_entries: vec![BootEntry {
+                id: "alp-linux".into(),
+                title: "Linux installer".into(),
+                kind: BootKind::LinuxKernel {
+                    kernel_url: "iso/alp/boot/vmlinuz".into(),
+                    initrd_urls: vec!["iso/alp/boot/initrd".into()],
+                    args: KernelArgs {
+                        cmdline: "quiet repo=${base-url}/iso/alp.iso".into(),
+                    },
+                },
+            }],
+            category: openpxe_iso_store::IsoCategory::default(),
+            password_hash: None,
+        }
+    }
+
+    #[test]
+    fn renders_linux_entries_with_http_device_urls() {
+        let cfg = render_grub_menu(&[linux_iso()], "http://10.0.0.5:8080/");
+        assert!(
+            cfg.contains("menuentry \"alpine.iso — Linux installer\""),
+            "{cfg}"
+        );
+        assert!(
+            cfg.contains("linux (http,10.0.0.5:8080)/iso/alp/boot/vmlinuz quiet repo=http://10.0.0.5:8080/iso/alp.iso"),
+            "{cfg}"
+        );
+        assert!(
+            cfg.contains("initrd (http,10.0.0.5:8080)/iso/alp/boot/initrd"),
+            "{cfg}"
+        );
+        assert!(cfg.contains("Boot from local disk"), "{cfg}");
+    }
+
+    #[test]
+    fn config_tries_ipxe_chainload_before_menu() {
+        // v0.7.1: SB-off machines recover full iPXE in the same boot;
+        // SB-on machines fail the chainload inline and reach the menu.
+        let cfg = render_grub_menu(&[linux_iso()], "http://10.0.0.5:8080");
+        let chain_pos = cfg
+            .find("if chainloader (http,10.0.0.5:8080)/ipxe/$openpxe_ipxe ; then")
+            .expect("chainload attempt missing");
+        let menu_pos = cfg.find("menuentry").expect("menu missing");
+        assert!(
+            chain_pos < menu_pos,
+            "chainload must precede the menu:\n{cfg}"
+        );
+        // Arch-conditional binary selection via GRUB's $grub_cpu.
+        assert!(cfg.contains("set openpxe_ipxe=ipxe-arm64.efi"), "{cfg}");
+        assert!(cfg.contains("set openpxe_ipxe=ipxe.efi"), "{cfg}");
+    }
+
+    #[test]
+    fn sanboot_and_wimboot_entries_are_omitted() {
+        let mut iso = linux_iso();
+        iso.boot_entries = vec![BootEntry {
+            id: "win".into(),
+            title: "Windows".into(),
+            kind: BootKind::SanBootIso {
+                iso_url: "iso/win.iso".into(),
+            },
+        }];
+        let cfg = render_grub_menu(&[iso], "http://10.0.0.5");
+        assert!(!cfg.contains("Windows"), "{cfg}");
+        assert!(cfg.contains("No Secure-Boot-bootable images"), "{cfg}");
+    }
+}

crates/http-api/src/ipxe_script.rs

@@ -61,16 +61,24 @@ pub fn render_menu(isos: &[IsoMeta], settings: &Settings, base_url: &str) -> Str
     // returns a full-screen 1024×768 PNG now — the operator's logo on a
     // dark field, or a default OpenPXE mark when none is uploaded. The
     // `--top 290` reserves the top band (where the logo paints) so the
-    // menu text lands below it. On an iPXE build *with* `IMAGE_PNG` +
+    // menu text lands below it.
-    // `CONSOLE_FRAMEBUFFER` (our x86_64 UEFI binaries, built from source
+    //
-    // — see deploy/docker/Dockerfile) this paints the background and
+    // v0.5.7: gate the whole command behind `iseq ${platform} efi`.
-    // overlays the menu. On a build *without* PNG support (the fetched
+    // `console --picture` needs IMAGE_PNG + CONSOLE_FRAMEBUFFER, which
-    // BIOS/i386/arm64 binaries) the whole `console --picture …` command
+    // only our from-source UEFI binaries carry (x86_64/arm64 UEFI — see
-    // fails and the `|| console` resets to a clean full-screen text
+    // deploy/docker/Dockerfile). The fetched BIOS `undionly.kpxe` has
-    // menu. Either way there's no ASCII placeholder anymore.
+    // neither, and on legacy BIOS the `--picture` attempt misbehaves
+    // *before* the trailing `|| console` fallback can recover (it tries
+    // to set a framebuffer mode the BIOS console can't honour). Guarding
+    // on platform means BIOS clients never issue the command at all —
+    // they drop straight to the plain text menu — while UEFI clients
+    // still get the graphical background. A PNG-less UEFI build (e.g. the
+    // upstream i386-efi baseline) still falls back gracefully through the
+    // same `|| console`. No operator toggle needed; mixed BIOS+UEFI
+    // fleets each get the right treatment automatically.
     let _ = writeln!(
         s,
-        "console --picture {base}/branding/pxe-logo --top 290 || console"
+        "iseq ${{platform}} efi && console --picture {base}/branding/pxe-logo --top 290 || console"
     );
     // Map iPXE's ${{buildarch}} + ${{platform}} into the human form the
     // user asked for (e.g. "x86 BIOS", "x86_64 UEFI", "arm64 UEFI").
@@ -101,12 +109,13 @@ pub fn render_menu(isos: &[IsoMeta], settings: &Settings, base_url: &str) -> Str
     } else {
         let _ = writeln!(s, "item --gap -- (no Linux ISOs uploaded)");
     }
-    if settings.windows_enabled && has_family(isos, is_windows_family) {
+    // v0.5.8: Windows just works — no Settings toggle. Show the Windows
+    // installers submenu whenever a Windows ISO is present; entries boot
+    // via HTTP sanboot of the raw ISO, so no SMB/extraction is required.
+    if has_family(isos, is_windows_family) {
         let _ = writeln!(s, "item windows          Windows Installers  >");
-    } else if settings.windows_enabled {
-        let _ = writeln!(s, "item --gap -- (no Windows ISOs uploaded)");
     } else {
-        let _ = writeln!(s, "item --gap -- (Windows support disabled in Settings)");
+        let _ = writeln!(s, "item --gap -- (no Windows ISOs uploaded)");
     }
     let _ = writeln!(
         s,
@@ -460,8 +469,21 @@ pub fn render_queue_entry(base_url: &str) -> String {
 }
 
 /// Per-entry boot script (same as Phase 1, with extra_kernel_args appended).
+///
+/// `unattended_args` (v0.5.2) carries the per-host unattended-install
+/// kernel arguments (`inst.ks=…`, `auto=true … url=…`, or
+/// `autoinstall ds=nocloud-net;s=…`) when the requesting MAC has a
+/// deployment profile with an answer file selected. It's appended to the
+/// Linux kernel command line after the operator's global extra args, and
+/// ignored for Windows (wimboot) / sanboot entries which don't take a
+/// kernel cmdline.
 #[must_use]
-pub fn render_entry(entry: &BootEntry, settings: &Settings, base_url: &str) -> String {
+pub fn render_entry(
+    entry: &BootEntry,
+    settings: &Settings,
+    base_url: &str,
+    unattended_args: Option<&str>,
+) -> String {
     let mut s = String::new();
     let base = base_url.trim_end_matches('/');
     let _ = writeln!(s, "#!ipxe");
@@ -477,6 +499,12 @@ pub fn render_entry(entry: &BootEntry, settings: &Settings, base_url: &str) -> S
                 cmdline.push(' ');
                 cmdline.push_str(settings.extra_kernel_args.trim());
             }
+            if let Some(extra) = unattended_args {
+                if !extra.trim().is_empty() {
+                    cmdline.push(' ');
+                    cmdline.push_str(extra.trim());
+                }
+            }
             let _ = writeln!(s, "kernel {base}/{kernel_url} {cmdline}");
             for u in initrd_urls {
                 let _ = writeln!(s, "initrd {base}/{u}");
@@ -674,6 +702,22 @@ mod password_tests {
         assert!(s.contains("arm64 UEFI"), "{s}");
     }
 
+    // v0.5.4: a full snapshot of the rendered top menu. The fragment
+    // `assert!`s above check specific invariants; this catches *any* other
+    // drift (a reordered item, a dropped line, changed spacing) so it's
+    // reviewed deliberately. The OpenPXE version is filtered out so the
+    // snapshot doesn't churn on every release bump.
+    #[test]
+    fn render_menu_snapshot() {
+        // Normalize the compile-time version so the snapshot doesn't churn
+        // on every release bump (no insta `filters` feature needed).
+        let rendered = render_menu(&[], &Settings::default(), "http://10.0.0.5").replace(
+            concat!("OpenPXE v", env!("CARGO_PKG_VERSION")),
+            "OpenPXE vX.Y.Z",
+        );
+        insta::assert_snapshot!(rendered);
+    }
+
     #[test]
     fn generated_scripts_do_not_emit_bare_or_trailing_fallbacks() {
         let settings = Settings::default();

crates/http-api/src/lib.rs

@@ -15,6 +15,8 @@
 
 pub mod app;
 pub mod auth;
+pub mod error;
+pub mod grub_script;
 pub mod ipxe_script;
 pub mod iso_fs;
 pub mod log_stream;

crates/http-api/src/notify.rs

@@ -105,7 +105,11 @@ async fn send_email(cfg: &NotifyConfig, subject: &str, body: &str) -> Result<(),
             .trim()
             .parse()
             .map_err(|e| format!("invalid To address '{}': {e}", cfg.smtp_to))?)
-        .subject(if subject.is_empty() { "OpenPXE" } else { subject })
+        .subject(if subject.is_empty() {
+            "OpenPXE"
+        } else {
+            subject
+        })
         .body(body.to_string())
         .map_err(|e| format!("could not build email: {e}"))?;
 

crates/http-api/src/saml_routes.rs

@@ -336,3 +336,35 @@ fn redirect_with_session(location: &str, session: &str) -> Response {
             IntoResponse::into_response,
         )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wiremock::matchers::method;
+    use wiremock::{Mock, MockServer, ResponseTemplate};
+
+    // v0.5.4: exercise the SAML metadata-URL fetch against a mock server —
+    // previously this path did a real network GET and had no coverage.
+    #[tokio::test]
+    async fn fetch_metadata_returns_body_on_200() {
+        let server = MockServer::start().await;
+        let xml = "<EntityDescriptor>idp</EntityDescriptor>";
+        Mock::given(method("GET"))
+            .respond_with(ResponseTemplate::new(200).set_body_string(xml))
+            .mount(&server)
+            .await;
+        let got = fetch_metadata(&server.uri()).await.expect("fetch ok");
+        assert_eq!(got, xml);
+    }
+
+    #[tokio::test]
+    async fn fetch_metadata_errors_on_non_2xx() {
+        let server = MockServer::start().await;
+        Mock::given(method("GET"))
+            .respond_with(ResponseTemplate::new(503))
+            .mount(&server)
+            .await;
+        let err = fetch_metadata(&server.uri()).await.unwrap_err();
+        assert!(matches!(err, SamlError::Metadata(_)), "got {err:?}");
+    }
+}

crates/http-api/src/snapshots/openpxe_http_api__ipxe_script__password_tests__render_menu_snapshot.snap

@@ -0,0 +1,36 @@
+---
+source: crates/http-api/src/ipxe_script.rs
+expression: rendered
+---
+#!ipxe
+# OpenPXE top-level menu - auto-generated, do not edit
+set base-url http://10.0.0.5
+set esc:hex 1b
+set cls ${esc:string}[2J
+iseq ${platform} efi && console --picture http://10.0.0.5/branding/pxe-logo --top 290 || console
+set arch-label ${buildarch} ${platform}
+iseq ${buildarch} i386   && iseq ${platform} pcbios && set arch-label x86 BIOS         || iseq ${buildarch} x86_64 && iseq ${platform} efi    && set arch-label x86_64 UEFI      || iseq ${buildarch} arm64  && iseq ${platform} efi    && set arch-label arm64 UEFI       || true
+:menu
+menu OpenPXE - network boot menu
+item --gap
+item --gap -- ------------------------- Default -------------------------
+item local            Boot from Local HDD
+item --gap -- ----------------------- Installers -----------------------
+item --gap -- (no Linux ISOs uploaded)
+item --gap -- (no Windows ISOs uploaded)
+item --gap -- -------------------------- Tools --------------------------
+item tools            Tools  >
+item --gap -- ---------------------- Queued Deployment ---------------------
+item queue            Queued Deployment  (join queue)
+item --gap
+item --key x exit     Exit iPXE
+item --gap
+item --gap --                 OpenPXE vX.Y.Z  -  ${arch-label}
+choose --default queue --timeout 600000 target || goto menu
+iseq ${target} local   && chain http://10.0.0.5/boot/_local.ipxe        || goto menu
+iseq ${target} linux   && chain http://10.0.0.5/boot/_linux_menu.ipxe   || goto menu
+iseq ${target} windows && chain http://10.0.0.5/boot/_windows_menu.ipxe || goto menu
+iseq ${target} tools   && chain http://10.0.0.5/boot/_tools_menu.ipxe   || goto menu
+iseq ${target} queue   && chain http://10.0.0.5/boot/_queue.ipxe         || goto menu
+iseq ${target} exit    && exit                                 || goto menu
+goto menu

crates/http-api/src/state.rs

@@ -2,13 +2,19 @@ use crate::auth::SessionStore;
 use crate::saml_routes::SamlRuntime;
 use crate::uploads::UploadSessions;
 use openpxe_core::{
-    AdminStore, BootLog, BrandingStore, ClientRegistry, DeploymentQueue, HostBindings, LogBus,
+    AdminStore, BootLog, BootRulesStore, BootTokens, BrandingStore, ClientRegistry,
-    Metrics, NotifyStore, SettingsStore, SsoStore,
+    DeploymentQueue, HostBindings, LogBus, Metrics, NotifyStore, SettingsStore, SsoStore,
+};
+use openpxe_iso_store::{
+    IsoStore, NfsShareManager, SftpShareManager, SmbManager, SmbShareManager, UnattendedStore,
 };
-use openpxe_iso_store::{IsoStore, NfsShareManager, SmbManager, SmbShareManager};
 use std::sync::Arc;
 use time::OffsetDateTime;
 
+/// Cached composited PXE boot-menu background: `(logo_rev, encoded PNG)`.
+/// See `AppState::pxe_bg_cache`.
+pub type PxeBgCache = Arc<parking_lot::Mutex<Option<(u64, bytes::Bytes)>>>;
+
 #[derive(Clone)]
 pub struct AppState {
     pub iso_store: IsoStore,
@@ -23,10 +29,24 @@ pub struct AppState {
     /// every `/boot/<entry>.ipxe` chain that goes on to serve a script
     /// (i.e. an image actually starting to install on a machine).
     pub boot_log: BootLog,
+    /// v0.7.0: ordered label-based boot rules (MAC prefix / arch →
+    /// target) plus the optional boot-decision webhook. Consulted by the
+    /// top-level boot script after exact host bindings, before the menu.
+    pub boot_rules: BootRulesStore,
+    /// v0.7.0: short-lived access tokens for unattended answer files.
+    /// Minted into every generated answer-file URL; the serving endpoint
+    /// requires one (or an operator session) once an admin exists.
+    pub boot_tokens: BootTokens,
     /// Operator-controlled UI overrides (custom logo). When the
     /// operator hasn't uploaded anything, the WebUI serves the bundled
     /// rainbow-horizon mark.
     pub branding: BrandingStore,
+    /// v0.6.2: cache of the composited PXE boot-menu background PNG,
+    /// keyed on the branding logo revision. Composing costs ~50-200 ms
+    /// of image decode/encode and **every** booting client fetches it
+    /// for `console --picture` — caching makes that one compose per
+    /// logo change instead of one per boot.
+    pub pxe_bg_cache: PxeBgCache,
     /// Forms-auth admin record + first-run bootstrap state. When
     /// `admin.is_configured() == false`, the auth middleware passes
     /// every request through and `/api/me` reports `setup_required`.
@@ -67,6 +87,18 @@ pub struct AppState {
     /// In-process (no subprocess); supports HTTP Range requests on
     /// NFS-sourced ISOs because NFSv3 READ3 takes an explicit offset.
     pub nfs_shares: NfsShareManager,
+    /// v0.5.5: SFTP-over-SSH share manager — pure-Rust userspace
+    /// consumer via `russh` + `russh-sftp` (ring backend, no OpenSSL).
+    /// Ships alongside SMB/NFS as the third remote-library protocol.
+    /// In-process (no subprocess, no kernel mount); supports HTTP Range
+    /// requests because SFTP opens a seekable file handle. Authenticates
+    /// the server's SSH host key on a trust-on-first-use basis.
+    pub sftp_shares: SftpShareManager,
+    /// v0.5.2: uploaded unattended-install answer files (Kickstart /
+    /// Preseed / Autoinstall / Windows answer files). Served on demand to
+    /// booting clients with per-host hostname/IP/MAC templating; lives in
+    /// its own directory, never the ISO listing or PXE menu.
+    pub unattended: UnattendedStore,
     /// Browser chunked upload state. Multipart uploads still go straight
     /// through `IsoStore`, but the UI uses sessions so large ISO transfers
     /// can show deterministic progress and leave visible partial files.

crates/http-api/src/terminal.rs

@@ -96,6 +96,8 @@ async fn dispatch(state: &AppState, argv: &[String]) -> Result<String, String> {
         "share" | "smb-share" => smb_share_command(state, tail).await,
         "smb" => smb_command(state, tail).await,
         "nfs" => nfs_share_command(state, tail).await,
+        // v0.5.5: SFTP-over-SSH remote shares (in-process russh client).
+        "sftp" => sftp_share_command(state, tail).await,
         "log" => log_command(state, tail),
         "whoami" => Ok("operator".to_string()),
         "echo" => Ok(tail.join(" ")),
@@ -118,17 +120,21 @@ fn status_text(s: &AppState) -> String {
     // v0.4.67: NFSv3 sources too.
     let nfs_shares = s.nfs_shares.list();
     let nfs_reachable = nfs_shares.iter().filter(|m| m.reachable).count();
+    // v0.5.5: SFTP-over-SSH sources too.
+    let sftp_shares = s.sftp_shares.list();
+    let sftp_reachable = sftp_shares.iter().filter(|m| m.reachable).count();
     format!(
         "OpenPXE {ver}\n\
          base url:     {base}\n\
          interface:    {nic}\n\
          uptime:       {up}\n\
-         isos:         {n_isos}  (local: {n_local}, smb: {n_smb}, nfs: {n_nfs})\n\
+         isos:         {n_isos}  (local: {n_local}, smb: {n_smb}, nfs: {n_nfs}, sftp: {n_sftp})\n\
          clients:      {n_clients}\n\
          queue:        {n_entries}\n\
          smb server:   {smb}\n\
          smb shares:   {n_smb_total} configured ({n_smb_active} reachable)\n\
-         nfs shares:   {n_nfs_total} configured ({n_nfs_active} reachable)\n",
+         nfs shares:   {n_nfs_total} configured ({n_nfs_active} reachable)\n\
+         sftp shares:  {n_sftp_total} configured ({n_sftp_active} reachable)\n",
         ver = env!("CARGO_PKG_VERSION"),
         base = s.public_base_url,
         nic = if s.nic_name.is_empty() {
@@ -150,6 +156,10 @@ fn status_text(s: &AppState) -> String {
             .iter()
             .filter(|i| matches!(i.source, openpxe_iso_store::IsoSource::Nfs { .. }))
             .count(),
+        n_sftp = isos
+            .iter()
+            .filter(|i| matches!(i.source, openpxe_iso_store::IsoSource::Sftp { .. }))
+            .count(),
         n_clients = clients.len(),
         n_entries = queue_entries.len(),
         smb = smb.map_or_else(|| "(disabled)".into(), |s| format!("{s:?}")),
@@ -157,6 +167,8 @@ fn status_text(s: &AppState) -> String {
         n_smb_active = smb_reachable,
         n_nfs_total = nfs_shares.len(),
         n_nfs_active = nfs_reachable,
+        n_sftp_total = sftp_shares.len(),
+        n_sftp_active = sftp_reachable,
     )
 }
 
@@ -177,6 +189,8 @@ fn isos_text(s: &AppState) -> String {
             openpxe_iso_store::IsoSource::Smb { share_id, .. } => format!("smb:{share_id}"),
             // v0.4.67: NFSv3 via in-process nfs3_client.
             openpxe_iso_store::IsoSource::Nfs { share_id, .. } => format!("nfs:{share_id}"),
+            // v0.5.5: SFTP-over-SSH via in-process russh.
+            openpxe_iso_store::IsoSource::Sftp { share_id, .. } => format!("sftp:{share_id}"),
         };
         let _ = writeln!(
             out,
@@ -321,11 +335,9 @@ async fn smb_share_command(s: &AppState, args: &[String]) -> Result<String, Stri
         }
         Some("add") => {
             // share add //server/share [guest|user:password]
-            let target = args
+            let target = args.get(1).ok_or_else(|| {
-                .get(1)
+                "usage: share add //server/share [guest|user:password]".to_string()
-                .ok_or_else(|| {
+            })?;
-                    "usage: share add //server/share [guest|user:password]".to_string()
-                })?;
             // Accept either `//server/share` (UNC-style) or
             // `server:share` (shorter to type).
             let stripped = target.trim_start_matches('/').trim_start_matches('\\');
@@ -401,11 +413,7 @@ async fn nfs_share_command(s: &AppState, args: &[String]) -> Result<String, Stri
                 return Ok("(no NFS shares configured)".into());
             }
             let mut out = String::new();
-            let _ = writeln!(
+            let _ = writeln!(out, "{:<24} {:<7} {:<6} TARGET", "ID", "STATUS", "ISOS");
-                out,
-                "{:<24} {:<7} {:<6} TARGET",
-                "ID", "STATUS", "ISOS"
-            );
             for m in shares {
                 let status = if m.reachable { "ok" } else { "down" };
                 let _ = writeln!(
@@ -476,6 +484,104 @@ async fn nfs_share_command(s: &AppState, args: &[String]) -> Result<String, Stri
     }
 }
 
+// ── sftp (v0.5.5) ────────────────────────────────────────────────────────
+//
+// Parallel to nfs_share_command. The terminal `add` only supports
+// password auth — pasting a multiline PEM private key through the
+// terminal is impractical, so key-based shares are added via the WebUI.
+
+async fn sftp_share_command(s: &AppState, args: &[String]) -> Result<String, String> {
+    match args.first().map(String::as_str) {
+        None | Some("list") => {
+            let shares = s.sftp_shares.list();
+            if shares.is_empty() {
+                return Ok("(no SFTP shares configured)".into());
+            }
+            let mut out = String::new();
+            let _ = writeln!(out, "{:<24} {:<7} {:<6} TARGET", "ID", "STATUS", "ISOS");
+            for m in shares {
+                let status = if m.reachable { "ok" } else { "down" };
+                let _ = writeln!(
+                    out,
+                    "{:<24} {:<7} {:<6} {}@{}:{}",
+                    truncate(&m.id, 24),
+                    status,
+                    m.iso_count,
+                    m.username,
+                    m.server,
+                    m.export,
+                );
+                if let Some(e) = m.last_error {
+                    let _ = writeln!(out, "    error: {e}");
+                }
+                if let Some(h) = m.last_hint {
+                    let _ = writeln!(out, "    hint:  {h}");
+                }
+            }
+            Ok(out)
+        }
+        Some("add") => {
+            // sftp add <user>@<server>:<export> <password> [port]
+            let target = args.get(1).ok_or_else(|| {
+                "usage: sftp add <user>@<server>:<export> <password> [port] \
+                 (key auth: use the WebUI)"
+                    .to_string()
+            })?;
+            let password = args
+                .get(2)
+                .ok_or_else(|| "a password is required (key auth: use the WebUI)".to_string())?;
+            let (user, rest) = target
+                .split_once('@')
+                .ok_or_else(|| "target must be 'user@server:/export'".to_string())?;
+            let (server, export) = rest
+                .split_once(':')
+                .ok_or_else(|| "target must be 'user@server:/export'".to_string())?;
+            let port = args.get(3).and_then(|s| s.parse::<u16>().ok());
+            let req = openpxe_iso_store::SftpAddRequest {
+                server: server.to_string(),
+                export: export.to_string(),
+                username: Some(user.to_string()),
+                port,
+                password: Some(password.clone()),
+                private_key: None,
+                passphrase: None,
+            };
+            match s.sftp_shares.add(req).await {
+                Ok(m) => Ok(format!("added {} ({} isos)", m.id, m.iso_count)),
+                Err(e) => {
+                    let mut out = format!("add failed: {}", e.error);
+                    if let Some(h) = e.hint {
+                        out.push_str("\nhint: ");
+                        out.push_str(&h);
+                    }
+                    Err(out)
+                }
+            }
+        }
+        Some("remove") => {
+            let id = args
+                .get(1)
+                .ok_or_else(|| "usage: sftp remove <id>".to_string())?;
+            match s.sftp_shares.remove(id).await {
+                Ok(()) => Ok(format!("removed {id}")),
+                Err(e) => Err(format!("remove failed: {e}")),
+            }
+        }
+        Some("scan") => {
+            let id = args
+                .get(1)
+                .ok_or_else(|| "usage: sftp scan <id>".to_string())?;
+            match s.sftp_shares.rescan(id).await {
+                Ok(n) => Ok(format!("re-scanned {id}: {n} isos")),
+                Err(e) => Err(format!("scan failed: {e}")),
+            }
+        }
+        Some(other) => Err(format!(
+            "unknown sftp subcommand: {other}\ntry: sftp [list|add|remove|scan]"
+        )),
+    }
+}
+
 // ── smb ────────────────────────────────────────────────────────────────
 
 #[allow(clippy::unused_async)]
@@ -622,6 +728,11 @@ OpenPXE terminal — available commands:
   nfs remove <id>                   forget an NFS share
   nfs scan <id>                     re-list an NFS share for new ISOs
 
+  sftp list                         list configured SFTP-over-SSH shares
+  sftp add <user>@<srv>:<export> <pass> [port]   add an SFTP share (key auth: WebUI)
+  sftp remove <id>                  forget an SFTP share
+  sftp scan <id>                    re-list an SFTP share for new ISOs
+
   smb status                        outbound Samba state (Windows install media)
   smb start | stop | reload         control the outbound smbd
 

crates/http-api/src/uploads.rs

@@ -9,6 +9,7 @@
 use bytes::Bytes;
 use openpxe_core::{Error, Result};
 use openpxe_iso_store::{IsoMeta, IsoStore, UploadHandle};
+use parking_lot::RwLock;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -19,7 +20,11 @@ const DEFAULT_CHUNK_SIZE: u64 = 8 * 1024 * 1024;
 
 #[derive(Clone, Default)]
 pub struct UploadSessions {
-    inner: Arc<Mutex<HashMap<String, Arc<Mutex<UploadSession>>>>>,
+    // v0.5.4: the registry is a sync `parking_lot::RwLock` — it's only ever
+    // briefly read/inserted/removed to look up a session, never held across
+    // an `.await`. The per-session lock below stays a `tokio::sync::Mutex`
+    // because `write_chunk` / `finish` are awaited while it's held.
+    inner: Arc<RwLock<HashMap<String, Arc<Mutex<UploadSession>>>>>,
 }
 
 struct UploadSession {
@@ -67,8 +72,7 @@ impl UploadSessions {
         };
 
         self.inner
-            .lock()
+            .write()
-            .await
             .insert(upload_id.clone(), Arc::new(Mutex::new(session)));
 
         Ok(UploadStarted {
@@ -88,7 +92,7 @@ impl UploadSessions {
         chunk: Bytes,
         complete: bool,
     ) -> Result<UploadAppend> {
-        let Some(session_lock) = self.inner.lock().await.get(upload_id).cloned() else {
+        let Some(session_lock) = self.inner.read().get(upload_id).cloned() else {
             return Err(Error::Invalid(format!("no such upload '{upload_id}'")));
         };
 
@@ -119,7 +123,7 @@ impl UploadSessions {
         if let Err(e) = handle.write_chunk(&chunk).await {
             let handle = session.handle.take();
             drop(session);
-            self.inner.lock().await.remove(upload_id);
+            self.inner.write().remove(upload_id);
             if let Some(handle) = handle {
                 let _ = handle.abort().await;
             }
@@ -156,11 +160,11 @@ impl UploadSessions {
         let meta = match handle.finish(store).await {
             Ok(meta) => meta,
             Err(e) => {
-                self.inner.lock().await.remove(upload_id);
+                self.inner.write().remove(upload_id);
                 return Err(e);
             }
         };
-        self.inner.lock().await.remove(upload_id);
+        self.inner.write().remove(upload_id);
         Ok(UploadAppend::Complete {
             offset: new_offset,
             iso: Box::new(meta),
@@ -168,7 +172,7 @@ impl UploadSessions {
     }
 
     pub async fn abort(&self, upload_id: &str) -> Result<()> {
-        let Some(session_lock) = self.inner.lock().await.remove(upload_id) else {
+        let Some(session_lock) = self.inner.write().remove(upload_id) else {
             return Err(Error::Invalid(format!("no such upload '{upload_id}'")));
         };
         let mut session = session_lock.lock().await;

crates/http-api/tests/full_flow.rs

@@ -14,7 +14,7 @@ use axum::body::Body;
 use axum::http::{header, Request, StatusCode};
 use openpxe_core::{ClientRegistry, DeploymentQueue, HostBindings, LogBus, Metrics, SettingsStore};
 use openpxe_http_api::{build_router, AppState};
-use openpxe_iso_store::{IsoStore, NfsShareManager, SmbShareManager};
+use openpxe_iso_store::{IsoStore, NfsShareManager, SftpShareManager, SmbShareManager};
 use tempfile::tempdir;
 use tower::ServiceExt;
 
@@ -96,6 +96,9 @@ async fn build_state() -> (AppState, tempfile::TempDir) {
     let settings = SettingsStore::load_or_default(dir.path());
     let smb_shares = SmbShareManager::new(dir.path(), iso_store.clone());
     let nfs_shares = NfsShareManager::new(dir.path(), iso_store.clone());
+    let sftp_shares = SftpShareManager::new(dir.path(), iso_store.clone());
+    let unattended = openpxe_iso_store::UnattendedStore::new(dir.path().join("unattended"));
+    unattended.ensure_dir().await.unwrap();
     let log_bus = LogBus::new(64);
     let hosts = HostBindings::load_or_default(dir.path());
     let boot_log = openpxe_core::BootLog::load_or_default(dir.path());
@@ -112,7 +115,10 @@ async fn build_state() -> (AppState, tempfile::TempDir) {
         settings,
         hosts,
         boot_log,
+        boot_rules: openpxe_core::BootRulesStore::load_or_default(dir.path()),
+        boot_tokens: openpxe_core::BootTokens::new(),
         branding,
+        pxe_bg_cache: openpxe_http_api::state::PxeBgCache::default(),
         admin,
         sessions,
         sso,
@@ -122,6 +128,8 @@ async fn build_state() -> (AppState, tempfile::TempDir) {
         smb: None,
         smb_shares,
         nfs_shares,
+        sftp_shares,
+        unattended,
         uploads: openpxe_http_api::uploads::UploadSessions::default(),
         log_bus,
         started_at: time::OffsetDateTime::now_utc(),
@@ -688,7 +696,7 @@ async fn log_recent_returns_buffered_lines() {
 }
 
 #[tokio::test]
-async fn windows_iso_renders_clean_wimboot_script_with_no_trust_store_writes() {
+async fn windows_iso_renders_clean_sanboot_script_with_no_trust_store_writes() {
     // Synthesize an ISO with a Windows volume label + the sources/boot.wim
     // sentinel so introspection labels it WindowsPe with has_boot_wim.
     let mut buf = vec![0u8; 32 * 2048];
@@ -758,38 +766,35 @@ async fn windows_iso_renders_clean_wimboot_script_with_no_trust_store_writes() {
         "introspection should detect sources/boot.wim sentinel"
     );
 
-    // The boot entry should be a wimboot kind with the canonical 5-file
+    // v0.5.8: Windows boots via iPXE HTTP sanboot of the raw ISO — no SMB,
-    // chain documented in the LinusTechTips iPXE-Windows guide.
+    // no extraction, no in-ISO file serving, no operator toggle. The boot
+    // entry is a `san_boot_iso` kind pointing at the raw image.
     let entry = &meta["boot_entries"][0];
-    assert_eq!(entry["kind"]["kind"], "wimboot");
+    assert_eq!(entry["kind"]["kind"], "san_boot_iso");
-    let files = entry["kind"]["files"].as_array().unwrap();
+    let iso_url = entry["kind"]["iso_url"].as_str().unwrap();
-    let names: Vec<&str> = files.iter().map(|f| f[0].as_str().unwrap()).collect();
+    assert!(
-    assert!(names.contains(&"bootmgr"));
+        std::path::Path::new(iso_url)
-    assert!(names.contains(&"bootmgr.efi"));
+            .extension()
-    assert!(names.contains(&"bcd"));
+            .is_some_and(|e| e.eq_ignore_ascii_case("iso")),
-    assert!(names.contains(&"boot.sdi"));
+        "sanboot should target the raw ISO, got: {iso_url}"
-    assert!(names.contains(&"boot.wim"));
+    );
 
     // Render the entry script and verify:
-    //   1. It uses wimboot
+    //   1. It uses `sanboot` against the raw ISO over HTTP
-    //   2. All 5 files are referenced via `initrd --name`
+    //   2. NO trust-store / driver / testsigning operations slip in
-    //   3. NO trust-store / driver / testsigning operations slip in
     let entry_id = entry["id"].as_str().unwrap();
     let url = format!("/boot/{entry_id}.ipxe");
     let (s, body) = get(&app, &url).await;
     assert_eq!(s, StatusCode::OK);
     let script = String::from_utf8(body).unwrap();
-    assert!(script.contains("kernel "), "missing kernel line:\n{script}");
     assert!(
-        script.contains("ipxe/wimboot"),
+        script.contains("sanboot"),
-        "missing wimboot loader:\n{script}"
+        "missing sanboot line:\n{script}"
+    );
+    assert!(
+        script.contains(&format!("/{iso_url}")),
+        "sanboot should reference the raw ISO url:\n{script}"
     );
-    for tag in ["bootmgr", "bootmgr.efi", "bcd", "boot.sdi", "boot.wim"] {
-        assert!(
-            script.contains(&format!("initrd --name {tag}")),
-            "missing `initrd --name {tag}` line:\n{script}"
-        );
-    }
     // Hard guarantees we never want to see in any client-facing script.
     let lower = script.to_lowercase();
     for forbidden in [
@@ -1486,9 +1491,11 @@ async fn api_docs_lists_known_endpoints() {
     }
     for needle in [
         "/api/isos",
-        "/api/isos/:id/category",
+        // v0.6.3: docs use axum 0.8's `{param}` capture syntax.
+        "/api/isos/{id}/category",
         "/api/storage/disk",
-        "/api/branding/logo",
+        "/api/branding/logo/{slot}",
+        "/api/unattended",
         "/api/boot-log",
         "/metrics",
     ] {
@@ -1509,7 +1516,7 @@ async fn branding_clear_when_no_logo_is_no_content() {
         .oneshot(
             Request::builder()
                 .method("DELETE")
-                .uri("/api/branding/logo")
+                .uri("/api/branding/logo/dark")
                 .body(Body::empty())
                 .unwrap(),
         )
@@ -1532,6 +1539,60 @@ async fn status_exposes_custom_logo_flag() {
     );
 }
 
+/// v0.5.4 guard: the typed `StatusResponse` must keep every key the WebUI
+/// (`crates/webui/src/app.js`) reads off `/api/status`. If a refactor drops
+/// or renames one, the dashboard silently breaks — this catches it.
+#[tokio::test]
+async fn status_contract_has_all_ui_keys() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state);
+    let (s, body) = get(&app, "/api/status").await;
+    assert_eq!(s, StatusCode::OK);
+    let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
+    for key in [
+        "version",
+        "public_base_url",
+        "iso_count",
+        "client_count",
+        "queue_count",
+        "imaging_count",
+        "waiting_count",
+        "ipxe_assets",
+        "settings",
+        "smb_share_count",
+        "smb_share_reachable",
+        "nfs_share_count",
+        "nfs_share_reachable",
+        "host_bindings",
+        "custom_logo",
+        "branding",
+        "unattended_count",
+        "uptime_secs",
+        "started_at",
+        "nic_name",
+        "subnet_mask",
+        "gateway",
+    ] {
+        assert!(
+            v.get(key).is_some(),
+            "/api/status missing UI key '{key}': {v}"
+        );
+    }
+    // Nested branding presence the Settings tab reads.
+    for key in ["light", "dark", "client", "rev"] {
+        assert!(
+            v["branding"].get(key).is_some(),
+            "/api/status branding missing '{key}': {v}"
+        );
+    }
+    // started_at must remain an RFC3339 string (the UI does fmtUptime on
+    // uptime_secs but renders started_at as text), not a serialized struct.
+    assert!(
+        v["started_at"].is_string(),
+        "started_at should serialize as a string: {v}"
+    );
+}
+
 async fn put_json(router: &axum::Router, path: &str, body: &str) -> (StatusCode, Vec<u8>) {
     let res = router
         .clone()
@@ -1950,6 +2011,7 @@ async fn pxe_background_falls_back_to_default_for_svg_upload() {
     state
         .branding
         .set_logo(
+            openpxe_core::LogoSlot::Client,
             "image/svg+xml",
             "svg",
             br#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 8 8"/>"#,
@@ -1985,7 +2047,10 @@ async fn pxe_logo_composes_to_1024x768_png() {
     // the iPXE menu always paints at consistent dimensions.
     let (state, _dir) = build_state().await;
     let png = tiny_png();
-    state.branding.set_logo("image/png", "png", &png).unwrap();
+    state
+        .branding
+        .set_logo(openpxe_core::LogoSlot::Client, "image/png", "png", &png)
+        .unwrap();
     let app = build_router(state);
     let res = app
         .clone()
@@ -2025,7 +2090,10 @@ async fn pxe_logo_endpoint_is_public_after_admin_setup() {
     // auth allowlist gates `/api/*` only.
     let (state, _dir) = build_state().await;
     let png = tiny_png();
-    state.branding.set_logo("image/png", "png", &png).unwrap();
+    state
+        .branding
+        .set_logo(openpxe_core::LogoSlot::Client, "image/png", "png", &png)
+        .unwrap();
     let app = build_router(state);
     // Configure an admin so the middleware kicks in.
     let (s, _, _) = post_collect(
@@ -2040,6 +2108,201 @@ async fn pxe_logo_endpoint_is_public_after_admin_setup() {
     assert_eq!(s, StatusCode::OK);
 }
 
+// ─── v0.5.2: unattended files + deployment profiles ─────────────────────────
+
+async fn post_multipart(
+    router: &axum::Router,
+    path: &str,
+    ct: &str,
+    body: Vec<u8>,
+) -> (StatusCode, Vec<u8>) {
+    let res = router
+        .clone()
+        .oneshot(
+            Request::builder()
+                .method("POST")
+                .uri(path)
+                .header("content-type", ct)
+                .body(Body::from(body))
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    let status = res.status();
+    let body = axum::body::to_bytes(res.into_body(), usize::MAX)
+        .await
+        .unwrap()
+        .to_vec();
+    (status, body)
+}
+
+#[tokio::test]
+async fn unattended_upload_list_serve_and_template() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state);
+    let ks = b"install\nnetwork --hostname={{HOSTNAME}} --ip={{IP}}\n%packages\n@core\n%end\n";
+    let (ct, body) = multipart_iso_body("rocky.ks", ks);
+    let (s, b) = post_multipart(&app, "/api/unattended", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED, "{}", String::from_utf8_lossy(&b));
+    let m: serde_json::Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(m["kind"], "kickstart");
+    let id = m["id"].as_str().unwrap().to_string();
+
+    let (s, b) = get(&app, "/api/unattended").await;
+    assert_eq!(s, StatusCode::OK);
+    let v: serde_json::Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(v["files"].as_array().unwrap().len(), 1);
+
+    // Public serve substitutes the query tokens.
+    let (s, b) = get(
+        &app,
+        &format!("/unattended/{id}?hostname=node7&ip=10.0.0.7"),
+    )
+    .await;
+    assert_eq!(s, StatusCode::OK);
+    let text = String::from_utf8_lossy(&b);
+    assert!(text.contains("--hostname=node7"), "got: {text}");
+    assert!(text.contains("--ip=10.0.0.7"), "got: {text}");
+    assert!(!text.contains("{{"), "tokens left unrendered: {text}");
+
+    // Delete.
+    let res = app
+        .clone()
+        .oneshot(
+            Request::builder()
+                .method("DELETE")
+                .uri(format!("/api/unattended/{id}"))
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(res.status(), StatusCode::NO_CONTENT);
+    let (_, b) = get(&app, "/api/unattended").await;
+    let v: serde_json::Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(v["files"].as_array().unwrap().len(), 0);
+}
+
+#[tokio::test]
+async fn unattended_upload_rejects_bad_type() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state);
+    let (ct, body) = multipart_iso_body("evil.sh", b"#!/bin/sh\n");
+    let (s, _) = post_multipart(&app, "/api/unattended", &ct, body).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+}
+
+#[tokio::test]
+async fn host_pin_with_unattended_injects_kickstart_arg() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state.clone());
+    // Upload a Linux ISO → synthesises the `fake-alpine-linux` LinuxKernel entry.
+    let (ct, body) = multipart_iso_body("fake-alpine.iso", &fake_alpine_iso());
+    let (s, _) = post_multipart(&app, "/api/isos", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    // Upload a kickstart.
+    let (ct, body) = multipart_iso_body("ks.ks", b"install\n%packages\n@core\n%end\n");
+    let (s, b) = post_multipart(&app, "/api/unattended", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let ks_id = serde_json::from_slice::<serde_json::Value>(&b).unwrap()["id"]
+        .as_str()
+        .unwrap()
+        .to_string();
+    // Pin a MAC to the Linux entry with the unattended profile.
+    let mac = "aa:bb:cc:dd:ee:01";
+    let pin = format!(
+        r#"{{"mac":"{mac}","target":"fake-alpine-linux","label":"lab","auto_hostname":"node7","auto_ip":"10.0.0.7","unattended_file":"{ks_id}"}}"#
+    );
+    let (s, b) = post_json(&app, "/api/hosts", &pin).await;
+    assert_eq!(s, StatusCode::CREATED, "{}", String::from_utf8_lossy(&b));
+    // Boot the entry as that MAC; the kernel line should carry inst.ks=.
+    let (s, b) = get(&app, &format!("/boot/fake-alpine-linux.ipxe?mac={mac}")).await;
+    assert_eq!(s, StatusCode::OK);
+    let script = String::from_utf8_lossy(&b);
+    assert!(
+        script.contains("inst.ks="),
+        "no kickstart arg injected:\n{script}"
+    );
+    assert!(
+        script.contains("hostname=node7"),
+        "hostname not passed:\n{script}"
+    );
+}
+
+#[tokio::test]
+async fn host_pin_rejects_unknown_unattended_file() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state.clone());
+    let (ct, body) = multipart_iso_body("fake-alpine.iso", &fake_alpine_iso());
+    let (s, _) = post_multipart(&app, "/api/isos", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let pin = r#"{"mac":"aa:bb:cc:dd:ee:02","target":"fake-alpine-linux","unattended_file":"does-not-exist"}"#;
+    let (s, _) = post_json(&app, "/api/hosts", pin).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+}
+
+#[tokio::test]
+async fn host_pin_rejects_bad_auto_ip() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state.clone());
+    let (ct, body) = multipart_iso_body("fake-alpine.iso", &fake_alpine_iso());
+    let (s, _) = post_multipart(&app, "/api/isos", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let pin = r#"{"mac":"aa:bb:cc:dd:ee:03","target":"fake-alpine-linux","auto_ip":"not-an-ip"}"#;
+    let (s, _) = post_json(&app, "/api/hosts", pin).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+}
+
+#[tokio::test]
+async fn per_theme_logo_and_favicon_serve() {
+    let (state, _dir) = build_state().await;
+    // Light slot only; dark falls back to it, favicon stays bundled.
+    let png = tiny_png();
+    state
+        .branding
+        .set_logo(openpxe_core::LogoSlot::Light, "image/png", "png", &png)
+        .unwrap();
+    let app = build_router(state);
+    // Light theme → the uploaded PNG.
+    let (s, b) = get(&app, "/assets/logo.svg?theme=light").await;
+    assert_eq!(s, StatusCode::OK);
+    assert!(b.starts_with(b"\x89PNG"), "light slot should serve the PNG");
+    // Dark theme → falls back to the light PNG (only slot set).
+    let (s, b) = get(&app, "/assets/logo.svg?theme=dark").await;
+    assert_eq!(s, StatusCode::OK);
+    assert!(
+        b.starts_with(b"\x89PNG"),
+        "dark should fall back to light PNG"
+    );
+    // Favicon is always the bundled SVG, never the custom raster.
+    let (s, b) = get(&app, "/assets/favicon.svg").await;
+    assert_eq!(s, StatusCode::OK);
+    let txt = String::from_utf8_lossy(&b);
+    assert!(txt.contains("<svg"), "favicon must be the bundled SVG mark");
+}
+
+#[tokio::test]
+async fn branding_slot_rejects_unknown_and_client_svg() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state);
+    // Unknown slot name → 400.
+    let (ct, body) = multipart_iso_body("logo.png", &tiny_png());
+    let (s, _) = post_multipart(&app, "/api/branding/logo/sideways", &ct, body).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+    // SVG into the client (PXE) slot → 400 (raster-only).
+    let svg = br#"<svg xmlns="http://www.w3.org/2000/svg"/>"#;
+    let boundary = "----OpenPxeTestBoundary1234";
+    let mut b = Vec::new();
+    b.extend_from_slice(format!("--{boundary}\r\n").as_bytes());
+    b.extend_from_slice(b"Content-Disposition: form-data; name=\"file\"; filename=\"l.svg\"\r\n");
+    b.extend_from_slice(b"Content-Type: image/svg+xml\r\n\r\n");
+    b.extend_from_slice(svg);
+    b.extend_from_slice(format!("\r\n--{boundary}--\r\n").as_bytes());
+    let ct = format!("multipart/form-data; boundary={boundary}");
+    let (s, _) = post_multipart(&app, "/api/branding/logo/client", &ct, b).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+}
+
 // ─── v0.5.1: SAML SSO flow ──────────────────────────────────────────────────
 //
 // The core crate exhaustively tests signature verification + semantic
@@ -2145,8 +2408,16 @@ fn urlencode(s: &str) -> String {
             }
             _ => {
                 out.push('%');
-                out.push(char::from_digit((b >> 4) as u32, 16).unwrap().to_ascii_uppercase());
+                out.push(
-                out.push(char::from_digit((b & 0xf) as u32, 16).unwrap().to_ascii_uppercase());
+                    char::from_digit((b >> 4) as u32, 16)
+                        .unwrap()
+                        .to_ascii_uppercase(),
+                );
+                out.push(
+                    char::from_digit((b & 0xf) as u32, 16)
+                        .unwrap()
+                        .to_ascii_uppercase(),
+                );
             }
         }
     }
@@ -2341,3 +2612,162 @@ async fn acs_garbage_is_rejected_without_500() {
     assert!(location(&resp).contains("sso_error"));
     assert!(!has_session_cookie(&resp));
 }
+
+// ─── v0.7.0: tokenized answer files + boot rules ────────────────────────────
+
+#[tokio::test]
+async fn unattended_requires_token_once_admin_exists() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state.clone());
+    // Upload an answer file while in setup mode (everything open).
+    let (ct, body) =
+        multipart_iso_body("ks.ks", b"install\nrootpw s3cret\n%packages\n@core\n%end\n");
+    let (s, b) = post_multipart(&app, "/api/unattended", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let id = serde_json::from_slice::<serde_json::Value>(&b).unwrap()["id"]
+        .as_str()
+        .unwrap()
+        .to_string();
+    // Pre-setup, the file serves openly (bootstrap parity with the
+    // auth middleware).
+    let (s, _) = get(&app, &format!("/unattended/{id}")).await;
+    assert_eq!(s, StatusCode::OK);
+
+    // Create the admin → the gate arms.
+    let (s, _, cookies) = post_collect(
+        &app,
+        "/api/setup",
+        r#"{"username":"admin","password":"hunter2hunter2"}"#,
+    )
+    .await;
+    assert_eq!(s, StatusCode::CREATED);
+    let session = session_value(&cookies).unwrap();
+
+    // Bare fetch (the CVE-2026-0386 harvesting pattern) is refused.
+    let (s, _) = get(&app, &format!("/unattended/{id}")).await;
+    assert_eq!(s, StatusCode::UNAUTHORIZED);
+    // Garbage token is refused.
+    let (s, _) = get(&app, &format!("/unattended/{id}?t=bogus")).await;
+    assert_eq!(s, StatusCode::UNAUTHORIZED);
+    // A token minted for a *different* file is refused.
+    let other = state.boot_tokens.mint("some-other-file");
+    let (s, _) = get(&app, &format!("/unattended/{id}?t={other}")).await;
+    assert_eq!(s, StatusCode::UNAUTHORIZED);
+    // The boot-scoped token OpenPXE mints into generated URLs passes.
+    let tok = state.boot_tokens.mint(&id);
+    let (s, b) = get(&app, &format!("/unattended/{id}?t={tok}")).await;
+    assert_eq!(s, StatusCode::OK);
+    assert!(String::from_utf8_lossy(&b).contains("rootpw"));
+    // A logged-in operator (browser testing) passes too.
+    let (s, _) = get_with_cookie(&app, &format!("/unattended/{id}"), &session).await;
+    assert_eq!(s, StatusCode::OK);
+}
+
+#[tokio::test]
+async fn boot_script_for_pinned_unattended_carries_live_token() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state.clone());
+    let (ct, body) = multipart_iso_body("fake-alpine.iso", &fake_alpine_iso());
+    let (s, _) = post_multipart(&app, "/api/isos", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let (ct, body) = multipart_iso_body("ks.ks", b"install\n%packages\n@core\n%end\n");
+    let (s, b) = post_multipart(&app, "/api/unattended", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let ks_id = serde_json::from_slice::<serde_json::Value>(&b).unwrap()["id"]
+        .as_str()
+        .unwrap()
+        .to_string();
+    let mac = "aa:bb:cc:dd:ee:71";
+    let pin =
+        format!(r#"{{"mac":"{mac}","target":"fake-alpine-linux","unattended_file":"{ks_id}"}}"#);
+    let (s, _) = post_json(&app, "/api/hosts", &pin).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let (s, b) = get(&app, &format!("/boot/fake-alpine-linux.ipxe?mac={mac}")).await;
+    assert_eq!(s, StatusCode::OK);
+    let script = String::from_utf8_lossy(&b).into_owned();
+    // The injected inst.ks URL ends with a token that is live for the file.
+    let tok = script
+        .split("t=")
+        .nth(1)
+        .and_then(|rest| rest.split_whitespace().next())
+        .expect("kernel arg should carry t=<token>");
+    assert!(
+        state.boot_tokens.check(tok, &ks_id),
+        "token in boot script must be live:\n{script}"
+    );
+}
+
+#[tokio::test]
+async fn boot_rules_match_and_persist_via_api() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state);
+    let (ct, body) = multipart_iso_body("fake-alpine.iso", &fake_alpine_iso());
+    let (s, _) = post_multipart(&app, "/api/isos", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+
+    // Save a rule: any MAC under aa:bb:cc, any arch → the Linux entry.
+    let cfg = r#"{"rules":[{"mac_prefix":"AA-BB-CC","arch":"","target":"fake-alpine-linux","enabled":true,"note":"rack"}],"webhook_url":""}"#;
+    let (s, _) = put_json(&app, "/api/boot-rules", cfg).await;
+    assert_eq!(s, StatusCode::NO_CONTENT);
+    // The config reads back (prefix normalized to colons).
+    let (s, b) = get(&app, "/api/boot-rules").await;
+    assert_eq!(s, StatusCode::OK);
+    let v: serde_json::Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(v["rules"][0]["mac_prefix"], "aa:bb:cc");
+
+    // A matching client short-circuits to the target...
+    let (s, b) = get(&app, "/boot.ipxe?mac=aa:bb:cc:00:00:09&arch=uefi-x64").await;
+    assert_eq!(s, StatusCode::OK);
+    let script = String::from_utf8_lossy(&b);
+    assert!(
+        script.contains("boot rule -> fake-alpine-linux"),
+        "rule did not chain:\n{script}"
+    );
+    // ...while a non-matching one still gets the menu.
+    let (s, b) = get(&app, "/boot.ipxe?mac=11:22:33:00:00:09&arch=uefi-x64").await;
+    assert_eq!(s, StatusCode::OK);
+    assert!(
+        String::from_utf8_lossy(&b).contains("menu"),
+        "non-matching client should see the menu"
+    );
+}
+
+#[tokio::test]
+async fn arch_selective_rule_ignores_other_arches() {
+    let (state, _dir) = build_state().await;
+    let app = build_router(state);
+    let (ct, body) = multipart_iso_body("fake-alpine.iso", &fake_alpine_iso());
+    let (s, _) = post_multipart(&app, "/api/isos", &ct, body).await;
+    assert_eq!(s, StatusCode::CREATED);
+    let cfg = r#"{"rules":[{"mac_prefix":"","arch":"uefi-arm64","target":"fake-alpine-linux","enabled":true,"note":""}],"webhook_url":""}"#;
+    let (s, _) = put_json(&app, "/api/boot-rules", cfg).await;
+    assert_eq!(s, StatusCode::NO_CONTENT);
+    // x64 client: no match → menu.
+    let (s, b) = get(&app, "/boot.ipxe?mac=aa:bb:cc:00:00:01&arch=uefi-x64").await;
+    assert_eq!(s, StatusCode::OK);
+    assert!(!String::from_utf8_lossy(&b).contains("boot rule ->"));
+    // arm64 client: match.
+    let (s, b) = get(&app, "/boot.ipxe?mac=aa:bb:cc:00:00:01&arch=uefi-arm64").await;
+    assert_eq!(s, StatusCode::OK);
+    assert!(String::from_utf8_lossy(&b).contains("boot rule -> fake-alpine-linux"));
+}
+
+#[tokio::test]
+async fn boot_rule_driver_mode_pin_round_trips_via_api() {
+    // v0.7.1: a rule may pin only a boot binary (no target) — the API
+    // must persist and return it for the DHCP proxy to consult.
+    let (state, _dir) = build_state().await;
+    let app = build_router(state.clone());
+    let cfg = r#"{"rules":[{"mac_prefix":"aa:bb:cc","arch":"","target":"","driver_mode":"shim","enabled":true,"note":"SB rack"}],"webhook_url":""}"#;
+    let (s, _) = put_json(&app, "/api/boot-rules", cfg).await;
+    assert_eq!(s, StatusCode::NO_CONTENT);
+    let (s, b) = get(&app, "/api/boot-rules").await;
+    assert_eq!(s, StatusCode::OK);
+    let v: serde_json::Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(v["rules"][0]["driver_mode"], "shim");
+    // And the store the DHCP proxy shares resolves the pin.
+    assert_eq!(
+        state.boot_rules.driver_mode_hint("aa:bb:cc:00:00:07", None),
+        Some(openpxe_core::DriverMode::Shim)
+    );
+}

crates/ipxe-assets/src/lib.rs

@@ -6,43 +6,40 @@
 //! missing, that architecture simply won't have PXE support — we log at
 //! startup and serve what we have.
 //!
-//! Filename convention (matches `ClientArch::ipxe_bootfile`):
+//! Filename convention (matches `ClientArch::ipxe_bootfile_mode`):
+//!
+//! DriverMode::Firmware (default — reuse the firmware UNDI/SNP NIC stack):
 //!   - `undionly.kpxe`       — Legacy x86 BIOS
 //!   - `snponly-i386.efi`    — IA32 UEFI
 //!   - `snponly.efi`         — x86_64 UEFI
-//!   - `snponly-arm32.efi`   — ARM32 UEFI
 //!   - `snponly-arm64.efi`   — ARM64 UEFI
-//!   - `ipxe.efi` (fallback) — UEFI with bundled drivers, if snponly fails on a NIC
+//!
+//! DriverMode::Builtin (v0.6.1 automatic fallback — iPXE's own NIC drivers,
+//! advertised when a firmware-net boot fails to chainload):
+//!   - `ipxe.pxe`            — Legacy x86 BIOS
+//!   - `ipxe-i386.efi`       — IA32 UEFI
+//!   - `ipxe.efi`            — x86_64 UEFI (built from source with PNG)
+//!   - `ipxe-arm64.efi`      — ARM64 UEFI
+//!
 //!   - `wimboot`             — Windows boot shim (fetched separately for WIM chains)
 #![forbid(unsafe_code)]
 
-use openpxe_core::ClientArch;
+use openpxe_core::{ClientArch, DriverMode};
 use rust_embed::Embed;
 
 #[derive(Embed)]
 #[folder = "../../assets/ipxe/"]
 #[include = "*.kpxe"]
 #[include = "*.efi"]
+#[include = "*.pxe"]
 #[include = "wimboot"]
 pub struct IpxeAssets;
 
-/// Return the embedded iPXE binary for `arch`, or `None` if we didn't bundle
+/// Return a named embedded asset (e.g. `snponly.efi`, `wimboot`) as a
-/// one for that architecture.
+/// `Cow` over the embedded bytes. In release builds the data is borrowed
-#[must_use]
+/// straight from the binary's rodata — **zero copy** — which matters
-pub fn bootfile_bytes(arch: ClientArch) -> Option<Vec<u8>> {
+/// because the TFTP and HTTP serving paths hit this for every boot
-    let name = arch.ipxe_bootfile()?;
+/// (`ipxe.efi` is ~1 MiB). Debug builds read from disk and return Owned.
-    IpxeAssets::get(name).map(|f| f.data.into_owned())
-}
-
-/// Return a named asset directly (e.g. `wimboot`, or a fallback `ipxe.efi`).
-#[must_use]
-pub fn asset_bytes(name: &str) -> Option<Vec<u8>> {
-    IpxeAssets::get(name).map(|f| f.data.into_owned())
-}
-
-/// Same as [`asset_bytes`] but returns the embedded slice directly,
-/// avoiding the heap copy when the caller only needs to read the
-/// payload. Falls back to None for unknown names.
 #[must_use]
 pub fn asset_slice(name: &str) -> Option<std::borrow::Cow<'static, [u8]>> {
     IpxeAssets::get(name).map(|f| f.data)
@@ -56,25 +53,48 @@ pub fn list_assets() -> Vec<String> {
         .collect()
 }
 
-/// Log at startup which iPXE binaries are present and which are missing.
+/// Log at startup which iPXE binaries are present and which are missing, for
+/// both driver modes. The Firmware-mode binaries are required for PXE on each
+/// arch; the Builtin-mode binaries are the optional automatic NIC-driver
+/// fallback (v0.6.1) — without one, escalation simply can't help that arch.
 pub fn log_availability() {
     let have: std::collections::HashSet<String> = list_assets().into_iter().collect();
-    let needed = [
+    let arches = [
-        (ClientArch::LegacyX86, "undionly.kpxe"),
+        ClientArch::LegacyX86,
-        (ClientArch::Ia32Uefi, "snponly-i386.efi"),
+        ClientArch::Ia32Uefi,
-        (ClientArch::X64Uefi, "snponly.efi"),
+        ClientArch::X64Uefi,
-        // ARM32 UEFI deferred — no upstream snponly binary published.
+        // ARM32 UEFI deferred — no upstream binary published in either mode.
-        (ClientArch::Arm64Uefi, "snponly-arm64.efi"),
+        ClientArch::Arm64Uefi,
     ];
-    for (arch, name) in needed {
+    for arch in arches {
-        if have.contains(name) {
+        for mode in [DriverMode::Firmware, DriverMode::Builtin, DriverMode::Shim] {
-            tracing::info!(target: "openpxe::ipxe", "bundled iPXE for {}: {}", arch.as_str(), name);
+            let Some(name) = arch.ipxe_bootfile_mode(mode) else {
-        } else {
+                continue;
-            tracing::warn!(
+            };
-                target: "openpxe::ipxe",
+            if have.contains(name) {
-                "MISSING iPXE binary for {}: {} — clients of this arch will not PXE boot",
+                tracing::info!(
-                arch.as_str(), name
+                    target: "openpxe::ipxe",
-            );
+                    "bundled iPXE for {} [{mode:?}]: {name}", arch.as_str()
+                );
+            } else if mode == DriverMode::Firmware {
+                tracing::warn!(
+                    target: "openpxe::ipxe",
+                    "MISSING iPXE binary for {} [{mode:?}]: {name} — clients of this arch will not PXE boot",
+                    arch.as_str()
+                );
+            } else if mode == DriverMode::Builtin {
+                tracing::info!(
+                    target: "openpxe::ipxe",
+                    "no built-in-driver fallback for {} [{mode:?}]: {name} — auto NIC driver escalation unavailable for this arch",
+                    arch.as_str()
+                );
+            } else {
+                tracing::info!(
+                    target: "openpxe::ipxe",
+                    "no signed shim chain for {} [{mode:?}]: {name} — Secure Boot clients of this arch can't be served",
+                    arch.as_str()
+                );
+            }
         }
     }
 }

crates/iso-store/Cargo.toml

@@ -39,6 +39,10 @@ image = { version = "0.25", default-features = false, features = ["png", "jpeg",
 # kernel mount. See crates/iso-store/src/nfs_share.rs for usage.
 nfs3_client = { workspace = true }
 nfs3_types = { workspace = true }
+# v0.5.5: pure-Rust SSH/SFTP client (ring backend) for the SFTP remote
+# share path. See crates/iso-store/src/sftp_share.rs for usage.
+russh = { workspace = true }
+russh-sftp = { workspace = true }
 # Needed for the Stream trait that wraps the mpsc receiver feeding
 # NFS read-loop bytes into axum's Body::from_stream.
 futures = { workspace = true }

crates/iso-store/src/entry.rs

@@ -25,9 +25,11 @@ pub enum BootKind {
         wimboot_url: String,
         files: Vec<(String, String)>,
     },
-    /// Last-resort: SAN-boot the ISO as an emulated CD. Only works for small
+    /// SAN-boot the raw ISO as an emulated CD (iPXE `sanboot`). The emulated
-    /// ISOs (<~1 GiB) and older distros. Kept for completeness, not the
+    /// CD is backed by on-demand HTTP range reads, so ISO size is *not* a
-    /// default.
+    /// constraint — this is the primary path for Windows (v0.5.8) and for any
+    /// El Torito-bootable image we don't special-case: ESXi/VMvisor
+    /// installers, BSDs, firmware/diagnostic tools, custom spins (v0.6.0).
     SanBootIso { iso_url: String },
 }
 

crates/iso-store/src/introspect.rs

@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
 use std::io::{Read, Seek, SeekFrom};
 use std::path::Path;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "snake_case")]
 pub enum DistroFamily {
     DebianUbuntu,
@@ -22,10 +22,22 @@ pub enum DistroFamily {
     Arch,
     Alpine,
     WindowsPe,
+    #[default]
     Unknown,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Bumped whenever the introspection logic changes in a way that should
+/// re-classify already-uploaded ISOs. On startup the store re-runs
+/// `introspect` on any *local* ISO whose persisted report predates this
+/// revision (see `IsoStore::load_from_disk`), so an upgrade fixes stale
+/// metadata — e.g. a Windows 11 ISO tagged `Unknown` by an older binary —
+/// without the operator having to delete and re-upload it.
+///
+/// rev 1 (v0.5.9): added El Torito boot-catalog detection + broadened
+/// Windows (UDF/UTF-16) detection becomes retroactive.
+pub const INTROSPECT_REV: u32 = 1;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct IntrospectionReport {
     pub family: DistroFamily,
     pub volume_label: Option<String>,
@@ -35,17 +47,28 @@ pub struct IntrospectionReport {
     pub initrd_paths: Vec<String>,
     /// True if `sources/boot.wim` present — Windows install media.
     pub has_boot_wim: bool,
+    /// True if the ISO carries an El Torito boot catalog — i.e. it is
+    /// bootable by BIOS/UEFI firmware and therefore by iPXE `sanboot`
+    /// (emulated CD). This is the authoritative "can this boot at all?"
+    /// signal for ISOs we can't classify as Linux or Windows (BSDs, ESXi,
+    /// firmware tools, custom spins). A *data* ISO (e.g. a VMware vCenter
+    /// appliance bundle) has no boot catalog and reports `false`. v0.5.9.
+    #[serde(default)]
+    pub el_torito: bool,
+    /// Revision of the introspection logic that produced this report. Old
+    /// `meta.json` files without the field deserialize as 0, which is
+    /// below [`INTROSPECT_REV`], triggering a one-time re-introspect on
+    /// the next startup. v0.5.9.
+    #[serde(default)]
+    pub introspect_rev: u32,
 }
 
 /// Probe an ISO file on disk. Never fails — on unrecoverable IO error we log
 /// and return an `Unknown` family so the uploader still sees a record.
 pub fn introspect(path: &Path) -> IntrospectionReport {
     let mut report = IntrospectionReport {
-        family: DistroFamily::Unknown,
+        introspect_rev: INTROSPECT_REV,
-        volume_label: None,
+        ..Default::default()
-        kernel_path: None,
-        initrd_paths: Vec::new(),
-        has_boot_wim: false,
     };
 
     let Ok(mut f) = std::fs::File::open(path) else {
@@ -68,6 +91,11 @@ pub fn introspect(path: &Path) -> IntrospectionReport {
         }
     }
 
+    // Does the ISO have an El Torito boot catalog? This is what decides
+    // whether an ISO we *can't* otherwise classify is bootable at all —
+    // a bootable ISO sanboots; a data/appliance ISO (no catalog) can't.
+    report.el_torito = detect_el_torito(&mut f);
+
     // Cheap content scan: read the first ~64 MiB, look for signature filenames.
     // This is enough to identify `sources/boot.wim` (Windows) and common
     // kernel/initrd paths for the major Linux distros.
@@ -75,7 +103,13 @@ pub fn introspect(path: &Path) -> IntrospectionReport {
     let scan_bytes = 64 * 1024 * 1024;
     let mut buf = vec![0u8; 1024 * 1024];
     let mut read_total = 0usize;
-    let mut haystack = Vec::with_capacity(scan_bytes.min(32 * 1024 * 1024));
+    // Size the haystack to what will actually be read — the scan cap or
+    // the file itself, whichever is smaller — so the fill never reallocs
+    // and a small ISO doesn't reserve the full 64 MiB.
+    let file_len = f.metadata().map_or(usize::MAX, |m| {
+        usize::try_from(m.len()).unwrap_or(usize::MAX)
+    });
+    let mut haystack = Vec::with_capacity(scan_bytes.min(file_len));
     while read_total < scan_bytes {
         let n = f.read(&mut buf).unwrap_or(0);
         if n == 0 {
@@ -85,12 +119,37 @@ pub fn introspect(path: &Path) -> IntrospectionReport {
         read_total += n;
     }
 
+    // `sources/boot.wim` is the definitive Windows-install-media marker
+    // when the ISO exposes ASCII (ISO9660/Joliet) names. `contains_ascii`
+    // is case-insensitive, so one form covers BOOT.WIM / boot.wim and the
+    // backslash variant.
     if contains_ascii(&haystack, b"sources/boot.wim")
-        || contains_ascii(&haystack, b"SOURCES/BOOT.WIM")
+        || contains_ascii(&haystack, b"sources\\boot.wim")
-        || contains_ascii(&haystack, b"SOURCES\\BOOT.WIM")
     {
         report.has_boot_wim = true;
-        if report.family == DistroFamily::Unknown {
+        report.family = DistroFamily::WindowsPe;
+    }
+
+    // v0.5.8: broaden Windows detection. Modern Windows 10/11 ISOs are
+    // UDF — filenames are stored as UTF-16 (so the ASCII scan above misses
+    // them) and the volume label is a cryptic Microsoft string (so
+    // `family_from_label` misses it too). Booting is via HTTP sanboot of
+    // the raw ISO (no boot.wim extraction), so we only need the *family*.
+    // Catch the common cases: well-known Windows markers in either ASCII
+    // or UTF-16LE within the first 16 MiB, plus a filename hint.
+    if report.family == DistroFamily::Unknown {
+        let head = &haystack[..haystack.len().min(16 * 1024 * 1024)];
+        let ascii_markers: [&[u8]; 4] = [
+            b"bootmgr",
+            b"sources/install.wim",
+            b"sources/install.esd",
+            b"efi/microsoft",
+        ];
+        let utf16_markers = ["bootmgr", "boot.wim", "install.wim", "microsoft"];
+        let looks_windows = ascii_markers.iter().any(|m| contains_ascii(head, m))
+            || utf16_markers.iter().any(|m| contains_utf16le_ci(head, m))
+            || filename_looks_windows(path);
+        if looks_windows {
             report.family = DistroFamily::WindowsPe;
         }
     }
@@ -158,6 +217,83 @@ fn contains_ascii(haystack: &[u8], needle: &[u8]) -> bool {
         .any(|w| w.eq_ignore_ascii_case(needle))
 }
 
+/// Case-insensitive search for an ASCII string encoded as UTF-16LE — the
+/// way UDF (and thus modern Windows ISOs) store filenames. Each character
+/// is two bytes: the ASCII low byte (compared case-insensitively) followed
+/// by a 0 high byte. v0.5.8.
+fn contains_utf16le_ci(haystack: &[u8], ascii: &str) -> bool {
+    let n = ascii.len();
+    if n == 0 || haystack.len() < n * 2 {
+        return false;
+    }
+    let lower: Vec<u8> = ascii.bytes().map(|b| b.to_ascii_lowercase()).collect();
+    haystack.windows(n * 2).any(|w| {
+        lower
+            .iter()
+            .enumerate()
+            .all(|(i, &c)| w[i * 2 + 1] == 0 && w[i * 2].to_ascii_lowercase() == c)
+    })
+}
+
+/// Filename heuristic: a stock Windows ISO almost always carries an obvious
+/// token in its name (e.g. `..._windows_11_...`, `Win10`, `winserver`).
+/// Used only as a last-resort family hint when the content scan and volume
+/// label are inconclusive. v0.5.8.
+fn filename_looks_windows(path: &Path) -> bool {
+    let name = path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_ascii_lowercase();
+    const TOKENS: [&str; 6] = [
+        "windows",
+        "winpe",
+        "win10",
+        "win11",
+        "winserver",
+        "win-server",
+    ];
+    TOKENS.iter().any(|t| name.contains(t))
+}
+
+/// The boot-system identifier string in an El Torito Boot Record Volume
+/// Descriptor (offset 7, NUL-padded to 32 bytes).
+const EL_TORITO_ID: &[u8] = b"EL TORITO SPECIFICATION";
+
+/// Detect an El Torito boot catalog — the marker that an ISO is bootable
+/// by BIOS/UEFI firmware (and thus by iPXE `sanboot`).
+///
+/// The ISO9660 Volume Descriptor Set starts at LBA 16 (offset 0x8000) and
+/// runs one 2048-byte descriptor per sector until a Set Terminator
+/// (type 0xFF). A Boot Record descriptor (type 0x00) whose 32-byte boot
+/// system identifier reads "EL TORITO SPECIFICATION" means the image
+/// declares an El Torito boot catalog. We only confirm its presence — we
+/// don't parse the catalog (sanboot/the firmware does that). The walk is
+/// capped so a malformed/huge image can't spin us. v0.5.9.
+fn detect_el_torito(f: &mut std::fs::File) -> bool {
+    let mut vd = [0u8; 2048];
+    for lba in 16u64..32 {
+        if f.seek(SeekFrom::Start(lba * 2048)).is_err() || f.read_exact(&mut vd).is_err() {
+            return false;
+        }
+        // Every descriptor in the set carries the "CD001" magic; once it's
+        // missing we've walked off the end of a valid set.
+        if &vd[1..6] != b"CD001" {
+            return false;
+        }
+        match vd[0] {
+            // Boot Record descriptor carrying the El Torito signature.
+            0x00 if vd[7..7 + EL_TORITO_ID.len()] == *EL_TORITO_ID => return true,
+            // Volume Descriptor Set Terminator — nothing bootable found.
+            0xFF => return false,
+            // Any other descriptor (incl. a non-El-Torito boot record) —
+            // keep walking the set.
+            _ => {}
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -179,4 +315,72 @@ mod tests {
         assert_eq!(family_from_label("ARCH_202604"), DistroFamily::Arch);
         assert_eq!(family_from_label("weird-custom"), DistroFamily::Unknown);
     }
+
+    #[test]
+    fn utf16le_marker_matches_case_insensitively() {
+        // "boot.wim" encoded UTF-16LE, mixed case — UDF stores Windows
+        // filenames this way, which the ASCII scan can't see.
+        let s = "BOOT.WIM";
+        let utf16: Vec<u8> = s.bytes().flat_map(|b| [b, 0]).collect();
+        let mut hay = vec![0u8; 8];
+        hay.extend_from_slice(&utf16);
+        hay.extend_from_slice(&[1, 2, 3]);
+        assert!(contains_utf16le_ci(&hay, "boot.wim"));
+        assert!(contains_utf16le_ci(&hay, "Boot.Wim"));
+        assert!(!contains_utf16le_ci(&hay, "install.wim"));
+        // An ASCII (not UTF-16) occurrence must NOT match the UTF-16 scan.
+        assert!(!contains_utf16le_ci(b"boot.wim plain ascii", "boot.wim"));
+    }
+
+    #[test]
+    fn el_torito_boot_catalog_detected() {
+        let dir = tempfile::tempdir().unwrap();
+        // Helper: stamp a 2048-byte descriptor at `lba` with type + magic.
+        let stamp = |img: &mut [u8], lba: usize, ty: u8| {
+            let off = lba * 2048;
+            img[off] = ty;
+            img[off + 1..off + 6].copy_from_slice(b"CD001");
+        };
+
+        // Bootable image: PVD @16, El Torito Boot Record @17, terminator @18.
+        let mut boot = vec![0u8; 2048 * 19];
+        stamp(&mut boot, 16, 0x01);
+        stamp(&mut boot, 17, 0x00);
+        boot[17 * 2048 + 7..17 * 2048 + 7 + EL_TORITO_ID.len()].copy_from_slice(EL_TORITO_ID);
+        stamp(&mut boot, 18, 0xFF);
+        let bp = dir.path().join("boot.iso");
+        std::fs::write(&bp, &boot).unwrap();
+        let mut f = std::fs::File::open(&bp).unwrap();
+        assert!(
+            detect_el_torito(&mut f),
+            "El Torito boot record should match"
+        );
+
+        // Data/appliance image: PVD @16, terminator @17, no boot record.
+        let mut data = vec![0u8; 2048 * 18];
+        stamp(&mut data, 16, 0x01);
+        stamp(&mut data, 17, 0xFF);
+        let dp = dir.path().join("data.iso");
+        std::fs::write(&dp, &data).unwrap();
+        let mut f2 = std::fs::File::open(&dp).unwrap();
+        assert!(!detect_el_torito(&mut f2), "data ISO has no boot catalog");
+    }
+
+    #[test]
+    fn filename_hint_catches_windows_isos() {
+        use std::path::Path;
+        assert!(filename_looks_windows(Path::new(
+            "en-us_windows_11_iot_enterprise_ltsc_2024_x64_dvd.iso"
+        )));
+        assert!(filename_looks_windows(Path::new(
+            "Win10_22H2_English_x64.iso"
+        )));
+        assert!(filename_looks_windows(Path::new("winserver2022.iso")));
+        assert!(!filename_looks_windows(Path::new(
+            "ubuntu-24.04-desktop.iso"
+        )));
+        assert!(!filename_looks_windows(Path::new(
+            "Rocky-9.4-x86_64-dvd.iso"
+        )));
+    }
 }

crates/iso-store/src/lib.rs

@@ -20,9 +20,11 @@ pub mod entry;
 pub mod introspect;
 pub mod nfs_share;
 pub mod pxe_logo;
+pub mod sftp_share;
 pub mod smb;
 pub mod smb_share;
 pub mod store;
+pub mod unattended;
 pub mod windows;
 
 pub use entry::{BootEntry, BootKind, KernelArgs};
@@ -39,8 +41,18 @@ pub use smb_share::{SmbAddRequest, SmbShare, SmbShareError, SmbShareManager, Smb
 // "works in any container" property as SMB, plus support for HTTP
 // Range requests because NFSv3 READ3 takes an explicit offset.
 pub use nfs_share::{NfsAddRequest, NfsShare, NfsShareError, NfsShareManager, NfsStream};
+// v0.5.5: SFTP-over-SSH remote shares via the pure-Rust `russh` +
+// `russh-sftp` crates (ring backend — no OpenSSL, no new C deps). Like
+// NFS, supports HTTP Range requests because SFTP opens a seekable file
+// handle. See crates/iso-store/src/sftp_share.rs.
+pub use sftp_share::{
+    SftpAddRequest, SftpAuthKind, SftpShare, SftpShareError, SftpShareManager, SftpStream,
+};
 pub use store::{
-    generate_boot_entries_for, slugify_str, IsoCategory, IsoMeta, IsoSource, IsoStore,
+    generate_boot_entries_for, slugify_str, IsoCategory, IsoMeta, IsoSource, IsoStore, UploadHandle,
-    UploadHandle,
+};
+pub use unattended::{
+    classify as classify_unattended, render_template, UnattendedKind, UnattendedMeta,
+    UnattendedStore, MAX_UNATTENDED_BYTES,
 };
 pub use windows::{WimPatcher, WinPatchState};

crates/iso-store/src/nfs_share.rs

@@ -57,14 +57,14 @@
 //! UI to ask for. (If a future server needs Kerberos or non-default
 //! uid mapping we can add those, but for ISO read access nobody does.)
 
-use crate::introspect::{DistroFamily, IntrospectionReport};
+use crate::introspect::IntrospectionReport;
 use crate::store::{generate_boot_entries_for, slugify_str, IsoSource, IsoStore};
 use bytes::Bytes;
 use nfs3_client::tokio::TokioConnector;
 use nfs3_client::Nfs3ConnectionBuilder;
 use nfs3_types::nfs3::{
-    self as nfs3, diropargs3, entry3, filename3, nfs_fh3, GETATTR3args, LOOKUP3args,
+    self as nfs3, diropargs3, entry3, filename3, nfs_fh3, GETATTR3args, LOOKUP3args, Nfs3Result,
-    Nfs3Result, READ3args, READDIR3args,
+    READ3args, READDIR3args,
 };
 use nfs3_types::rpc::{auth_unix, opaque_auth};
 use nfs3_types::xdr_codec::Opaque;
@@ -220,10 +220,7 @@ impl NfsShareManager {
     /// Register an NFS share. Validates, probes connectivity by
     /// performing a real MOUNT3 + READDIR3, and registers the
     /// resulting ISOs with the store.
-    pub async fn add(
+    pub async fn add(&self, req: NfsAddRequest) -> std::result::Result<NfsShare, NfsShareError> {
-        &self,
-        req: NfsAddRequest,
-    ) -> std::result::Result<NfsShare, NfsShareError> {
         let server = normalize_server(&req.server);
         let export = req.export.trim().to_string();
         if server.is_empty() {
@@ -258,7 +255,9 @@ impl NfsShareManager {
         if let Err(e) = self.rescan_inner(&id).await {
             let m = self.get(&id);
             return Err(NfsShareError {
-                error: m.as_ref().and_then(|m| m.last_error.clone())
+                error: m
+                    .as_ref()
+                    .and_then(|m| m.last_error.clone())
                     .unwrap_or_else(|| e.to_string()),
                 stderr: String::new(),
                 hint: m.and_then(|m| m.last_hint),
@@ -333,8 +332,7 @@ impl NfsShareManager {
             return Err(Error::Invalid(format!("invalid filename '{filename}'")));
         }
 
-        let (tx, rx) =
+        let (tx, rx) = tokio::sync::mpsc::channel::<std::io::Result<Bytes>>(STREAM_BUFFER_DEPTH);
-            tokio::sync::mpsc::channel::<std::io::Result<Bytes>>(STREAM_BUFFER_DEPTH);
         let server = share.server.clone();
         let export = share.export.clone();
         let port = share.port;
@@ -358,16 +356,11 @@ impl NfsShareManager {
             if let Err(e) = result {
                 // Best-effort signal of the error to the consumer.
                 // If the receiver has already dropped we just exit.
-                let _ = tx
+                let _ = tx.send(Err(std::io::Error::other(e.to_string()))).await;
-                    .send(Err(std::io::Error::other(e.to_string())))
-                    .await;
             }
         });
 
-        Ok(NfsStream {
+        Ok(NfsStream { rx, _task: task })
-            rx,
-            _task: task,
-        })
     }
 
     // ── internals ─────────────────────────────────────────────────────
@@ -399,13 +392,7 @@ impl NfsShareManager {
             // Same approach as SMB: no real introspection over the
             // network in v0.4.67. The boot-entry generator falls back
             // to filename-based sanboot detection.
-            let report = IntrospectionReport {
+            let report = IntrospectionReport::default();
-                family: DistroFamily::Unknown,
-                volume_label: None,
-                kernel_path: None,
-                initrd_paths: Vec::new(),
-                has_boot_wim: false,
-            };
             let boot_entries = generate_boot_entries_for(&iso_id, &entry.filename, &report);
             let source = IsoSource::Nfs {
                 share_id: share.id.clone(),
@@ -988,8 +975,14 @@ mod tests {
         // the allow-list and the secure/insecure angle.
         let h = hint_for("connect failed: MNT3ERR_ACCES").unwrap();
         let lc = h.to_lowercase();
-        assert!(lc.contains("insecure") || lc.contains("privileged"), "got: {h}");
+        assert!(
-        assert!(lc.contains("allow") || lc.contains("permission"), "got: {h}");
+            lc.contains("insecure") || lc.contains("privileged"),
+            "got: {h}"
+        );
+        assert!(
+            lc.contains("allow") || lc.contains("permission"),
+            "got: {h}"
+        );
     }
 
     #[test]

crates/iso-store/src/smb_share.rs

@@ -56,7 +56,7 @@
 //! streaming. A follow-up release can add libsmbclient-based seek if
 //! a real workload needs it.
 
-use crate::introspect::{DistroFamily, IntrospectionReport};
+use crate::introspect::IntrospectionReport;
 use crate::store::{generate_boot_entries_for, slugify_str, IsoSource, IsoStore};
 use openpxe_core::{Error, Result};
 use parking_lot::Mutex;
@@ -231,10 +231,7 @@ impl SmbShareManager {
 
     /// Add or refresh a share. Validates the input, writes a creds
     /// file, probes connectivity, and scans for ISOs.
-    pub async fn add(
+    pub async fn add(&self, req: SmbAddRequest) -> std::result::Result<SmbShare, SmbShareError> {
-        &self,
-        req: SmbAddRequest,
-    ) -> std::result::Result<SmbShare, SmbShareError> {
         let server = normalize_server(&req.server);
         let share = req.share.trim().trim_start_matches('/').to_string();
         if server.is_empty() {
@@ -309,7 +306,9 @@ impl SmbShareManager {
         if let Err(e) = self.rescan_inner(&id).await {
             let m = self.get(&id);
             return Err(SmbShareError {
-                error: m.as_ref().and_then(|m| m.last_error.clone())
+                error: m
+                    .as_ref()
+                    .and_then(|m| m.last_error.clone())
                     .unwrap_or_else(|| e.to_string()),
                 stderr: String::new(),
                 hint: m.and_then(|m| m.last_hint),
@@ -365,11 +364,7 @@ impl SmbShareManager {
     /// throttling concurrent smbclients) would need to await without
     /// changing the call sites.
     #[allow(clippy::unused_async)]
-    pub async fn stream_iso(
+    pub async fn stream_iso(&self, share_id: &str, filename: &str) -> Result<SmbStream> {
-        &self,
-        share_id: &str,
-        filename: &str,
-    ) -> Result<SmbStream> {
         let share = self
             .get(share_id)
             .ok_or_else(|| Error::Invalid(format!("no such SMB share '{share_id}'")))?;
@@ -377,9 +372,7 @@ impl SmbShareManager {
         // share root. smbclient itself accepts only filenames at the
         // share root in our `get` form, but belt-and-suspenders.
         if filename.contains('/') || filename.contains('\\') || filename.contains("..") {
-            return Err(Error::Invalid(format!(
+            return Err(Error::Invalid(format!("invalid filename '{filename}'")));
-                "invalid filename '{filename}'"
-            )));
         }
         let creds = share
             .creds_path
@@ -470,13 +463,7 @@ impl SmbShareManager {
             // and the operator gets *something* bootable. A follow-up
             // release can do a bounded `smbclient get` of the first
             // 64 KiB for real detection.
-            let report = IntrospectionReport {
+            let report = IntrospectionReport::default();
-                family: DistroFamily::Unknown,
-                volume_label: None,
-                kernel_path: None,
-                initrd_paths: Vec::new(),
-                has_boot_wim: false,
-            };
             let boot_entries = generate_boot_entries_for(&iso_id, &entry.filename, &report);
             let source = IsoSource::Smb {
                 share_id: share.id.clone(),
@@ -543,10 +530,7 @@ impl SmbShareManager {
                 } else {
                     String::new()
                 };
-                return Err((
+                return Err((format!("could not exec smbclient: {e}"), stderr));
-                    format!("could not exec smbclient: {e}"),
-                    stderr,
-                ));
             }
         };
         if !output.status.success() {
@@ -757,10 +741,7 @@ fn parse_ls_iso(out: &str) -> Vec<SmbListEntry> {
 
 /// Pre-flight TCP probe to `server:port`. Format matches v0.4.64 NFS
 /// probe so the UI banner reads consistently.
-async fn tcp_probe(
+async fn tcp_probe(server: &str, port: u16) -> std::result::Result<(), (String, String)> {
-    server: &str,
-    port: u16,
-) -> std::result::Result<(), (String, String)> {
     use tokio::net::TcpStream;
     let addr = format!("{server}:{port}");
     match tokio::time::timeout(PROBE_TIMEOUT, TcpStream::connect(&addr)).await {
@@ -937,8 +918,8 @@ mod tests {
         // exec error in `error` plus an empty `stderr`. The
         // SmbShareError constructor's hint_for fallback checks error
         // too, so this pattern needs to translate as well.
-        let h2 = hint_for("could not exec smbclient: No such file or directory (os error 2)")
+        let h2 =
-            .unwrap();
+            hint_for("could not exec smbclient: No such file or directory (os error 2)").unwrap();
         assert!(h2.contains("smbclient"));
     }
 

crates/iso-store/src/store.rs

@@ -24,6 +24,10 @@ use tokio::io::AsyncWriteExt;
 /// `nfs3_client` crate (in-process, no subprocess). Same "works in
 /// any container" property as SMB, plus Range requests work because
 /// NFSv3 READ3 takes an explicit offset.
+/// `Sftp` (v0.5.5) — remote SFTP-over-SSH share, streamed via the
+/// pure-Rust `russh` + `russh-sftp` crates (in-process). Like NFS it
+/// supports HTTP Range requests because SFTP opens a seekable file
+/// handle (`SSH_FXP_READ` at offset).
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum IsoSource {
@@ -42,6 +46,13 @@ pub enum IsoSource {
         /// Filename at the export root.
         relative_path: String,
     },
+    /// v0.5.5: SFTP-over-SSH via the in-process `russh` + `russh-sftp`
+    /// crates.
+    Sftp {
+        share_id: String,
+        /// Filename at the export root.
+        relative_path: String,
+    },
 }
 
 /// Where the ISO lands in the PXE menu hierarchy.
@@ -212,7 +223,8 @@ impl IsoStore {
                 continue;
             }
             if let Ok(text) = tokio::fs::read_to_string(&p).await {
-                if let Ok(meta) = serde_json::from_str::<IsoMeta>(&text) {
+                if let Ok(mut meta) = serde_json::from_str::<IsoMeta>(&text) {
+                    self.reintrospect_if_stale(&mut meta).await;
                     self.insert(meta);
                 }
             }
@@ -220,6 +232,46 @@ impl IsoStore {
         Ok(())
     }
 
+    /// v0.5.9: re-run introspection on a *local* ISO whose persisted report
+    /// predates the current logic. ISOs uploaded by an older binary carry a
+    /// stale family/boot profile — most visibly a Windows 11 ISO tagged
+    /// `Unknown` before the UDF/El-Torito detection landed, which then shows
+    /// as "won't boot" forever. Re-probing on startup fixes them in place,
+    /// no delete-and-re-upload. Bounded: only `Local` sources (we have the
+    /// bytes locally) below [`introspect::INTROSPECT_REV`], so it runs at
+    /// most once per ISO per upgrade. The probe reads up to ~64 MiB, so we
+    /// push it onto the blocking pool to keep the async runtime responsive.
+    async fn reintrospect_if_stale(&self, meta: &mut IsoMeta) {
+        if !matches!(meta.source, IsoSource::Local)
+            || meta.introspection.introspect_rev >= crate::introspect::INTROSPECT_REV
+        {
+            return;
+        }
+        let path = self.iso_path(&meta.id);
+        if !path.exists() {
+            return;
+        }
+        let Ok(fresh) = tokio::task::spawn_blocking(move || introspect(&path)).await else {
+            tracing::warn!(target: "openpxe::iso", id = %meta.id, "re-introspect task failed");
+            return;
+        };
+        let before = meta.introspection.family;
+        meta.introspection = fresh;
+        meta.boot_entries = generate_boot_entries(&meta.id, &meta.filename, &meta.introspection);
+        if let Err(e) = self.persist_meta(meta).await {
+            tracing::warn!(target: "openpxe::iso", id = %meta.id, "re-introspect persist: {e}");
+            return;
+        }
+        tracing::info!(
+            target: "openpxe::iso",
+            id = %meta.id,
+            from = ?before,
+            to = ?meta.introspection.family,
+            el_torito = meta.introspection.el_torito,
+            "re-introspected stale ISO metadata"
+        );
+    }
+
     fn insert(&self, meta: IsoMeta) {
         self.inner.write().isos.insert(meta.id.clone(), meta);
     }
@@ -290,20 +342,29 @@ impl IsoStore {
     /// SMB sources or when the file is missing.
     pub fn iso_path_for(&self, id: &str) -> Option<PathBuf> {
         let meta = self.get(id)?;
+        self.local_path(&meta)
+    }
+
+    /// Same resolution as [`Self::iso_path_for`], but for a meta the
+    /// caller already holds — skips the second registry lock + deep
+    /// clone, which matters on the per-range-request ISO serving path
+    /// (a sanboot install issues hundreds of those).
+    #[must_use]
+    pub fn local_path(&self, meta: &IsoMeta) -> Option<PathBuf> {
         match &meta.source {
             IsoSource::Local => {
-                let path = self.iso_path(id);
+                let path = self.iso_path(&meta.id);
                 if path.exists() {
                     Some(path)
                 } else {
                     None
                 }
             }
-            // SMB and NFS sources have no local path — they're
+            // SMB, NFS, and SFTP sources have no local path — they're
             // streamed in-process. Callers must inspect the source
             // kind first and dispatch to the appropriate share
             // manager.
-            IsoSource::Smb { .. } | IsoSource::Nfs { .. } => None,
+            IsoSource::Smb { .. } | IsoSource::Nfs { .. } | IsoSource::Sftp { .. } => None,
         }
     }
 
@@ -363,9 +424,9 @@ impl IsoStore {
     pub fn drop_external_source(&self, share_id: &str) {
         let mut g = self.inner.write();
         g.isos.retain(|_, m| match &m.source {
-            IsoSource::Smb { share_id: sid, .. } | IsoSource::Nfs { share_id: sid, .. } => {
+            IsoSource::Smb { share_id: sid, .. }
-                sid != share_id
+            | IsoSource::Nfs { share_id: sid, .. }
-            }
+            | IsoSource::Sftp { share_id: sid, .. } => sid != share_id,
             IsoSource::Local => true,
         });
     }
@@ -546,22 +607,22 @@ fn generate_boot_entries(id: &str, filename: &str, r: &IntrospectionReport) -> V
         .clone()
         .unwrap_or_else(|| filename.to_string());
     match r.family {
-        DistroFamily::WindowsPe if r.has_boot_wim => {
+        DistroFamily::WindowsPe => {
-            // Standard wimboot chain. Paths are in-ISO; the HTTP layer maps
+            // v0.5.8: boot Windows directly via iPXE HTTP sanboot. iPXE
-            // `iso/<id>/<path>` to on-disk extraction via ISO9660 lookup.
+            // exposes the raw ISO as an emulated CD backed by on-demand
-            let base = format!("iso/{id}");
+            // HTTP range reads, and Windows Setup boots from it. This
+            // replaces the old wimboot+SMB chain, which (a) needed an SMB
+            // server the host often can't provide (port 445 collisions),
+            // (b) served in-ISO files via an ISO9660 lookup that failed on
+            // UDF-only Windows 11 ISOs, and (c) required an operator
+            // toggle. sanboot needs none of that — just the HTTP port,
+            // which works in any environment. The unmodified, stock ISO is
+            // served at iso/<id>.iso; nothing is injected into Windows.
             vec![BootEntry {
-                id: format!("{id}-winpe"),
+                id: format!("{id}-windows"),
-                title: format!("{title} (Windows / wimboot)"),
+                title: format!("{title} (Windows)"),
-                kind: BootKind::Wimboot {
+                kind: BootKind::SanBootIso {
-                    wimboot_url: "ipxe/wimboot".to_string(),
+                    iso_url: format!("iso/{id}.iso"),
-                    files: vec![
-                        ("bootmgr".into(), format!("{base}/bootmgr")),
-                        ("bootmgr.efi".into(), format!("{base}/bootmgr.efi")),
-                        ("bcd".into(), format!("{base}/boot/bcd")),
-                        ("boot.sdi".into(), format!("{base}/boot/boot.sdi")),
-                        ("boot.wim".into(), format!("{base}/sources/boot.wim")),
-                    ],
                 },
             }]
         }
@@ -587,15 +648,33 @@ fn generate_boot_entries(id: &str, filename: &str, r: &IntrospectionReport) -> V
             }]
         }
         _ => {
-            // Last-resort SAN boot. Won't work for large modern ISOs, but
+            // No Windows-install media and no Linux kernel/initrd. Decide
-            // lets the ISO at least appear in the menu.
+            // whether the ISO is bootable at all (v0.6.0):
-            vec![BootEntry {
+            //   * `el_torito` — it carries a boot catalog, so iPXE sanboots
-                id: format!("{id}-sanboot"),
+            //     the raw image as an emulated CD: BSDs, ESXi/VMvisor
-                title: format!("{title} (SAN boot — may fail for >1GiB ISOs)"),
+            //     installers, firmware tools, custom spins. The emulated CD
-                kind: BootKind::SanBootIso {
+            //     is backed by HTTP range reads, so ISO size is a non-issue
-                    iso_url: format!("iso/{id}.iso"),
+            //     (this is the same path Windows uses since v0.5.8) — hence
-                },
+            //     no more "may fail for >1GiB ISOs" disclaimer.
-            }]
+            //   * `introspect_rev == 0` — a remote-share ISO we couldn't
+            //     introspect (SMB/NFS/SFTP listings don't seek into the ISO).
+            //     Offer sanboot optimistically rather than hide a
+            //     likely-bootable installer.
+            // Otherwise it's a local image we *did* introspect and found to
+            // carry no boot catalog — a data/appliance ISO (e.g. a VMware
+            // vCenter Server Appliance bundle). It genuinely cannot boot, so
+            // we expose no menu entry; the dashboard flags it instead.
+            if r.el_torito || r.introspect_rev == 0 {
+                vec![BootEntry {
+                    id: format!("{id}-sanboot"),
+                    title,
+                    kind: BootKind::SanBootIso {
+                        iso_url: format!("iso/{id}.iso"),
+                    },
+                }]
+            } else {
+                Vec::new()
+            }
         }
     }
 }
@@ -659,13 +738,59 @@ mod tests {
         // good.
         let s = linux_cmdline(DistroFamily::DebianUbuntu, "ubuntu-24-04");
         assert!(s.contains("boot=casper"), "{s}");
-        assert!(s.contains("iso-url=${base-url}/iso/ubuntu-24-04.iso"), "{s}");
+        assert!(
+            s.contains("iso-url=${base-url}/iso/ubuntu-24-04.iso"),
+            "{s}"
+        );
         assert!(s.contains("ds=nocloud"), "{s}");
         assert!(s.contains("ip=dhcp"), "{s}");
         assert!(!s.contains("netboot=url"), "legacy option leaked: {s}");
         assert!(!s.contains(" --- "), "stray ---: {s}");
     }
 
+    #[test]
+    fn boot_entries_respect_el_torito_and_source() {
+        use crate::introspect::INTROSPECT_REV;
+
+        // ESXi / VMvisor installer shape: bootable (carries an El Torito
+        // catalog) but not classifiable as Windows or Linux. Must yield a
+        // single sanboot entry so it's selectable + boots via emulated CD.
+        let esxi = IntrospectionReport {
+            family: DistroFamily::Unknown,
+            volume_label: Some("ESXI-7.0U3".into()),
+            el_torito: true,
+            introspect_rev: INTROSPECT_REV,
+            ..Default::default()
+        };
+        let e = generate_boot_entries("esxi", "VMware-VMvisor-Installer-7.0U3n.iso", &esxi);
+        assert_eq!(e.len(), 1, "ESXi should get exactly one boot entry");
+        assert!(matches!(e[0].kind, BootKind::SanBootIso { .. }));
+        // Clean title — no stale ">1GiB may fail" disclaimer.
+        assert!(!e[0].title.contains("may fail"), "title: {}", e[0].title);
+
+        // VCSA / data-appliance shape: locally introspected (rev set), no
+        // boot catalog, not Windows/Linux. Genuinely unbootable → no entry,
+        // so it stays out of the iPXE menu (the dashboard flags it instead).
+        let vcsa = IntrospectionReport {
+            family: DistroFamily::Unknown,
+            el_torito: false,
+            introspect_rev: INTROSPECT_REV,
+            ..Default::default()
+        };
+        assert!(
+            generate_boot_entries("vcsa", "VMware-VCSA-all-8.0.iso", &vcsa).is_empty(),
+            "data/appliance ISO must produce no boot entry"
+        );
+
+        // Remote-share ISO: never introspected (rev 0, no random access over
+        // SMB/NFS/SFTP). Assume bootable and offer sanboot rather than hide a
+        // likely-bootable installer.
+        let remote = IntrospectionReport::default();
+        let r = generate_boot_entries("remote", "unknown-remote.iso", &remote);
+        assert_eq!(r.len(), 1, "remote (uninspected) ISO keeps a sanboot entry");
+        assert!(matches!(r[0].kind, BootKind::SanBootIso { .. }));
+    }
+
     fn fake_meta(id: &str) -> IsoMeta {
         IsoMeta {
             id: id.into(),
@@ -673,13 +798,7 @@ mod tests {
             size_bytes: 0,
             sha256_hex: None,
             uploaded_at: OffsetDateTime::now_utc(),
-            introspection: IntrospectionReport {
+            introspection: IntrospectionReport::default(),
-                family: DistroFamily::Unknown,
-                volume_label: None,
-                kernel_path: None,
-                initrd_paths: vec![],
-                has_boot_wim: false,
-            },
             boot_entries: vec![],
             source: IsoSource::Local,
             password_hash: None,

crates/iso-store/src/unattended.rs

@@ -0,0 +1,412 @@
+//! Unattended-install answer-file store (v0.5.2).
+//!
+//! Operators upload the answer file their installer expects — a RHEL/
+//! Fedora **Kickstart**, a Debian **Preseed**, an Ubuntu **Autoinstall**
+//! cloud-init user-data, or a Windows **answer file** (`autounattend.xml`)
+//! — and OpenPXE serves it on demand to the booting machine. Files live
+//! in their own directory (`<unattended_dir>/`), deliberately *not* under
+//! `iso_dir`, so they never appear in the ISO listing or the PXE menu.
+//!
+//! Storage mirrors [`crate::store::IsoStore`]: in-memory map authoritative
+//! for the process, sidecar `*.meta.json` on disk is the source of truth on
+//! restart. The raw answer file sits beside it as `<id>.file`.
+//!
+//! Templating is applied at *serve* time, not store time — see
+//! [`render_template`]. The stored bytes are exactly what the operator
+//! uploaded; per-host hostname/IP/MAC values are substituted into a copy
+//! when the file is fetched for a specific client.
+
+use crate::store::slugify_str;
+use openpxe_core::{Error, Result};
+use parking_lot::RwLock;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use time::OffsetDateTime;
+
+/// Disk + memory cap for one answer file. Kickstarts/preseeds/cloud-init
+/// configs are a few KB; 1 MiB is a comfortable ceiling that still bounds
+/// abuse.
+pub const MAX_UNATTENDED_BYTES: usize = 1024 * 1024;
+
+/// Which installer the answer file targets. Drives the kernel-argument
+/// injection in the boot chain.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum UnattendedKind {
+    /// RHEL / Fedora / CentOS / AlmaLinux / Rocky — `inst.ks=<url>`.
+    Kickstart,
+    /// Debian / older Ubuntu — `auto=true priority=critical url=<url>`.
+    Preseed,
+    /// Ubuntu 20.04+ Subiquity autoinstall — cloud-init NoCloud:
+    /// `autoinstall ds=nocloud-net;s=<url>/`.
+    Autoinstall,
+    /// Windows Setup answer file (`autounattend.xml`). Served, not
+    /// auto-injected (Windows reads it from media/USB, not a kernel arg).
+    AnswerFile,
+    /// Couldn't classify — stored + served, no auto-injection.
+    #[default]
+    Unknown,
+}
+
+impl UnattendedKind {
+    #[must_use]
+    pub fn label(self) -> &'static str {
+        match self {
+            UnattendedKind::Kickstart => "Kickstart",
+            UnattendedKind::Preseed => "Preseed",
+            UnattendedKind::Autoinstall => "Autoinstall",
+            UnattendedKind::AnswerFile => "Answer file",
+            UnattendedKind::Unknown => "Unknown",
+        }
+    }
+}
+
+/// Lowercase file extension (no dot), or `None` if there isn't one.
+fn ext_lower(filename: &str) -> Option<String> {
+    std::path::Path::new(filename)
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(str::to_ascii_lowercase)
+}
+
+/// Classify an upload from its filename + a peek at its content. Best
+/// effort: extension first, then a content sniff to disambiguate the
+/// `.cfg` case (both Kickstart and Preseed use it).
+#[must_use]
+pub fn classify(filename: &str, content: &[u8]) -> UnattendedKind {
+    let lower_name = filename.to_ascii_lowercase();
+    let ext = ext_lower(filename);
+    let text = String::from_utf8_lossy(&content[..content.len().min(8192)]);
+    let looks_preseed = text.contains("d-i ") || text.contains("preseed/");
+    let looks_kickstart = text.contains("%packages")
+        || text.contains("\nlang ")
+        || text.contains("\nkeyboard ")
+        || text.contains("bootloader --")
+        || text.starts_with("install");
+    let looks_cloud_init = text.contains("autoinstall")
+        || text.contains("#cloud-config")
+        || text.contains("version: 1");
+
+    match ext.as_deref() {
+        Some("ks") => return UnattendedKind::Kickstart,
+        Some("seed") => return UnattendedKind::Preseed,
+        Some("xml") => return UnattendedKind::AnswerFile,
+        Some("yaml" | "yml") => return UnattendedKind::Autoinstall,
+        Some("cfg") => {
+            return if looks_kickstart && !looks_preseed {
+                UnattendedKind::Kickstart
+            } else {
+                UnattendedKind::Preseed
+            };
+        }
+        _ => {}
+    }
+    if lower_name == "user-data" {
+        return UnattendedKind::Autoinstall;
+    }
+    // No recognised extension — fall back to content sniffing.
+    if looks_cloud_init {
+        UnattendedKind::Autoinstall
+    } else if looks_kickstart {
+        UnattendedKind::Kickstart
+    } else if looks_preseed {
+        UnattendedKind::Preseed
+    } else {
+        UnattendedKind::Unknown
+    }
+}
+
+/// True if the filename carries an extension we accept for upload. We
+/// also accept the bare `user-data` name (cloud-init NoCloud convention).
+#[must_use]
+pub fn is_accepted_filename(filename: &str) -> bool {
+    if filename.trim().eq_ignore_ascii_case("user-data") {
+        return true;
+    }
+    matches!(
+        ext_lower(filename).as_deref(),
+        Some("ks" | "cfg" | "seed" | "yaml" | "yml" | "xml")
+    )
+}
+
+/// Sidecar metadata for a stored answer file.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UnattendedMeta {
+    /// URL-safe slug, unique within the store.
+    pub id: String,
+    /// Original upload filename, shown in the UI.
+    pub filename: String,
+    pub kind: UnattendedKind,
+    pub size_bytes: u64,
+    #[serde(with = "time::serde::rfc3339")]
+    pub uploaded_at: OffsetDateTime,
+}
+
+#[derive(Debug, Default)]
+struct Inner {
+    files: HashMap<String, UnattendedMeta>,
+}
+
+/// In-memory + on-disk answer-file registry. Cheap to clone.
+#[derive(Debug, Clone)]
+pub struct UnattendedStore {
+    dir: Arc<PathBuf>,
+    inner: Arc<RwLock<Inner>>,
+}
+
+impl UnattendedStore {
+    #[must_use]
+    pub fn new(dir: PathBuf) -> Self {
+        Self {
+            dir: Arc::new(dir),
+            inner: Arc::new(RwLock::new(Inner::default())),
+        }
+    }
+
+    pub async fn ensure_dir(&self) -> Result<()> {
+        tokio::fs::create_dir_all(self.dir.as_path()).await?;
+        Ok(())
+    }
+
+    /// Scan the directory on startup, loading every `*.meta.json` sidecar.
+    pub async fn load_from_disk(&self) -> Result<()> {
+        self.ensure_dir().await?;
+        let mut entries = tokio::fs::read_dir(self.dir.as_path()).await?;
+        while let Some(e) = entries.next_entry().await? {
+            let p = e.path();
+            let is_meta = p
+                .file_name()
+                .and_then(|s| s.to_str())
+                .is_some_and(|n| n.ends_with(".meta.json"));
+            if !is_meta {
+                continue;
+            }
+            if let Ok(text) = tokio::fs::read_to_string(&p).await {
+                if let Ok(meta) = serde_json::from_str::<UnattendedMeta>(&text) {
+                    self.inner.write().files.insert(meta.id.clone(), meta);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn data_path(&self, id: &str) -> PathBuf {
+        self.dir.join(format!("{id}.file"))
+    }
+
+    fn meta_path(&self, id: &str) -> PathBuf {
+        self.dir.join(format!("{id}.meta.json"))
+    }
+
+    /// Mint a unique slug from the upload filename's stem.
+    fn unique_id(&self, filename: &str) -> String {
+        let stem = filename.rsplit_once('.').map_or(filename, |(s, _)| s);
+        let base = {
+            let s = slugify_str(stem);
+            if s.is_empty() {
+                "unattended".to_string()
+            } else {
+                s
+            }
+        };
+        let g = self.inner.read();
+        if !g.files.contains_key(&base) {
+            return base;
+        }
+        for n in 1.. {
+            let candidate = format!("{base}-{n}");
+            if !g.files.contains_key(&candidate) {
+                return candidate;
+            }
+        }
+        unreachable!("u64 ids exhausted")
+    }
+
+    /// Store an uploaded answer file. Validates type + size, classifies,
+    /// writes the bytes + a sidecar, and returns the new metadata.
+    pub async fn add(&self, filename: &str, bytes: &[u8]) -> Result<UnattendedMeta> {
+        if !is_accepted_filename(filename) {
+            return Err(Error::Invalid(format!(
+                "unsupported answer-file type '{filename}'. Accepted: .ks, .cfg, .seed, .yaml, .yml, .xml, user-data"
+            )));
+        }
+        if bytes.len() > MAX_UNATTENDED_BYTES {
+            return Err(Error::Invalid(format!(
+                "answer file too large ({} bytes, max {MAX_UNATTENDED_BYTES})",
+                bytes.len()
+            )));
+        }
+        self.ensure_dir().await?;
+        let kind = classify(filename, bytes);
+        let id = self.unique_id(filename);
+        let meta = UnattendedMeta {
+            id: id.clone(),
+            filename: filename.to_string(),
+            kind,
+            size_bytes: bytes.len() as u64,
+            uploaded_at: OffsetDateTime::now_utc(),
+        };
+        // Atomic data write: tmp -> rename.
+        let data = self.data_path(&id);
+        let tmp = data.with_extension("file.tmp");
+        tokio::fs::write(&tmp, bytes).await?;
+        tokio::fs::rename(&tmp, &data).await?;
+        let meta_text = serde_json::to_string_pretty(&meta).map_err(|e| Error::Other(e.into()))?;
+        tokio::fs::write(self.meta_path(&id), meta_text).await?;
+        self.inner.write().files.insert(id.clone(), meta.clone());
+        tracing::info!(
+            target: "openpxe::unattended",
+            id = %id, file = %filename, kind = ?kind, size = bytes.len(),
+            "unattended answer file stored"
+        );
+        Ok(meta)
+    }
+
+    #[must_use]
+    pub fn list(&self) -> Vec<UnattendedMeta> {
+        let g = self.inner.read();
+        let mut v: Vec<_> = g.files.values().cloned().collect();
+        v.sort_by_key(|m| std::cmp::Reverse(m.uploaded_at));
+        v
+    }
+
+    #[must_use]
+    pub fn get(&self, id: &str) -> Option<UnattendedMeta> {
+        self.inner.read().files.get(id).cloned()
+    }
+
+    /// Read the raw stored bytes for `id`.
+    pub async fn read(&self, id: &str) -> Result<Vec<u8>> {
+        if !self.inner.read().files.contains_key(id) {
+            return Err(Error::NotFound(format!("no unattended file '{id}'")));
+        }
+        let bytes = tokio::fs::read(self.data_path(id)).await?;
+        Ok(bytes)
+    }
+
+    /// Remove a file + its sidecar. Returns true if something was removed.
+    pub async fn remove(&self, id: &str) -> bool {
+        let existed = self.inner.write().files.remove(id).is_some();
+        if existed {
+            let _ = tokio::fs::remove_file(self.data_path(id)).await;
+            let _ = tokio::fs::remove_file(self.meta_path(id)).await;
+        }
+        existed
+    }
+
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.inner.read().files.len()
+    }
+
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+/// Substitute the per-host template tokens into an answer file at serve
+/// time. Recognised tokens (case-sensitive, double-brace): `{{HOSTNAME}}`,
+/// `{{IP}}`, `{{MAC}}`. Unset values render as an empty string so a
+/// half-filled profile never leaves a literal `{{IP}}` in the file.
+#[must_use]
+pub fn render_template(
+    content: &str,
+    mac: Option<&str>,
+    hostname: Option<&str>,
+    ip: Option<&str>,
+) -> String {
+    content
+        .replace("{{HOSTNAME}}", hostname.unwrap_or(""))
+        .replace("{{IP}}", ip.unwrap_or(""))
+        .replace("{{MAC}}", mac.unwrap_or(""))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn classify_by_extension() {
+        assert_eq!(
+            classify(" subiquity.yaml", b""),
+            UnattendedKind::Autoinstall
+        );
+        assert_eq!(classify("ks.ks", b""), UnattendedKind::Kickstart);
+        assert_eq!(classify("preseed.seed", b""), UnattendedKind::Preseed);
+        assert_eq!(
+            classify("autounattend.xml", b"<xml/>"),
+            UnattendedKind::AnswerFile
+        );
+        assert_eq!(classify("user-data", b""), UnattendedKind::Autoinstall);
+    }
+
+    #[test]
+    fn classify_cfg_by_content() {
+        assert_eq!(
+            classify("answer.cfg", b"d-i debian-installer/locale string en_US"),
+            UnattendedKind::Preseed
+        );
+        assert_eq!(
+            classify("answer.cfg", b"install\n%packages\n@core\n%end\n"),
+            UnattendedKind::Kickstart
+        );
+    }
+
+    #[test]
+    fn accepted_filenames() {
+        assert!(is_accepted_filename("a.ks"));
+        assert!(is_accepted_filename("USER-DATA".to_lowercase().as_str()));
+        assert!(is_accepted_filename("autounattend.XML"));
+        assert!(!is_accepted_filename("evil.sh"));
+        assert!(!is_accepted_filename("image.iso"));
+    }
+
+    #[test]
+    fn template_substitutes_and_blanks_unset() {
+        let body = "ip={{IP}} host={{HOSTNAME}} mac={{MAC}}";
+        let out = render_template(body, Some("aa:bb"), Some("node1"), None);
+        assert_eq!(out, "ip= host=node1 mac=aa:bb");
+    }
+
+    #[tokio::test]
+    async fn add_list_read_remove_round_trip() {
+        let dir = tempdir().unwrap();
+        let s = UnattendedStore::new(dir.path().join("unattended"));
+        let meta = s
+            .add("rocky.ks", b"install\n%packages\n@core\n%end\n")
+            .await
+            .unwrap();
+        assert_eq!(meta.kind, UnattendedKind::Kickstart);
+        assert_eq!(s.len(), 1);
+        let got = s.read(&meta.id).await.unwrap();
+        assert!(got.starts_with(b"install"));
+        // Survives a reload.
+        let s2 = UnattendedStore::new(dir.path().join("unattended"));
+        s2.load_from_disk().await.unwrap();
+        assert!(s2.get(&meta.id).is_some());
+        assert!(s2.remove(&meta.id).await);
+        assert!(s2.get(&meta.id).is_none());
+    }
+
+    #[tokio::test]
+    async fn rejects_bad_type_and_oversize() {
+        let dir = tempdir().unwrap();
+        let s = UnattendedStore::new(dir.path().join("unattended"));
+        assert!(s.add("evil.sh", b"#!/bin/sh").await.is_err());
+        let big = vec![b'x'; MAX_UNATTENDED_BYTES + 1];
+        assert!(s.add("big.ks", &big).await.is_err());
+    }
+
+    #[tokio::test]
+    async fn ids_are_unique() {
+        let dir = tempdir().unwrap();
+        let s = UnattendedStore::new(dir.path().join("unattended"));
+        let a = s.add("ks.ks", b"install").await.unwrap();
+        let b = s.add("ks.ks", b"install").await.unwrap();
+        assert_ne!(a.id, b.id);
+    }
+}

crates/openpxe/src/main.rs

@@ -9,7 +9,7 @@ use openpxe_core::{
 };
 use openpxe_dhcp_proxy::DhcpProxyServer;
 use openpxe_http_api::{build_router, AppState};
-use openpxe_iso_store::{IsoStore, NfsShareManager, SmbManager, SmbShareManager};
+use openpxe_iso_store::{IsoStore, NfsShareManager, SftpShareManager, SmbManager, SmbShareManager};
 use openpxe_tftp::TftpServer;
 use std::net::{Ipv4Addr, SocketAddr};
 use std::path::PathBuf;
@@ -59,11 +59,10 @@ async fn main() -> anyhow::Result<()> {
     init_tracing(log_bus.clone());
 
     let cli = Cli::parse();
-    let mut config = match &cli.config {
+    // v0.5.4: layered load via figment — defaults → optional TOML → env.
-        Some(p) if p.exists() => Config::from_toml_file(p)?,
+    // The OPENPXE_* env layer keeps the historical flat names (see
-        _ => Config::default(),
+    // `Config::load`), so existing deployments are unaffected.
-    };
+    let config = Config::load(cli.config.as_deref())?;
-    config.apply_env();
 
     // Dispatch subcommands before bringing up the server.
     if let Some(cmd) = cli.command {
@@ -95,10 +94,25 @@ async fn main() -> anyhow::Result<()> {
             }
         },
     };
-    let public_base_url = format!("http://{our_ip}");
+    // v0.5.6: the advertised base URL must carry the HTTP port. Every
+    // client-facing URL (the DHCP-proxy iPXE filename, UEFI HTTP boot,
+    // and the menu's kernel/initrd/ISO links) is derived from this one
+    // string, so omitting the port silently pointed PXE clients at :80 —
+    // breaking every non-80 deployment (e.g. the Unraid template's 4200,
+    // chosen to dodge the webGUI). See `build_public_base_url`.
+    let public_base_url = build_public_base_url(our_ip, config.server.http_port);
 
     let iso_store = IsoStore::new(config.paths.iso_dir.clone());
     iso_store.load_from_disk().await?;
+    // v0.5.2: unattended answer-file store (Kickstart/Preseed/Autoinstall/
+    // Windows answer files). Separate directory from the ISO store.
+    let unattended = openpxe_iso_store::UnattendedStore::new(config.paths.unattended_dir.clone());
+    if let Err(e) = unattended.load_from_disk().await {
+        tracing::warn!(
+            target: "openpxe::unattended",
+            "could not load unattended files on startup: {e}"
+        );
+    }
     let clients = ClientRegistry::new();
     let queue = DeploymentQueue::new();
     let settings = SettingsStore::load_or_default(&config.paths.work_dir);
@@ -146,6 +160,19 @@ async fn main() -> anyhow::Result<()> {
         );
     }
 
+    // v0.5.5: SFTP-over-SSH share manager — pure-Rust in-process
+    // consumer via `russh` + `russh-sftp` (ring backend, no OpenSSL).
+    // The third remote-library protocol alongside SMB/NFS; like NFS it
+    // works in any container (no subprocess, no kernel mount) and
+    // supports HTTP Range requests because SFTP file handles seek.
+    let sftp_shares = SftpShareManager::new(&config.paths.work_dir, iso_store.clone());
+    if let Err(e) = sftp_shares.load_and_rescan().await {
+        tracing::warn!(
+            target: "openpxe::sftp",
+            "could not reload SFTP shares on startup: {e}"
+        );
+    }
+
     // Sniff network details for the Network tab. None of these are
     // required for PXE to work — they're informational, surfaced in the
     // UI so an operator doesn't have to drop to a shell to find their
@@ -157,6 +184,10 @@ async fn main() -> anyhow::Result<()> {
         "network info"
     );
 
+    // v0.7.1: boot rules are shared between the HTTP layer (target rules,
+    // webhook, the editor API) and the DHCP proxy (driver-mode pins).
+    let boot_rules = openpxe_core::BootRulesStore::load_or_default(&config.paths.work_dir);
+
     let state = AppState {
         iso_store: iso_store.clone(),
         clients: clients.clone(),
@@ -164,7 +195,10 @@ async fn main() -> anyhow::Result<()> {
         queue: queue.clone(),
         hosts: hosts.clone(),
         boot_log: boot_log.clone(),
+        boot_rules: boot_rules.clone(),
+        boot_tokens: openpxe_core::BootTokens::new(),
         branding: branding.clone(),
+        pxe_bg_cache: openpxe_http_api::state::PxeBgCache::default(),
         admin: admin.clone(),
         sessions: sessions.clone(),
         sso: sso.clone(),
@@ -174,6 +208,8 @@ async fn main() -> anyhow::Result<()> {
         smb: Some(smb.clone()),
         smb_shares: smb_shares.clone(),
         nfs_shares: nfs_shares.clone(),
+        sftp_shares: sftp_shares.clone(),
+        unattended: unattended.clone(),
         uploads: openpxe_http_api::uploads::UploadSessions::default(),
         log_bus: log_bus.clone(),
         started_at: time::OffsetDateTime::now_utc(),
@@ -200,11 +236,28 @@ async fn main() -> anyhow::Result<()> {
         Ok::<_, anyhow::Error>(())
     });
 
+    // v0.7.0: TFTP names that aren't embedded assets get a dynamic
+    // renderer — `grub.cfg` for the Secure Boot shim+GRUB chain is
+    // generated from the live boot-entry list on every fetch, so menu
+    // changes apply without restart.
+    let grub_isos = iso_store.clone();
+    let grub_base = public_base_url.clone();
+    let tftp_dynamic: openpxe_tftp::DynamicAsset = std::sync::Arc::new(move |name: &str| {
+        if name == "grub.cfg" || name.starts_with("grub.cfg-") {
+            Some(
+                openpxe_http_api::grub_script::render_grub_menu(&grub_isos.list(), &grub_base)
+                    .into_bytes(),
+            )
+        } else {
+            None
+        }
+    });
     let tftp = TftpServer::new(
         config.server.tftp_bind,
         config.server.tftp_port,
         clients.clone(),
         metrics.clone(),
+        Some(tftp_dynamic),
     );
     let tftp_task = tokio::spawn(tftp.run());
 
@@ -218,6 +271,10 @@ async fn main() -> anyhow::Result<()> {
                 public_base_url.clone(),
                 clients.clone(),
                 metrics.clone(),
+                // v0.7.1: learned driver modes persist next to the other
+                // state files, so a machine walks the ladder once *ever*.
+                openpxe_dhcp_proxy::DriverEscalation::load_or_default(&config.paths.work_dir),
+                boot_rules.clone(),
             );
             tokio::spawn(s.run())
         }
@@ -322,6 +379,20 @@ async fn seed_from_dir(
 /// a loopback address (which would give every PXE client an unreachable
 /// `http://127.0.0.1/...`). Users in multi-homed setups should set
 /// `OPENPXE_PUBLIC_IP` explicitly.
+/// Build the base URL advertised to PXE clients. The port is included
+/// unless it's the HTTP default (80), keeping the common case clean
+/// (`http://10.0.0.5`) while a remapped port (`http://10.0.0.5:4200`)
+/// stays reachable. This is the single source of truth for every
+/// client-facing URL — the DHCP-proxy iPXE filename, UEFI HTTP boot, and
+/// the boot menu's kernel/initrd/ISO links all derive from it.
+fn build_public_base_url(ip: Ipv4Addr, http_port: u16) -> String {
+    if http_port == 80 {
+        format!("http://{ip}")
+    } else {
+        format!("http://{ip}:{http_port}")
+    }
+}
+
 fn detect_primary_ipv4() -> Option<Ipv4Addr> {
     // First try: route to the public internet. `UdpSocket::connect` to a
     // well-known external address causes the OS to populate `local_addr`
@@ -455,3 +526,26 @@ fn prefix_to_dotted(prefix: u8) -> String {
         mask & 0xff
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn public_base_url_includes_non_default_port() {
+        // The v0.5.6 regression guard: a remapped HTTP port (e.g. the
+        // Unraid template's 4200) MUST appear in the advertised URL, or
+        // PXE clients fetch :80 — the wrong service — and boot fails.
+        let ip: Ipv4Addr = "192.168.1.49".parse().unwrap();
+        assert_eq!(build_public_base_url(ip, 4200), "http://192.168.1.49:4200");
+        assert_eq!(build_public_base_url(ip, 8080), "http://192.168.1.49:8080");
+    }
+
+    #[test]
+    fn public_base_url_omits_default_port() {
+        // Port 80 stays clean (no `:80`) so the common case reads nicely
+        // and matches what every browser/iPXE assumes by default.
+        let ip: Ipv4Addr = "10.0.0.5".parse().unwrap();
+        assert_eq!(build_public_base_url(ip, 80), "http://10.0.0.5");
+    }
+}

crates/tftp/src/lib.rs

@@ -14,4 +14,4 @@
 
 pub mod server;
 
-pub use server::TftpServer;
+pub use server::{DynamicAsset, TftpServer};

crates/tftp/src/server.rs

@@ -7,12 +7,12 @@
 //! `tftpd`/`in.tftpd` works and is why TFTP is awkward behind stateful NAT:
 //! the ephemeral ports must be reachable from the client.
 //!
-//! We only serve files from `openpxe_ipxe_assets::asset_bytes` — that is,
+//! We only serve files from `openpxe_ipxe_assets::asset_slice` — that is,
 //! the bundled iPXE binaries and wimboot. No filesystem is ever opened, so
 //! `../` path traversal attempts simply return ENOENT.
 
 use openpxe_core::{ClientEvent, ClientRegistry};
-use openpxe_ipxe_assets::asset_bytes;
+use openpxe_ipxe_assets::asset_slice;
 use socket2::{Domain, Protocol, Socket, Type};
 use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
@@ -21,6 +21,7 @@ use tokio::net::UdpSocket;
 
 // TFTP opcodes.
 const OP_RRQ: u16 = 1;
+const OP_WRQ: u16 = 2;
 const OP_DATA: u16 = 3;
 const OP_ACK: u16 = 4;
 const OP_ERROR: u16 = 5;
@@ -31,11 +32,19 @@ const ERR_NOT_DEFINED: u16 = 0;
 const ERR_FILE_NOT_FOUND: u16 = 1;
 const ERR_ILLEGAL_OP: u16 = 4;
 
+/// Server-rendered TFTP content for names that aren't embedded assets —
+/// e.g. `grub.cfg` for the signed shim+GRUB Secure Boot chain (v0.7.0),
+/// which is generated from the live boot-entry list per fetch. Kept as a
+/// closure so this crate stays decoupled from the ISO store; the binary
+/// wires it up in `main`.
+pub type DynamicAsset = Arc<dyn Fn(&str) -> Option<Vec<u8>> + Send + Sync>;
+
 pub struct TftpServer {
     bind: IpAddr,
     port: u16,
     clients: Arc<ClientRegistry>,
     metrics: openpxe_core::Metrics,
+    dynamic: Option<DynamicAsset>,
 }
 
 impl TftpServer {
@@ -44,12 +53,14 @@ impl TftpServer {
         port: u16,
         clients: Arc<ClientRegistry>,
         metrics: openpxe_core::Metrics,
+        dynamic: Option<DynamicAsset>,
     ) -> Self {
         Self {
             bind,
             port,
             clients,
             metrics,
+            dynamic,
         }
     }
 
@@ -71,8 +82,11 @@ impl TftpServer {
             let clients = clients.clone();
             let metrics = metrics.clone();
             let bind_ip = self.bind;
+            let dynamic = self.dynamic.clone();
             tokio::spawn(async move {
-                if let Err(e) = handle_rrq(data, from, bind_ip, clients, metrics.clone()).await {
+                if let Err(e) =
+                    handle_rrq(data, from, bind_ip, clients, metrics.clone(), dynamic).await
+                {
                     metrics.record_tftp_err();
                     tracing::warn!(target: "openpxe::tftp", peer=%from, "handler error: {e}");
                 }
@@ -87,18 +101,45 @@ async fn handle_rrq(
     bind_ip: IpAddr,
     clients: Arc<ClientRegistry>,
     metrics: openpxe_core::Metrics,
+    dynamic: Option<DynamicAsset>,
 ) -> anyhow::Result<()> {
     let Some(req) = parse_rrq(&packet) else {
+        // Not a well-formed RRQ. A WRQ deserves an explicit refusal —
+        // legacy clients retry a silently-dropped write until they time
+        // out; an ERROR packet fails them fast with a readable reason.
+        if packet.len() >= 2 && u16::from_be_bytes([packet[0], packet[1]]) == OP_WRQ {
+            let sock = bind_udp(bind_ip, 0)?;
+            let _ = send_error(&sock, peer, ERR_ILLEGAL_OP, "writes not supported").await;
+        }
         return Ok(());
     };
     let Request {
-        filename, options, ..
+        filename,
+        mode,
+        options,
     } = req;
 
     // Per-transfer ephemeral socket.
     let sock = bind_udp(bind_ip, 0)?;
 
-    let Some(file_bytes) = asset_bytes(&filename) else {
+    // We serve binary boot artifacts; netascii line-ending translation
+    // would corrupt them. Refuse loudly instead of timing out silently —
+    // matters for legacy clients that default to netascii.
+    if !mode.eq_ignore_ascii_case("octet") {
+        let _ = send_error(&sock, peer, ERR_NOT_DEFINED, "only octet mode is supported").await;
+        tracing::info!(target: "openpxe::tftp", peer=%peer, %mode, "rejected non-octet transfer");
+        return Ok(());
+    }
+
+    // Embedded assets first; otherwise the dynamic renderer (server-
+    // generated content like the Secure Boot chain's grub.cfg, v0.7.0).
+    let resolved = asset_slice(&filename).or_else(|| {
+        dynamic
+            .as_ref()
+            .and_then(|f| f(&filename))
+            .map(std::borrow::Cow::Owned)
+    });
+    let Some(file_bytes) = resolved else {
         let _ = send_error(&sock, peer, ERR_FILE_NOT_FOUND, "no such file").await;
         tracing::info!(target: "openpxe::tftp", peer=%peer, file=%filename, "404");
         clients.record(
@@ -262,7 +303,6 @@ async fn handle_rrq(
 #[derive(Debug)]
 struct Request {
     filename: String,
-    #[allow(dead_code)]
     mode: String,
     options: Vec<(String, String)>,
 }
@@ -393,17 +433,13 @@ fn bind_udp(bind: IpAddr, port: u16) -> anyhow::Result<UdpSocket> {
     Ok(UdpSocket::from_std(std_sock)?)
 }
 
-#[allow(dead_code)]
+/// Pure-logic mirror of `handle_rrq`'s windowing math, exercised by the
-const _UNUSED: (u16, u16) = (ERR_NOT_DEFINED, ERR_ILLEGAL_OP);
+/// unit tests below. Given a position in the file and the window, return
-
+/// the (block_no, chunk_len) list this window will emit — tested against
-/// Pure-logic helper used by the unit tests below and (in a refactor) by
+/// edge cases (exact-blksize tail, short tail, single-block window,
-/// `handle_rrq`. Given a position in the file and the window, return the
+/// block-number wraparound).
-/// (block_no, chunk_len) list this window will emit. Useful as a sanity
+#[cfg(test)]
-/// check that our windowing math matches the wire behavior the spec
+fn plan_window(
-/// requires — tested against edge cases (exact-blksize tail, short tail,
-/// single-block window).
-#[must_use]
-pub fn plan_window(
     total: usize,
     offset: usize,
     blksize: usize,

crates/webui/src/app.css

@@ -304,6 +304,14 @@ button.ghost { background: transparent; color: var(--fg); border: 1px solid var(
 button.ghost:hover { background: var(--bg-panel-2); color: var(--fg); }
 button.danger { background: transparent; color: var(--err); border: 1px solid color-mix(in srgb, var(--err) 35%, transparent); }
 button.danger:hover { background: color-mix(in srgb, var(--err) 14%, transparent); color: var(--err); }
+/* v0.5.3: unified spacing for a card's primary action button(s). Any
+   button that sits as a direct child of a card body (Save, Bind, Add,
+   Launch, …) gets the same gap above it so it never butts against the
+   form. Inline buttons inside table rows / toolbars / logo slots /
+   modal action bars are nested deeper, so the `>` keeps them untouched.
+   Adjacent action buttons on one row (e.g. Save + Send test) share the
+   margin and stay aligned. */
+.card .body > button { margin-top: 16px; }
 
 label.field {
   display: grid; gap: 4px; margin-bottom: 14px;
@@ -840,3 +848,67 @@ tr.unbootable td:first-child { border-left: 3px solid var(--warn); }
   border: 1px solid var(--border);
   color: var(--fg-dim);
 }
+
+/* ── v0.5.2: three-slot branding (light / dark / client) ─────────── */
+.logo-slots {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 12px;
+}
+@media (max-width: 720px) { .logo-slots { grid-template-columns: 1fr; } }
+.logo-slot {
+  display: flex; flex-direction: column; gap: 8px;
+  padding: 12px;
+  background: var(--bg-panel-2);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+}
+.logo-slot-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+.logo-slot-head .name { color: var(--fg); font-weight: 600; font-size: 13px; }
+.logo-slot .swatch {
+  height: 64px;
+  display: flex; align-items: center; justify-content: center;
+  background: var(--bg); border: 1px solid var(--border);
+  border-radius: var(--radius);
+}
+.logo-slot .swatch img { max-width: 90%; max-height: 52px; object-fit: contain; }
+.logo-slot-hint { color: var(--fg-dim); font-size: 11.5px; }
+
+/* ── v0.5.2: login local/SSO separation ─────────────────────────── */
+.auth-card .auth-divider {
+  display: flex; align-items: center; text-align: center;
+  color: var(--fg-dimmer); font-size: 11px; text-transform: uppercase;
+  letter-spacing: 0.08em;
+  margin: 16px 0 12px;
+}
+.auth-card .auth-divider::before,
+.auth-card .auth-divider::after {
+  content: ""; flex: 1; height: 1px; background: var(--border-soft);
+}
+.auth-card .auth-divider span { padding: 0 10px; }
+.auth-card .sso-block .sso-btn { margin-top: 0; }
+.auth-card .sso-btn {
+  display: flex; align-items: center; justify-content: center; gap: 8px;
+}
+.auth-card .sso-btn .sso-logo { width: 16px; height: 16px; object-fit: contain; flex: none; }
+
+/* ── v0.5.2: modal (queue Profile editor) ───────────────────────── */
+.modal-overlay {
+  position: fixed; inset: 0; z-index: 200;
+  display: flex; align-items: center; justify-content: center;
+  background: rgba(0, 0, 0, 0.55);
+  padding: 24px;
+}
+.modal-box {
+  width: 100%; max-width: 520px;
+  background: var(--bg-panel);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-card);
+  padding: 22px;
+}
+.modal-box h2 { margin: 0 0 14px; font-size: 16px; font-weight: 600; color: var(--fg); }
+.modal-actions {
+  display: flex; justify-content: flex-end; gap: 10px; margin-top: 18px;
+}
+.modal-actions .submit { width: auto; padding: 8px 18px; }

crates/webui/src/index.html

@@ -13,7 +13,10 @@
        on the asset handlers, the practical caching window is one
        version. -->
   <link rel="stylesheet" href="/assets/app.css?v={{ASSET_VERSION}}" />
-  <link rel="icon" type="image/svg+xml" href="/assets/logo.svg?v={{ASSET_VERSION}}&r={{LOGO_REV}}" />
+  <!-- v0.5.2: favicon is pinned to the bundled OpenPXE mark (its own
+       endpoint, decoupled from operator branding) for tab-icon
+       continuity regardless of any uploaded light/dark/client logo. -->
+  <link rel="icon" type="image/svg+xml" href="/assets/favicon.svg?v={{ASSET_VERSION}}" />
   <!-- Theme is read from localStorage *before* paint to avoid the
        dark→light flash on every navigation. Falls back to the OS
        preference and finally to dark. -->

deploy/docker/Dockerfile

@@ -23,11 +23,19 @@ ARG RUST_VERSION=1.95
 # and serve as the baseline that the PNG-enabled x86_64/arm64 UEFI
 # binaries from the `ipxe-build` stage overlay on top of.
 FROM debian:12-slim AS fetch
-RUN apt-get update && apt-get install -y --no-install-recommends curl ca-certificates \
+# rpm2cpio + cpio: extract Fedora's Microsoft-signed shim/GRUB RPMs for
+# the Secure Boot chain (v0.7.0, scripts/fetch-shim.sh).
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        curl ca-certificates rpm2cpio cpio \
  && rm -rf /var/lib/apt/lists/*
 WORKDIR /src
 COPY scripts/fetch-ipxe.sh scripts/fetch-ipxe.sh
+COPY scripts/fetch-shim.sh scripts/fetch-shim.sh
 RUN mkdir -p assets/ipxe && bash scripts/fetch-ipxe.sh
+# Signed shim+GRUB (Secure Boot escalation rung). Redistributed
+# unmodified from the official Fedora packages — see fetch-shim.sh for
+# the trust model.
+RUN bash scripts/fetch-shim.sh /src/assets/ipxe
 
 ########## build PNG-enabled iPXE from source ##########
 # v0.4.69: THE graphical-boot-menu unlock. iVentoy paints a PNG
@@ -60,35 +68,41 @@ COPY deploy/ipxe/local/ deploy/ipxe/local/
 RUN mkdir -p assets/ipxe && bash scripts/build-ipxe.sh /src/assets/ipxe
 
 ########## build openpxe ##########
-FROM rust:${RUST_VERSION}-bookworm AS build
+# v0.5.2: cross-compile the Rust binary NATIVELY — no QEMU.
-WORKDIR /src
-
-# v0.4.5: build a fully static musl binary (matches Bootimus v0.1.70's
-# move). The resulting `/openpxe` has no glibc dependency at all, which:
-#   - Lets the runtime stage be any Linux distro (we still ship Debian
-#     slim for the `samba` / `wimtools` / `nfs-common` shellouts, but a
-#     scratch/distroless variant becomes a one-line swap).
-#   - Cuts a class of "GLIBC_2.39 not found" surprises when running on
-#     older RHEL/Rocky hosts that don't match Debian 12's libc version.
-#   - Sidesteps cross-compilation snags (the binary is its own world).
 #
-# x86_64-unknown-linux-musl is fully static by default (no extra
+# This stage is pinned to $BUILDPLATFORM (the builder's native arch — arm64
-# RUSTFLAGS needed). musl-tools provides the linker.
+# on an Apple-Silicon Mac, amd64 in x86 CI), exactly like `ipxe-build`. The
+# Rust compiler therefore runs at full native speed and emits an
+# x86_64-unknown-linux-musl binary via `cargo-zigbuild`, which uses `zig cc`
+# as the cross-linker (it bundles the musl sysroot for every target, so
+# there's no fiddly cross-gcc toolchain to assemble).
+#
+# Why this replaced the old `FROM rust ... --platform=linux/amd64` build:
+# that ran the *entire* compiler under QEMU x86_64 emulation on the arm64
+# host. It was ~15x slower (a single crate took >20 min) and the emulated
+# gcc/linker intermittently SIGSEGV'd or hung mid-link. Cross-compiling
+# sidesteps emulation entirely — the build is minutes, not half an hour,
+# and is deterministic.
+#
+# The output is still a fully static musl binary with no glibc dependency,
+# so the runtime stage stays free to be any Linux distro.
+FROM --platform=$BUILDPLATFORM rust:${RUST_VERSION}-bookworm AS build
+WORKDIR /src
+# zig (via the `ziglang` pip package — cargo-zigbuild auto-discovers it as
+# `python3 -m ziglang`) supplies the x86_64 musl sysroot + linker.
+# cargo-zigbuild is the thin cargo wrapper that wires zig in as the linker.
 RUN apt-get update \
- && apt-get install -y --no-install-recommends musl-tools \
+ && apt-get install -y --no-install-recommends python3 python3-pip \
  && rm -rf /var/lib/apt/lists/* \
- && rustup target add x86_64-unknown-linux-musl
+ && rustup target add x86_64-unknown-linux-musl \
+ && pip3 install --no-cache-dir --break-system-packages ziglang \
+ && cargo install --locked cargo-zigbuild
 
-# Copy the whole workspace in one go. We used to do a two-pass "cache-prime
-# with stubs, then real build" dance for dep-compile reuse; that turned out
-# to silently serve stale stub binaries when cargo's fingerprint didn't
-# notice the source swap. A single build is ~1.5 min longer on cold cache
-# but guarantees the binary reflects the sources we copied.
 # Do not copy rust-toolchain.toml into the image. The local workspace pins
 # developer tooling, but inside Docker we intentionally use the Rust version
 # selected by the base image. Copying rust-toolchain.toml with
 # `channel = "stable"` makes rustup download a second full toolchain during
-# `cargo build`, which is slow and can exhaust small Colima/CI disks.
+# the build, which is slow and can exhaust small Colima/CI disks.
 COPY Cargo.toml Cargo.lock ./
 COPY crates/ crates/
 # Baseline binaries (BIOS / i386 / wimboot), then overlay the
@@ -100,13 +114,11 @@ COPY --from=fetch /src/assets/ipxe /src/assets/ipxe
 COPY --from=ipxe-build /src/assets/ipxe/snponly.efi /src/assets/ipxe/snponly.efi
 COPY --from=ipxe-build /src/assets/ipxe/ipxe.efi /src/assets/ipxe/ipxe.efi
 
-# Cache cargo registry + target across builds. The mtime touch is
+# Cache cargo registry + target across builds. `cargo zigbuild` runs the
-# belt-and-suspenders: cargo occasionally misses mtime-only changes on
+# native rustc (fast) and links for x86_64-musl with zig — no emulation.
-# networked FS; this forces a fingerprint check.
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/src/target,sharing=locked \
-    find crates -name '*.rs' -exec touch {} + && \
+    cargo zigbuild --release --target x86_64-unknown-linux-musl --bin openpxe && \
-    cargo build --release --target x86_64-unknown-linux-musl --bin openpxe && \
     cp target/x86_64-unknown-linux-musl/release/openpxe /openpxe && \
     ls -l /openpxe
 

docs/openpxe-logo.svg

@@ -0,0 +1,21 @@
+<svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="OpenPXE">
+  <title>OpenPXE</title>
+  <!-- Static README mark: the "rainbow-horizon" medallion from the web UI,
+       with the SMIL animation removed so it renders reliably as an <img>
+       on Gitea/GitHub. -->
+  <defs>
+    <linearGradient id="opxRainbow" x1="0" y1="0" x2="1" y2="0">
+      <stop offset="0%"     stop-color="#330f1f"/>
+      <stop offset="12.56%" stop-color="#c83228"/>
+      <stop offset="25.06%" stop-color="#fb8841"/>
+      <stop offset="37.56%" stop-color="#d3dd92"/>
+      <stop offset="50.06%" stop-color="#59824f"/>
+      <stop offset="62.06%" stop-color="#002414"/>
+      <stop offset="74.06%" stop-color="#00143d"/>
+      <stop offset="86.06%" stop-color="#2874d7"/>
+      <stop offset="100%"   stop-color="#99c2ff"/>
+    </linearGradient>
+  </defs>
+  <circle cx="12" cy="12" r="10.5" fill="url(#opxRainbow)"
+          stroke="rgba(0,0,0,0.18)" stroke-width="0.6"/>
+</svg>

scripts/build-ipxe.sh

@@ -41,15 +41,31 @@ DEST="${1:-$ROOT/assets/ipxe}"
 WORK="$(mktemp -d)"
 trap 'rm -rf "$WORK"' EXIT
 
-# Pinned upstream iPXE. Rolling master is fine functionally, but a pin
+# Pinned upstream iPXE. Rolling master is fine functionally, but a pin keeps
-# keeps builds reproducible and protects against a transient master
+# builds reproducible, protects against a transient master breakage, and —
-# breakage. Bump deliberately.
+# crucially for the Docker image — busting this value invalidates the cached
+# ipxe-build layer so an "update iPXE" release actually recompiles from the
+# new upstream. Bump deliberately to a recent master commit.
+#
+# v0.6.1: ipxe/ipxe master @ 2026-06-09 (newer NIC drivers + EFI fixes;
+# mirrors iVentoy 1.0.35 "Update iPXE").
 IPXE_REPO="https://github.com/ipxe/ipxe.git"
-IPXE_REF="${IPXE_REF:-master}"
+IPXE_REF="${IPXE_REF:-95ffbf4745553e8a207922389929e1943c0237c0}"
 
-echo ">> cloning iPXE ($IPXE_REF)"
+echo ">> fetching iPXE ($IPXE_REF)"
-git clone --depth 1 --branch "$IPXE_REF" "$IPXE_REPO" "$WORK/ipxe" 2>/dev/null \
+# Shallow-fetch the exact ref: works for a full commit SHA (GitHub allows
-  || git clone "$IPXE_REPO" "$WORK/ipxe"
+# reachable-SHA1-in-want) and for branch/tag names. Fall back to a full
+# clone + checkout if the server refuses a direct fetch of this ref.
+git init -q "$WORK/ipxe"
+git -C "$WORK/ipxe" remote add origin "$IPXE_REPO"
+if git -C "$WORK/ipxe" fetch -q --depth 1 origin "$IPXE_REF"; then
+  git -C "$WORK/ipxe" checkout -q FETCH_HEAD
+else
+  echo "   direct fetch failed; falling back to full clone + checkout"
+  rm -rf "$WORK/ipxe"
+  git clone -q "$IPXE_REPO" "$WORK/ipxe"
+  git -C "$WORK/ipxe" checkout -q "$IPXE_REF"
+fi
 SRC="$WORK/ipxe/src"
 
 echo ">> applying OpenPXE config overrides (PNG + framebuffer + console cmd)"

scripts/fetch-ipxe.sh

@@ -29,11 +29,19 @@ mkdir -p "$DEST"
 # Upstream uses arch-scoped subdirectories; we flatten to the names our
 # ClientArch::ipxe_bootfile() expects.
 declare -a MAP=(
+  # DriverMode::Firmware (default) — reuse the firmware UNDI/SNP NIC stack.
   "undionly.kpxe=undionly.kpxe"
   "snponly.efi=x86_64-efi/snponly.efi"
   "snponly-i386.efi=i386-efi/snponly.efi"
   "snponly-arm64.efi=arm64-efi/snponly.efi"
-  "ipxe.efi=x86_64-efi/ipxe.efi"          # fallback with bundled drivers
+  # DriverMode::Builtin (v0.6.1 automatic fallback) — iPXE's own all-drivers
+  # builds, advertised by the DHCP proxy to a MAC whose firmware NIC stack
+  # failed to chainload. (x86_64 ipxe.efi is rebuilt from source with PNG in
+  # build-ipxe.sh and overlaid on top of this fetched baseline.)
+  "ipxe.efi=x86_64-efi/ipxe.efi"
+  "ipxe.pxe=ipxe.pxe"
+  "ipxe-i386.efi=i386-efi/ipxe.efi"
+  "ipxe-arm64.efi=arm64-efi/ipxe.efi"
 )
 
 BASE="https://boot.ipxe.org"

scripts/fetch-shim.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# Fetch Fedora's Microsoft-signed Secure Boot chain — shim + GRUB — and
+# place the EFI binaries under assets/ipxe/ with the filenames OpenPXE's
+# DriverMode::Shim mapping expects:
+#
+#   shimx64.efi    x86_64: Microsoft-signed shim (first stage)
+#   grubx64.efi    x86_64: Fedora-signed GRUB (loaded by shim, fetches
+#                  the server-rendered grub.cfg over TFTP/HTTP)
+#   shimaa64.efi   arm64 equivalents (best-effort — see below)
+#   grubaa64.efi
+#
+# Why Fedora: a supply-chain decision made deliberately (v0.7.0) — one
+# vendor, fast security turnaround, and the same chain most netboot
+# projects redistribute. The binaries are extracted from the official
+# distro RPMs and shipped BYTE-FOR-BYTE UNMODIFIED; their signatures are
+# what make the chain work, and modifying them would break it. This is
+# the standard documented netboot path for Secure Boot (Red Hat
+# Satellite, SUSE HTTPBoot) and involves no test certificates and no
+# client trust-store changes.
+#
+# Trust model matches fetch-ipxe.sh: HTTPS to the official distribution
+# point, no sha pinning because we track the latest signed build (which
+# rotates on SBAT revocations — pinning would mean shipping revoked
+# shims). Mirror to your own artifact store for deterministic builds.
+
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+DEST="${1:-$ROOT/assets/ipxe}"
+mkdir -p "$DEST"
+
+FEDORA_RELEASE="${FEDORA_RELEASE:-43}"
+BASE="${FEDORA_MIRROR:-https://dl.fedoraproject.org/pub/fedora/linux/releases/$FEDORA_RELEASE/Everything}"
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+# Find the newest RPM in a repo directory whose name starts with
+# `$pattern` followed by a version digit (anchoring on the digit keeps
+# `grub2-efi-x64` from matching `grub2-efi-x64-cdboot`).
+latest_rpm() {
+  local dir_url="$1" pattern="$2"
+  curl -fsSL "$dir_url/" \
+    | grep -oE "href=\"${pattern}-[0-9][^\"]*\.rpm\"" \
+    | sed 's/^href="//; s/"$//' \
+    | sort -V | tail -1
+}
+
+# fetch_chain <repo-arch> <shim-pkg> <grub-pkg> <shim-out> <grub-out> <hard|soft>
+fetch_chain() {
+  local arch="$1" shim_pkg="$2" grub_pkg="$3" shim_out="$4" grub_out="$5" mode="$6"
+  local pkg_base="$BASE/$arch/os/Packages"
+  local sdir="$pkg_base/${shim_pkg:0:1}" gdir="$pkg_base/${grub_pkg:0:1}"
+
+  local shim_rpm grub_rpm
+  shim_rpm="$(latest_rpm "$sdir" "$shim_pkg" || true)"
+  grub_rpm="$(latest_rpm "$gdir" "$grub_pkg" || true)"
+  if [ -z "$shim_rpm" ] || [ -z "$grub_rpm" ]; then
+    echo "!! could not locate $shim_pkg/$grub_pkg RPMs under $pkg_base"
+    [ "$mode" = "hard" ] && exit 2
+    echo "   skipping $arch Secure Boot chain (best-effort)"
+    return 0
+  fi
+
+  echo ">> $arch: $shim_rpm + $grub_rpm"
+  local exdir="$WORK/$arch"
+  mkdir -p "$exdir"
+  curl -fsSL -o "$exdir/shim.rpm" "$sdir/$shim_rpm"
+  curl -fsSL -o "$exdir/grub.rpm" "$gdir/$grub_rpm"
+  ( cd "$exdir" \
+    && rpm2cpio shim.rpm | cpio -idm --quiet "./boot/efi/EFI/*/$shim_out" \
+    && rpm2cpio grub.rpm | cpio -idm --quiet "./boot/efi/EFI/*/$grub_out" )
+
+  local shim_path grub_path
+  shim_path="$(find "$exdir/boot" -name "$shim_out" | head -1)"
+  grub_path="$(find "$exdir/boot" -name "$grub_out" | head -1)"
+  if [ -z "$shim_path" ] || [ -z "$grub_path" ]; then
+    echo "!! RPM layout changed — $shim_out/$grub_out not found inside the packages"
+    [ "$mode" = "hard" ] && exit 2
+    return 0
+  fi
+  cp "$shim_path" "$DEST/$shim_out"
+  cp "$grub_path" "$DEST/$grub_out"
+  echo "   installed $shim_out + $grub_out"
+}
+
+# x86_64 is the headline Secure Boot audience — fail the build if it
+# can't be assembled so a regression is loud, not silent.
+fetch_chain x86_64 shim-x64 grub2-efi-x64 shimx64.efi grubx64.efi hard
+# arm64 is best-effort: skipping just means no Shim escalation rung for
+# that arch (logged at startup by ipxe-assets::log_availability).
+fetch_chain aarch64 shim-aa64 grub2-efi-aa64 shimaa64.efi grubaa64.efi soft
+
+echo
+echo "Secure Boot chain assets now in $DEST:"
+ls -lh "$DEST"/shim*.efi "$DEST"/grub*.efi 2>/dev/null || true