Skip to content

All versions since 1.7.0

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.oracle checks 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.latest reads matching messages over IMAP, cxg.totp generates codes from private per-identity seed slots, and cxg.ask waits for an operator answer through a bounded file exchange. Configure mail and questions with --auth-inputs; templates declare the mail, totp and ask capabilities. 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 and cxg.page.watchXss observes 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-cert and --client-key apply 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-socket and scope gates still apply.
  • Scripted WebSocket exchanges support subprotocols, ordered send/expect operations and binary frames. cxg.attacker.ws opens a WebSocket from the foreign attacker origin for cross-site WebSocket hijacking probes.
  • Opt-in HTTP captures: --capture-http writes redacted per-template traffic.har and repro.curl files for web JavaScript probes. Confirmed findings carry an endpoint-selected HAR slice and curl reproductions under evidence._cxg_http. Captures redact credentials; reproductions may need replacement credentials and replay individual requests.
  • Operator guidance and Crush support: --skills-file appends authoring guidance to generation and mutation prompts as untrusted advice. --ai-provider crush explicitly selects the Crush CLI; repository configuration requires --trust-repo-config or 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 as inconclusive_refusal; transport errors and missing capabilities cannot establish that a control held. not_run records 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-ok still requires a disposable target; non-loopback staging hosts may now qualify through signed disposable_host_grants in the scope file. Brute-force proof also enforces the configured brute_force_min_attempts floor. 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 as model_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_seconds in 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_measured carries the observed part and network_requests is 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 --pentest is a front door to the pentest engine. It accepts every pentest run option 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 (alias missing-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 as inconclusive_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-dir for auth capture and listing, as well as import and verify. CERT_X_GEN_HOME is 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 actor and purpose.
  • A reserved anonymous role binds to a separate clean guest. A credentialed saved profile named anonymous never 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: 0 still returns the original redirect response.
  • An explicit pentest method_allowlist now refuses every method outside the list, including POST and arbitrary extension methods. --destructive-ok no longer overrides an explicit list. Destructive path consent and the built-in defaults when no method list is declared retain their existing behavior.
  • cxg.fetch and cxg.fetchAs check 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.json and the audit footer carry profile_liveness (profile, service, origin, alive, status code, reason) and services with ready/unavailable status.
  • 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_failures and 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-path and repeatable --liveness-status. Captures and imports save them as liveness_check: {path, expected_status}, and existing liveness_path metadata still loads.

  • Multi-service runs. Each profile opens its own service. Cross-origin cxg.fetchAs uses 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.excludedRecords verdicts bind when the scope has a path. With a landing scope such as --scope http://host/dashboard, the oracle measured /api/x at the service origin while the finding claimed /dashboard/api/x, so a correct row-filtering fix came back inconclusive_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 both cxg scan and cxg pentest run. The other class oracles build their requests from the full --target, so their claims already bound and are unchanged.
  • cxg pentest run --help described 1.8.0 session behaviour. It said a dead session only warns without --ci and that --skip-health-check force-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-check and exit-code 5 help now say so, and --ci reads 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/me answers 404, HTML, a redirect or nothing, the 1.8.0 landing test decides; a configured endpoint, or an /api/me answering 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 --auth names 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 --scope target again. A profile’s saved --target origin 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 --scope path prefix again, so cxg.fetch/raw/url and cxg.page.probeXss agree under a scope such as http://host/app/ and an XSS that 1.8.0 confirmed confirms. cxg.oracle.excludedRecords still resolves at the origin.
  • A complete run reports status: "ok", not "complete", so a consumer that treats any status other than ok as a caveat no longer reports one; incomplete is unchanged.
  • A blocked or failed request no longer changes the exit code to 4. It is still recorded in request_failures and makes the run status: incomplete.