All versions since 1.5.0
1.5.0
Added
-
cxg pentest runcan be limited to a list of routes.--only-routes <FILE>(and the repeatable--only-route <ENTRY>) tests only the hypotheses whose route or enclosing function is in the list; every other hypothesis is excluded before ranking and the--max-templatesbudget, and reported with its reason in the run output and a newroute_allowlistblock inreport.json. Entries areMETHOD /path(ANY/*for any method; path templates and concrete paths match each other; a trailing*is a prefix),/path,file::Function, orfile:Function— one per line, or JSON, including a code graph’scodegraph_routes/codegraph_attack_surfaceanswer passed through unchanged, so a caller can hand cxg the routes a change reached without reformatting them. Path matching reuses the code graph’s template-aware matcher. An empty list means “nothing in scope” and exits0without contacting the target, distinct from omitting the flag (a full run); an unreadable file, or a use with--template-diror--template-lang py, refuses the run with exit4. This is the cxg half of testing only a pull request’s delta in CI. -
cxg pentest runreads a code graph when one is available. Ifcodegraph-mcporbravos graphis installed and a graph has been built for the codebase (bravos graph build <codebase>), cxg uses its route table as the preferred route source for--discover-routes. That covers gorilla/mux, net/http, httprouter, OpenAPI-table and Django routes the regex cannot see: on gophish discovery goes from 0 routes to 48, and on VAmPI from 0 to 14. The graph’s reachable-sink ranking (data layer, exec, outbound network, …) also becomes a ranking dimension for which hypotheses get the--max-templatesbudget. When the graph reports insufficient call resolution, it is not used for ranking and the run output says so. Without graph tooling, or with--no-code-graph, a run is unchanged.report.jsongains acode_graphblock, and each discovered hypothesis records which source its route came from. -
Route-declaring
@flowsreach route discovery, and the run reports flows it cannot use. A flow whose mechanism is a route (via GET./orders/<id>) now adds that route to the--discover-routessurface when no scanned route already serves it, matching parameters across router spellings (<id>,:id,{id}). The run prints a[1h] @flows:line counting flow edges, chainable flows and route-declaring flows, and names by file and line every flow that cannot chain and every@flowsline it could not read. -
cxg pentest runtests each declared trust boundary. A guardlink SARIF that carries its model graph (sarif_profile_version1, guardlink’s export since it added declared context) lists every@boundarywith its claim key, both sides and the flows that cross it. For each boundary whose outside side guardlink can infer (one side is not a declared asset), cxg builds oneauth_apihypothesis per route on the inside: a route@flowscrossing inward, or a code graph route handled where an inward crossing is declared. The probe calls the route with no credential and then as the lowest-privilege identity, told the boundary’s own words, the code graph’s measured access level for the route (public,authenticated,elevatedorunknown) and the data classes the inside asset handles. These hypotheses rank below every declared threat and never displace or merge with one; a boundary is a claim to test, never evidence that a route is safe. A boundary between two declared assets has no known direction and yields none.report.jsongainsdeclared_boundaries(one record per boundary, with what was built or why nothing was), and a finding from such a probe carriesboundary_claim_key.
Changed
-
cxg pentest runreads guardlink’s declared context instead of re-deriving it. With a SARIF that carries it, a hypothesis’s@flowschain comes from the result’scodeFlows, its@boundary/@assumes/@handles/@transfersintent notes from itsrelatedLocations(same@verb: descriptiontext), and its function name fromlogicalLocations, rather than from source comments within 30 lines of the annotation. A hypothesis no longer picks up flows and notes declared on a neighbouring handler or asset, and does pick up notes on its own asset declared in another file.@commentand@validates, which guardlink does not export, are still read from source. An older SARIF is read exactly as before. The run prints a[1h]line saying which path it took. -
Routes come from the code graph before the source is scraped. A guardlink hypothesis with no route takes the code graph’s route for its own handler when a graph is loaded, and the decorator scrape near the annotation no longer runs when a graph is loaded or when guardlink marked the result’s route ambiguous. Without either, the scrape remains the last resort.
-
cxg pentest runtolerates a richer guardlink SARIF.guardlink/parse-errorresults are skipped likeguardlink/dangling-refinstead of becoming a hypothesis read as mitigated. Aguardlink/boundary-claimresult is read as a trust boundary to verify, never as an exposure, and the run prints a[1h]line counting them. A hypothesis whose result carries a guardlink claim key is named by it, so its id is stable when guardlink reorders results; without one the positional id is unchanged in the first run and scoped by run (gl-r1-0-…) in later runs. -
--only-routesaccepts every graph answer verbatim. Multi-method routes (GET,POST /<int:id>/update) and anonymous handler ids (file.rb::<module>/<anon:get#0>) used to refuse the whole file; they now parse, and a multi-method route matches each of its methods. -
A vulnerability class guessed from a URL’s shape no longer earns ranking weight. With a goal, a discovered route whose class was inferred from its path alone ranks below every annotated threat and every hypothesis with code graph reach, takes no class-match bonus, and does not double its reach for the sink class its guessed class would land in.
-
cxg pentestreads@flowsto the verb’s definition. The reader now accepts exactly the forms guardlink’s grammar accepts and refuses the rest, so an annotation means the same thing to both tools. Newly read: a flow with novia(recorded as not chainable, with the reason, instead of dropped), a dotted or repository-qualified target (#billing.charge), bare and dotted endpoints such as guardlink’s own exampleapi.auth -> db.users via TLS 1.3, quoted endpoints, multi-word mechanisms, multi-hop chains (A -> B -> C, one flow per hop), and a-- "..."continuation line extending a flow’s description. A route mechanism keeps its method and full path:via GET./orders/<id>is GET/orders/<id>where cxg used to keep the channelGET.. No longer read, because guardlink rejects them: an unspaced arrow (#a->#b), a hyphen or leading digit in a bare endpoint (user-agent,3rdparty), and a flow whose description is followed by more text. A mechanism followed by a trailing comment now carries it, as guardlink records it (redis # noqa), so the artifact name a chain is keyed on can change for such a line.
Fixed
-
An unmodelled guardlink SARIF rule is no longer read as a mitigated exposure. A
guardlink/*result whose rule cxg does not model — aguardlink/agent-reachtarget from the pentest profile, or a rule a newer guardlink adds — used to fall through to a “be conservative, assume mitigated” branch and become a hypothesis asserted safe: a probe slot spent on a non-finding and a clean bill cxg never earned. On guardlink’s own support-desk pentest export that was 14 fabricated mitigated hypotheses beside the one real exposure. Such a result is now skipped and counted, andcxg pentest runprints what it declined to read (skipped N result(s) … none assumed mitigated).guardlink/mitigated-exposureis handled explicitly as a covered exposure that names its covering@mitigates/@acceptscontrol from the result’ssuppressions, instead of reaching the mitigated flag by accident. Results from non-guardlink tools, and guardlink’s hyphen-prefixed extended schema, are unchanged. -
Go templates that import third-party packages now compile. cxg built a Go template with
go build <file>and never resolved its imports, so a template importing anything outside the standard library failed with “no required module provides package …” —cxg scan --templates grpc-reflection-abuseamong them — unless the operator first wrote ago.modand rango getby hand. A template that imports a non-stdlib package and is not inside a Go module is now built in a private module at~/.cert-x-gen/cache/go-modules/<stem>-<sha256>/(honouringCERT_X_GEN_HOME): cxg copies the template there, generatesgo.mod, runsgo mod tidyand builds. The entry is keyed by the template’s content, so an unchanged template reuses its binary offline, and it is renamed into place only after a successful build. The operator’s Go environment (GOPATH,GOMODCACHE,GOCACHE,GOFLAGS,GOPROXY,GOTOOLCHAIN) is inherited; with downloads disabled or unreachable the run fails fast aserrored, naming the imports and how to make them available.The build no longer spends the probe’s
--timeout: templates gain an optionalTemplate::preparephase, which the executor runs first under its own budget (300s, or--timeoutif larger), and the Go engine compiles there. A cold first build ofgrpc-reflection-abusetakes ~30s on an empty Go cache and previously read astimed-outat the default 30s. Go build subprocesses are now killed when their budget expires instead of outliving it.Stdlib-only templates and templates inside a module build as before, except that the build now runs in the template’s own directory, so an enclosing module is the one Go uses rather than whatever module cxg was launched from.
Security
-
Dependency advisories addressed.
cryptographyis bumped49.0.0→50.0.0inpentest/requirements.txt(GHSA-g6cj-pr64-35w5), andrustls0.23.41→0.23.45(GHSA-2mjx-qc3c-rqvc), which carriesaws-lc-rs,aws-lc-sysandrustls-webpkiforward with it. cxg does not terminate TLS as a server, so the rustls advisory does not describe a code path cxg exercises; the bump keeps the tree current regardless. -
Known open advisories, carried deliberately. Two transitive advisories are left for a later release because resolving them is not a version bump:
idna(reachable through the DNS stack, which needs thetrust-dns→hickorymigration to move off the affected line) andrmcp(whose fix is the2.xmajor, an API break). Both are named here so a reader of this release knows they are unaddressed rather than unnoticed.
Documentation and infrastructure
- Security-contact and crate-homepage metadata, pull-request CI spend, and the vendored guardlink
@flowsconformance corpus were updated since 1.4.0; none change runtime behaviour.
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.
1.6.1
Fixed
-
cxg updatefailed on Homebrew installs withUpdate failed: IoError: No such file or directory (os error 2)at “Replacing binary file…”. Homebrew linksbin/cxg -> ../Cellar/cxg/<version>/bin/cxg, and the replacement step resolved that relative link target against the current working directory rather than the link’s own directory, so it failed from everywhere exceptbin/itself. macOS reports the symlink as the running executable, so that is where it showed; a plain-file install was not affected. The replacement now follows the link to an absolute path.1.5.0 and 1.6.0 still run their own updater, so
cxg updateon those releases cannot pick up this fix. Upgrade once through your package manager (brew upgrade cxg,cargo install cert-x-gen --force, or pulling the new image withdocker pull ghcr.io/bugb-technologies/cert-x-gen:latest) or with a fresh download from the releases page.
Changed
cxg updateno longer replaces a binary that a package manager owns. A cxg in a Homebrew Cellar, in cargo’sbindirectory, or inside a container prints the command that upgrades it through its manager (brew upgrade cxg,cargo install cert-x-gen --force,docker pull …) and exits with status 3.--forcereplaces the file anyway.cxg updateverifies the downloaded binary against the release’sSHA256SUMSbefore replacing anything, and refuses a release without one.cxg updateno longer installs or refreshes detection templates on the way.
1.7.0
Upgrading
After upgrading an existing installation, run cxg pentest install --force. This
release changes the Python pentest pipeline embedded in the binary. Replacing the binary
alone does not replace the materialized files under ~/.cert-x-gen/pentest/; the explicit
install refreshes them before your next run. The automatic freshness check introduced in
1.6.0 also refreshes ordinary embedded installations on their first pentest action, but
source-checkout installations and CXG_SOURCE overrides keep their selected source. See
the pipeline upgrade guide for source
installations, backups and dependency setup. The pipeline adds the pinned h2 Python
dependency for HTTP/2 race transport; without it, races use the HTTP/1.1 fallback.
Report consumers must handle explicit proof and coverage outcomes. Findings now include
model_vuln_class, triage, triage_reason, reason_kind and proof_status. Reports add
inconclusive_refusal, not_run and, on completed JavaScript runs, mutation_outcome.
A refusal without a successful entitled control is no longer a verified mitigation.
proof_status is one of proven, unverified or unsupported; unsupported checks may
have sent requests without having an oracle able to prove the class. An empty confirmed
findings list is not evidence that every check ran or every control held.
Added
More vulnerability classes and engine-owned proof
- User enumeration, IP-header bypass and business-logic checks now have canonical class names, generation guidance, validation and engine-owned proof oracles. Enumeration compares repeated known-account and absent-account responses; IP-header bypass compares a refused baseline with a permitted spoofed-header request; business-logic proof reads back a server-side invariant through a distinct observer identity.
- Response-observable and in-band proof oracles for server-side template injection,
command injection, SSRF, XXE, path traversal, open redirects, credentialed CORS and mass
assignment.
cxg.oraclechecks engine-observed computed markers, content, redirect destinations, browser-readable responses or persisted changes, with class-specific controls. Reflection and template-authored verdicts cannot substitute for those observations. - Boolean-blind SQL injection proof through
cxg.sqli.boolean, complementing the existing timing and extraction oracles with repeated true/false response comparisons and controls. - A built-in, pollable OAST listener through
--oast-listener, for targets that can reach the operator but have no internet egress. Bind to the Docker bridge, Docker Desktop host or an explicit address; optionally add DNS with--oast-listener-dns. SSRF redirect staging supports 302/307 responses and configurable destinations, with redirect visits retained in evidence. DNS rebinding support answers successive A queries with configured addresses and TTL zero. Staging a redirect alone never confirms a vulnerability.
Authentication and multi-identity probes
- Mail, TOTP and operator input primitives:
cxg.mail.latestreads matching messages over IMAP,cxg.totpgenerates codes from private per-identity seed slots, andcxg.askwaits for an operator answer through a bounded file exchange. Configure mail and questions with--auth-inputs; templates declare themail,totpandaskcapabilities. Seeds stay outside the page, and missing inputs are explicit errors or scheduling skips. - Named identity requirements let templates select more than two captured profiles using
// @requires_identities:(a role-to-profile mapping).cxg.pageAs(idx)drives another loaded identity’s DOM in its own browser context. DOM XSS probes support POST navigation andcxg.page.watchXssobserves execution across navigation and interactions without reloading the page. - Wire-learned auth material records credentials from the target’s own traffic rather than relying only on preselected storage keys, improving bearer-token and credential discovery.
Transport reach and reproductions
- Web TLS, proxy and mutual TLS configuration:
--insecure-tls,--proxy,--client-certand--client-keyapply to browser contexts, raw HTTP and profile inspection. Navigation to a dead target is rejected instead of continuing on an unusable page. - Single-connection raw socket scripts through
cxg.socket.exchange, with ordered send, delimiter-read and timed-read operations for protocols requiring multi-step exchanges. The existing--allow-raw-socketand scope gates still apply. - Scripted WebSocket exchanges support subprotocols, ordered send/expect operations and
binary frames.
cxg.attacker.wsopens a WebSocket from the foreign attacker origin for cross-site WebSocket hijacking probes. - Opt-in HTTP captures:
--capture-httpwrites redacted per-templatetraffic.harandrepro.curlfiles for web JavaScript probes. Confirmed findings carry an endpoint-selected HAR slice and curl reproductions underevidence._cxg_http. Captures redact credentials; reproductions may need replacement credentials and replay individual requests. - Operator guidance and Crush support:
--skills-fileappends authoring guidance to generation and mutation prompts as untrusted advice.--ai-provider crushexplicitly selects the Crush CLI; repository configuration requires--trust-repo-configor its environment equivalent. Auto provider selection is unchanged.
Changed
- Refutation requires an observed control. A successful entitled identity and a distinct
refused attacker identity must perform the same request in the same dispatch before it can
enter
mitigation_verifications. Missing controls, configuration refusals and Tauri refusals are recorded asinconclusive_refusal; transport errors and missing capabilities cannot establish that a control held.not_runrecords why generation or execution was unavailable, and mutation outcomes distinguish resolved, still ambiguous, missing rewrite and no-verdict results. - Cross-identity proof is tied to observed responses. IDOR and related authorization checks require distinct routed identities and an identifier observed in both response bodies. Credential-substitution proof requires engine-observed credential identifiers. Binary raw response bodies are preserved so non-text downloads can participate in overlap checks.
- Race proof uses coordinated transport and independent readback. HTTP/2 races flush the terminating frames together on one connection; HTTP/1.1 uses last-byte synchronization. Dispatch timing alone cannot prove a race: the engine must read back the violated invariant.
- Destructive proof can run on signed disposable remote targets.
--destructive-okstill requires a disposable target; non-loopback staging hosts may now qualify through signeddisposable_host_grantsin the scope file. Brute-force proof also enforces the configuredbrute_force_min_attemptsfloor. A scope-file declaration without a valid signature cannot authorize destructive probes on a remote host. - Capability requirements can be combined.
// @requires_capability:accepts multiple capabilities, and scheduling requires all of them. Generation prompts describe the engine’s actual proof contracts and supported class vocabulary; generated probes retain their hypothesis class, with a model’s different class retained separately asmodel_vuln_class.
Fixed
- WAF, bot-challenge and rate-limit responses no longer imply verified application controls.
HTTP interference is recorded in engine evidence and produces inconclusive outcomes. HTTP
requests share pacing and 429 backoff across identities, honor
Retry-After, and group opaque identifier path segments under the same endpoint budget.request_interval_secondsin the scope file controls minimum spacing; coordinated race batches remain atomic. - CSRF probes originate from a different site, preserving real SameSite behavior, and capture the form response for engine-observed proof instead of treating submission alone as success.
- Mutation retries use the available AI provider chain and retain terminal generation failures in coverage reporting rather than silently dropping unresolved probes.
1.8.0
Upgrading
After upgrading an existing installation, run cxg pentest install --force. The
embedded Python pentest pipeline changes in this release, and replacing the binary alone
does not replace the files under ~/.cert-x-gen/pentest/. The pinned h2 dependency moves
to 4.4.1, which drops Python 3.9.
Plain cxg scan now runs supplied JS probes. A directory or file that holds JS probe
contracts is run through the pentest engine with zero model calls, alongside scanner
templates. The combined JSON report keeps a template’s own verdict apart from the engine’s
adjudicated verdict. --no-author is accepted on plain scan. It requires supplied probes,
skips ranking and generation, and records zero model calls. Missing, empty or wholly invalid
inputs are refused instead of generated.
Report consumers:
- Scanner summaries split declared and inferred verdicts; engine-adjudicated rows keep their own count.
- When subprocess traffic makes the total unknown,
network_requests_measuredcarries the observed part andnetwork_requestsis null. - Discovery outcomes (skipped helpers, YAML load errors) are kept, and an all-invalid directory still writes a report.
Templates without a capability header are no longer rejected. The required
capabilities are derived from the namespaces a template uses, with a warning. Unsupported
capabilities are still skipped, and raw fetch and ipcRenderer bypasses are still rejected.
Added
cxg scan --pentestis a front door to the pentest engine. It accepts everypentest runoption through shared argument definitions, and refuses scan options that don’t apply.- Opt-in scan CI gates:
--fail-on confirmed,errored,timed-out(repeatable or comma-separated) exits 2 when a run reaches a listed status. The default exit behaviour is unchanged. - Engine proof for unauthenticated protected reads. A declared protected GET reads as:
- confirmed when guest and authenticated responses match;
- refuted when the authenticated read returns content and the guest gets 401, 403 or a login redirect;
- inconclusive otherwise.
This covers
auth_api,missing_authentication(aliasmissing-authn) and protected metrics reads. The guest is a fresh context with no credentials.
- Engine refutation for authorization regressions. In the same dispatch, an entitled 2xx plus a distinct attacker denial for the same method-qualified endpoint (such as
GET /tasks) can be refuted. Missing, redirected or interfering controls read asinconclusive_refusal. - Fired-oracle routing. When a finding’s declared class can’t prove it, the engine routes through exactly one proven, request-bound oracle and keeps the original claim as provenance. Injection and file-inclusion aliases resolve before proof lookup. Forged stamps and ambiguous sibling matches can’t promote a finding.
--auth-dirfor auth capture and listing, as well as import and verify.CERT_X_GEN_HOMEis honoured for Python state.
Changed
- Every engine HTTP request is audited: landing, inspection, health, reauthentication and identity checks, including redirects. Each audit row records the
actorandpurpose. - A reserved
anonymousrole binds to a separate clean guest. A credentialed saved profile namedanonymousnever stands in for it. - Python helper bytecode writes are disabled during scans.
- Pull-request CI is two jobs: Rust (fmt, clippy, tests) and Python (pytest). Windows, Python 3.12, macOS and build jobs run on main and tags.
Fixed
- Malformed HTTP probe calls, such as
cxg.fetch({method, path}), are rejected as authoring errors. Load-time checks catch literal mistakes; runtime checks reject computed arguments before scope accounting or network dispatch and record the template as rejected. The loopback regression tests now declare their pinned aiohttp dependency. - HTTP argument and scope checks preserve empty paths, target URL prefixes, initial in-scope URL authentication, and ordinary JavaScript writers and aliases of engine primitives. URL credentials are removed on cross-origin raw redirects, alongside identity headers and cookies.
- Pentest raw HTTP redirects now pass scope checks, request budgets, pacing, and
auditing at every hop, including redirected methods. Out-of-scope hops stop
before dispatch. Cross-origin hops discard identity headers and use a fresh
cookie jar;
maxRedirects: 0still returns the original redirect response. - An explicit pentest
method_allowlistnow refuses every method outside the list, including POST and arbitrary extension methods.--destructive-okno longer overrides an explicit list. Destructive path consent and the built-in defaults when no method list is declared retain their existing behavior. cxg.fetchandcxg.fetchAscheck the resolved destination host before sending requests. Probe validation rejects native network API references, aliases, dynamic imports, and script injection, directing authors to engine primitives. Source validation remains a backstop rather than a JavaScript sandbox; see the browser traffic limitations.- Captured auth storage-state files are written with mode 0600, and existing ones are tightened before re-capture.
- Raw HTTP redirects pass every scope check at every hop: budget, pacing, method and canonical path. An out-of-scope hop stops before dispatch.
- Directory scans don’t execute helpers, and don’t infer a refutation after a native transport failure. The shipped
{{BaseURL}}request form executes. - The crate compiles again after duplicate CLI and template declarations were removed.
1.9.0
Upgrading
After upgrading an existing installation, run cxg pentest install --force. The
embedded Python pentest pipeline changes in this release, and replacing the binary alone
does not replace the files under ~/.cert-x-gen/pentest/.
Session liveness is now an authenticated API check, not a landing page. Capture,
cxg pentest auth verify, scan pre-flight and runtime health all call one API endpoint
on each profile’s own service. It defaults to /api/me and expects a 2xx; 401 and 403
always mean dead. If your application has no /api/me, its sessions now read as
unverified: configure a real authenticated endpoint with --me-path, or per profile
with auth import --liveness-path. --skip-health-check now skips only periodic
health checks and re-authentication. It no longer bypasses the startup API check. See
API session liveness and multiple services.
Request paths resolve at the service origin. fetch, fetchAs, raw, rawAs and
cxg.url no longer inherit a path from a landing --target such as
https://app.example/dashboard. The landing URL is still used for browser navigation.
Templates that relied on the implicit prefix must name their API prefix explicitly.
Report consumers:
report.jsonand the audit footer carryprofile_liveness(profile, service, origin, alive, status code, reason) andserviceswithready/unavailablestatus.- Exit 5 means a selected profile or service is unavailable or unverified. Probes for ready services still run, but the report is
complete: false,status: incomplete. - Scope and transport failures are recorded in
request_failuresand make the run incomplete with exit 4, even when a probe returns no findings.
Added
-
Engine-owned excluded-records oracle (
cxg.oracle.excludedRecords). It can refute a correct row-filtering fix. Such a fix keeps answering 200, so the refusal-control rule had nothing to observe and the fixed state stayed inconclusive. The engine issues three read-only GETs, each with its identity’s own credentials: the subject list as the attacker, the attacker’s own scoped list, and a reference list as a different identity. It compares records by key:- confirmed when a subject record outside the attacker’s list carries a reference value;
- refuted (proven) when the subject is non-empty and wholly inside the attacker’s list, the reference is non-empty, and both sessions were proven alive in the same run;
- inconclusive otherwise, naming the cause.
The verdict binds to the finding’s endpoint and applies only to cross-identity classes. It never overturns a proven confirmation and cannot be forged from template evidence. Generation prompt v8 documents it.
-
Per-profile service and liveness settings on
cxg pentest auth import:--service,--liveness-pathand repeatable--liveness-status. Captures and imports save them asliveness_check: {path, expected_status}, and existingliveness_pathmetadata still loads. -
Multi-service runs. Each profile opens its own service. Cross-origin
cxg.fetchAsuses that identity’s API request context, so a second service no longer fails on CORS. Scope, budgets, redirects and audit still apply at every hop.
Changed
- A denial verdict needs proof that both sessions were alive. Attacker and control liveness must come from the same run and service. Otherwise the result is
inconclusive_refusal, naming the unverified profiles. An expired session can no longer be recorded as a verified mitigation. - One unavailable profile no longer cancels the run. Profiles keep their roster indices, only the probes that need an unavailable profile are skipped, and other services continue.
- When an oracle observation cannot bind to a finding, triage names the measured request and the claimed endpoint. It no longer reports that the oracle saw no signal.
Fixed
- Oracle proofs bind to findings on dynamic paths such as
GET /users/{username}. Every SQLi and class-oracle router keeps the original request URL beside the substituted one. Binding accepts{param},:param,<param>and<type:param>, but a parameter never spans more than one segment. Method, origin, query and sibling-uniqueness checks are unchanged. - A public landing page can no longer make an expired bearer session look alive. Redirects, HTML fallbacks and missing endpoints do not count as liveness.
- The HTTP/2 race transport keeps reading responses already queued by a closing peer when an acknowledgment write fails. Previously those responses could be lost as all-zero statuses.
1.9.1
Upgrading
After upgrading an existing installation, run cxg pentest install --force. The fix
below is in the embedded Python pentest pipeline, and replacing the binary alone does not
replace the files under ~/.cert-x-gen/pentest/.
Fixed
cxg.oracle.excludedRecordsverdicts bind when the scope has a path. With a landing scope such as--scope http://host/dashboard, the oracle measured/api/xat the service origin while the finding claimed/dashboard/api/x, so a correct row-filtering fix came backinconclusive_refusal(unverified) instead of refuted (proven), and a leak was not confirmed by the oracle. The claim is now resolved at the service origin, the way the oracle’s requests are, through bothcxg scanandcxg pentest run. The other class oracles build their requests from the full--target, so their claims already bound and are unchanged.cxg pentest run --helpdescribed 1.8.0 session behaviour. It said a dead session only warns without--ciand that--skip-health-checkforce-marks profiles alive. Since 1.9.0 an expired profile exits 5 with or without either flag, and probes for ready services still run. The--ci,--skip-health-checkand exit-code 5 help now say so, and--cireads as what it still does: refuse a world-accessible--auth-dir.
[1.9.2] Latest
Upgrading
After upgrading an existing installation, run cxg pentest install --force. These fixes
are in the embedded Python pentest pipeline. cxg scan refreshes it on first use.
Fixed
- A profile is no longer unverified, and the run no longer exits 5, because the app has no
JSON
/api/me. When no liveness endpoint is configured and/api/meanswers 404, HTML, a redirect or nothing, the 1.8.0 landing test decides; a configured endpoint, or an/api/meanswering 401/403, still decides as in 1.9.x. Remaining 1.8.0 hole: an app with no API liveness endpoint, a public landing page and an expired bearer reads as alive. - A supplied-probe replay drops
--authnames with no loadable profile, as 1.8.0 did, so one missing profile no longer makes every kit, including anonymous ones, exit 5. - Identity traffic and liveness go to the
--scopetarget again. A profile’s saved--targetorigin is used only for a profile imported with--service; 1.9.x sent a stale profile’s requests to another port while the verdict was recorded against the scope. - Request helpers keep the
--scopepath prefix again, socxg.fetch/raw/urlandcxg.page.probeXssagree under a scope such ashttp://host/app/and an XSS that 1.8.0 confirmed confirms.cxg.oracle.excludedRecordsstill resolves at the origin. - A complete run reports
status: "ok", not"complete", so a consumer that treats any status other thanokas a caveat no longer reports one;incompleteis unchanged. - A blocked or failed request no longer changes the exit code to 4. It is still recorded
in
request_failuresand makes the runstatus: incomplete.

