cxg changelog
Version 1.6.0
Upgrading from 1.5.0 — read this first
The pentest pipeline refreshes itself after the binary upgrade. cxg pentest runs a
Python pipeline that an earlier binary materialised under ~/.cert-x-gen/pentest/. Before
this release, upgrading the binary left that copy untouched, so an upgraded cxg kept running
the previous release’s pipeline until someone ran cxg pentest install --force.
From 1.6.0, the first pentest action after upgrading (a run, an auth command or
capabilities) checks the installed files against the new binary’s embedded bundle and
refreshes them offline. A 1.5.0 installation has no content manifest and is refreshed on that
first action. To refresh deliberately instead, run cxg pentest update (add --json for a
machine-readable result); cxg pentest status --json reports freshness without changing
anything. Every replacement saves the entire previous tree, including local edits and added
files, under ~/.cert-x-gen/pentest-backups/; auth profiles, sessions and template stores are
not touched. Refresh does not run pip or install browsers, so new Python dependencies still
need the usual setup. An installation that records a source checkout as its origin, or a shell
with CXG_SOURCE set, is never replaced automatically: use cxg pentest update --from-embedded
to opt in. A 1.5.0 client takes no execution lease, so upgrade between runs rather than while
one is in progress. See the pentest upgrade guide.
Fewer findings reach confirmed, on purpose. A generated template can no longer confirm its
own finding: confirmed: true, evidence.outcome: "confirmed" or reflection-only evidence is
no longer enough. A finding is confirmed only on a class-appropriate signal the engine itself
observed. Without one it is held as unverified (the probe ran but proved nothing) or
unsupported (cxg has no oracle for the class). A run that confirmed a finding on 1.5.0 can
report it as unverified on 1.6.0 against the same target; that is the intended change, not a
regression. See “Proof contract” under Changed.
Added
- Exact GuardLink threat selection:
cxg pentest run --threat-id gl-…confines JS generation on web/Electron to imported hypotheses carrying that exact id. Selection precedes dedupe/ranking; unrelated discovery, boundary, desktop-surface and host probes are disabled. Missing ids refuse with exit 4 before target contact. Reports retain selected/excluded hypotheses inthreat_selection; scope authorization remains mandatory and unchanged.cxg pentest capabilitiesreturns the installed orchestrator’s JSON capability list, includingexact-threat-id. - No-login / anonymous pentests are first-class. Empty
--authnow runs real unauthenticated probing on a clean anonymous surface, without requesting interactive capture. Templates declaringrequires_auth_count=0are runnable without a login. Reports addauth_mode(anonymous,mixed, orauthenticated) andauth_skipped; auth-only checks are recorded as not-run when their authenticated context is unavailable, instead of halting the run or being silently refuted. All existing authentication and safety gates remain in force, including strict named-profile loading, scope/host containment, CI dead-session checks, the two-identity IDOR premise, and proof oracles. cxg pentest run --target-type tauri --tauri-proveproves Tauri IPC commands in process. After mapping the IPC surface, cxg copies the app, injects a#[cfg(test)]probe module into the file that already holds the app’stauri::generate_handler!(so the same command paths and imports — including private commands — are in scope), enables Tauri’stestcrate feature, and drives each ranked command throughtauri::test::get_ipc_responsewith hostile arguments on a headlessMockRuntime— no webview, no network. A deterministic prober generates the arguments from each command’s parameter shape (a../-chain against a planted sentinel for path parameters; privileged-vs-benign values for authorization parameters) and a conservative oracle classifies each into the existing finding model: confirmed only on definitive evidence (the sentinel’s content came back; a privileged value succeeded where every benign value was rejected), refuted when the handler rejected the hostile argument, unevaluated otherwise. A command the harness cannot drive (it does not compile, or exposes no probeable argument) is listed undertauri_skipped_commandswith a reason — never refuted. Needs a Rust toolchain;--tauri-prove-timeoutbounds the build+run. Without the flag, a tauri run stays the source-surface map.cxg pentest run --target-type taurimaps a Tauri app’s IPC surface from source. A new target type reads the Rust side of a Tauri application — every#[tauri::command]handler, its registration intauri::generate_handler!(resolving module-path-qualified names and aconstarray of command identifiers, and honouring#[tauri::command(rename = "…")]for the invokable command name), and thecapabilities/*.jsongrants plus the security-relevanttauri.conf.jsonfields — and emits oneipc://<command>hypothesis per command, correlating them against the guardlink threat model exactly as the Electron channel surface does. It is a source-surface map, not a live probe: a Tauri app exposes no CDP endpoint on macOS or Linux, so cxg cannot drive its webview the way it drives an Electron renderer. The run writes areport.jsonwithstatus: "tauri_surface_mapped", the command surface undertauri_ipc_surface, the capability grants undertauri_capabilities, and anenumerated_not_live_probedcaveat stating plainly that no command was confirmed or refuted.--targetis not required for this target type (it never navigates anywhere). Proving a command exploitable in-process is a separate, following step.cxg pentestcan authenticate to header/apikey-gated APIs. An auth profile’s per-identityextra_headers(set withcxg pentest auth login|import --header NAME:VALUE, serialised under theextra_headerskey in~/.cert-x-gen/auth/<profile>.meta.json) are now sent on every request cxg issues for that identity — both the in-browser fetch path and the out-of-browser raw (Playwright request) path, where they previously were not, so a target that gates on a staticapikey/Authorizationheader (for example a self-hosted Supabase gateway) is now authenticated oncxg.raw/cxg.rawAsprobes as well as in-browser ones. A template’s own per-request header of the same name (matched case-insensitively) still wins. Header values are treated as credentials and never logged.- Headers-only (cookieless) auth profiles. An apikey/bearer-gated identity has no capturable
cookie session;
cxg pentest auth import --profile <name> --target <url> --header NAME:VALUE(with no--storage-state) now writes a headers-only profile — a<name>.meta.jsonwithextra_headersand no<name>.json. It loads under--auth <name>without the “auth profile could not be loaded” error that previously halted every probe against such a target, opening an unauthenticated browser context that still presents the headers. - Engine oracles for SQL injection.
cxg.sqligives templates two engine-side oracles. The time-blind oracle samples baseline, injected-delay and zero-delay control latencies and confirms only when the injected delay is clearly separated from both. The extraction oracle confirms only when a database-computed, non-sensitive marker absent from the control is read back through a bounded UNION or error channel. Both SQL-injection classes now confirm only on these observations, never on reflection or a template’s own verdict. - Clickjacking is proven by an observed action, not by frameability. Under
--attacker-origin,cxg.attacker.clickjackframes the target cross-origin, overlays a decoy on a real control, clicks through it and confirms only when the underlying action fires. A page that merely renders in a frame is held as unverified. - Sandbox-gated oracles for destructive classes. File-upload-to-RCE, GraphQL amplification,
brute-force and credential stuffing run, and can confirm, only under an authorized-sandbox
gate:
--destructive-okand a loopback/localhost target. Outside the gate they are reportedunsupportedwith the missing half named, and the probe never runs. Upload-RCE confirms only on an observed execution callback, not on the upload being accepted; GraphQL amplification confirms on a measured response blow-up and states the factor; brute-force results are bounded by the configured attempt count. Race/TOCTOU confirms on an observed state readback and is not sandbox-gated. cxg pentest updateandcxg pentest status.update [--json] [--from-embedded]makes the installed pipeline match this binary’s embedded bundle offline, backing up the previous tree;status [--json]reports freshness read-only and works without Python.installandinstall --forceshare the same installer. Runs and updates coordinate through a lease on~/.cert-x-gen/pentest.lock, so an update never replaces files under a running pipeline. The bundle’s manifest is derived from the packaged files at build time.
Changed
- Proof contract. A finding is promoted to
confirmedonly through a per-class proof predicate that reads engine-written evidence. A registered class whose signal is absent is held asunverified; a class with no predicate is held asunsupported. The engine discards template-supplied copies of its reserved evidence keys, so a template cannot forge them. Theunreachable,dispatch_failedandblockedchecks run before any verdict. An XSS dialog counts as execution only if its message carries the payload marker. Seepentest/docs/TEMPLATES.md. - OAuth, OIDC and SAML findings are held at unverified. The previous OAuth forgery
differential could not distinguish a vulnerable flow from a safe one and was removed, so no
finding in these classes reaches
confirmed. Cross-host identity-provider traffic remains blocked by the scope rule.
Fixed
cxgno longer overflows the main-thread stack on Windows at startup. Building the full command tree could abort evencxg --helpwith0xC00000FDin debug builds. Argument parsing and dispatch now run on a dedicated thread with an explicit 8 MiB stack on every platform, with exit codes and panics carried back unchanged.
Documentation and infrastructure
- The README,
docs/USAGE_GUIDE.md,pentest/README.mdand the built-in--helptext describe CLI baseline scanning and Tauri testing: what the source map establishes, what--tauri-proveadds, and the limits of a mock-runtime proof. - The release and CI build jobs retry the artifact upload once after a pause, so a transient artifact-service timeout on one runner no longer fails a whole release.

