Skip to content

Cert-X-Gen

Cert-X-Gen is a security scanner that keeps the evidence behind every finding. Start a target you control, scan it, and read what it saw:

Terminal window
mkdir -p cxg-demo/data && cd cxg-demo
echo 'customer-export.csv placeholder' > data/customer-export.csv
python3 -m http.server 8899 --bind 127.0.0.1
Terminal window
# in a second terminal
cxg scan --scope http://127.0.0.1:8899 --templates directory-listing-common-paths
Findings by Severity:
CRITICAL: 0
HIGH: 0
MEDIUM: 1
LOW: 0
INFO: 0
TOTAL: 1

Truncated to the severity block. The run also prints a scan id, a duration, and the target and template counts.

MEDIUM: 1 is the finding. scan-results.json is why you can act on it: it holds the request that triggered the finding, the whole response body cxg matched against, and which conditions fired.

{
"severity": "medium",
"confidence": 85,
"title": "Directory Listing Exposure (Common Paths)",
"evidence": {
"request": "GET http://127.0.0.1:8899/data/\n",
"response": "<!DOCTYPE HTML>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>Directory listing for /data/</title>\n</head>\n<body>\n<h1>Directory listing for /data/</h1>\n<hr>\n<ul>\n<li><a href=\"customer-export.csv\">customer-export.csv</a></li>\n</ul>\n<hr>\n</body>\n</html>\n",
"matched_patterns": [
"status:200",
"Directory listing for"
],

Keeping the whole response body is what makes a finding auditable weeks later. You read what the scanner saw, rather than trusting that it matched something.

  • Apache-2.0 licensed. Free to use, including commercially. LICENSE.
  • One binary, no runtime. macOS, Linux, and Windows, on x86-64 and ARM64. Install cxg covers four ways to get it, including a Docker image that needs nothing installed at all.
  • Checks ship separately from the engine. Templates are an Apache-2.0 repository of their own, fetched with one command, so the catalogue grows without you upgrading the scanner. The template catalog is what that gets you today. It takes contributions, and a check you write is the same kind of artifact as one that ships.
  • A template can be a program. YAML for the straightforward checks, and Python, JavaScript, Rust, Go, C, C++, Java, Ruby, Perl, PHP, or Shell when a check has to compute or chain requests.
  • Templates run as you, with no sandbox. That is a real cost and it is covered in the template trust model.

Read your first scan runs the scan above and reads back every part of it. Each finding carries these fields:

Field What it holds
severity, confidence How serious the template’s author judged it, and how sure the check is
title, description What was found, in the template author’s words
evidence.request The exact request that triggered it
evidence.response The full response body cxg matched against
evidence.matched_patterns Which conditions fired
cwe_ids, cve_ids, cvss_score Set when the template provides them
remediation How to fix it, when the template says

Results go to scan-results.json by default, and one run can write JSON, SARIF, CSV, HTML, and Markdown at the same time, so the same scan feeds a pipeline and a person.

Most checks are straightforward: send a request, look for something in the response. YAML describes those well, and a YAML template stays readable to anyone on your team.

Some checks need to do more than match text. Cert-X-Gen lets a template be an ordinary program instead. A template written as a program can:

  • Choose its next request based on what the last response said
  • Calculate something, such as whether session tokens are genuinely random
  • Verify a signature or read a file format
  • Hold a finding back until every step has confirmed it

Take an exposed .git directory. A template can fetch /.git/HEAD, read which branch it points at, fetch that branch, and check that it resolves to a real commit. Three requests, each one deciding the next. If any step fails the template stays quiet, so what you get is a confirmed finding rather than a maybe.

Write your first template builds that check step by step, and why polyglot templates covers when the extra power is worth its cost, because a code template needs its language installed wherever the scan runs.

Cert-X-Gen has scanner templates and engine-adjudicated JS probes. Plain cxg scan can run a mixed supplied pack with zero model calls. Explicit cxg scan --pentest and cxg pentest run reach the same source-aware engine, with authoring available when requested.

flowchart TB
    subgraph SCAN["cxg scan"]
        direction LR
        A["a target you can reach"] --> C(["run every template<br/>that applies"])
        B["templates"] --> C
        C --> D["findings, each with the<br/>request and response"]
    end

    subgraph PENTEST["cxg pentest"]
        direction LR
        E["a running app"] --> G(["write probes,<br/>then try to confirm them"])
        F["its source, and a guardlink<br/>threat model"] --> G
        G --> H["a verdict for each<br/>suspected exposure"]
    end

    SCAN ~~~ PENTEST

    class D,H emphasis
What you are doing Reach for Why
Sweeping web applications and services for known issues cxg scan Select templates by tag, severity, or exact ID
Scanning hosts and networks cxg scan --scope takes hosts, domains, URLs, and CIDR ranges
Testing an application whose source you have cxg pentest Starts from exposures a developer marked in the code, not from guesswork
Testing an Electron desktop app cxg pentest --target-type electron Drives the app over the Chrome DevTools Protocol and probes its IPC channels
Testing a Tauri desktop app cxg pentest --target-type tauri Maps the IPC commands and capability grants against the threat model, and can prove commands in process
Testing a command-line tool cxg scan --scope cli:// Runs the binary with hostile arguments, files and environment, and reads what it does
Confirming blind SSRF or injection --oast-interactsh cxg owns the callback host and polls it, so a hit is proof rather than a lead
Gating a build Exit codes and --ci An expired session fails the job loudly instead of scanning logged out
Writing a check nothing else can express cxg template The check is a program, so it can parse, compute, and chain requests

Desktop applications use the pentest engine, through cxg pentest run or cxg scan --pentest. The two frameworks are tested differently. An Electron app is driven live over CDP. A Tauri app exposes no CDP endpoint on macOS or Linux, so cxg maps its IPC surface from source and, with --tauri-prove, drives its commands in a headless test harness built from the app’s own crate. A Tauri run never drives a live webview.

Three things surprise people. Each one is covered in full elsewhere.

Write a check in code

Build the .git detection above in Python, validate it, and run it through the engine.

Write your first template

Run a whitebox pentest

Turn a guardlink threat model into probes, and let cxg try to confirm or rule out each one against a running app.

Run a pentest

Look up a flag

Every command, flag, and default, generated from the binary’s own --help.

CLI reference

See what it can find

Every shipped check, by category, severity, target kind, or the weakness it looks for, with the long-form case behind the differentiated ones.

Template catalog · Playbooks

These docs describe Cert-X-Gen 1.9.2, released 2026-11-17. The generated reference runs the checksum-verified release asset; crates.io also publishes 1.9.2. Installation transcripts retain their stated verification dates.

After upgrading an existing install, run cxg pentest install --force. Refresh the pipeline before your next run. 1.9.1 and 1.9.2 both change the pipeline.

1.9.2 walks back three 1.9.0 changes that broke working setups. Each was re-run against 1.9.2 for these pages:

  • An app with no /api/me is no longer unverified. With no liveness path configured, a /api/me that answers 404, HTML or a redirect falls back to the landing-page test. A configured path, or a /api/me that answers 401 or 403, still decides. See tell cxg which endpoint proves a session.
  • Identity traffic goes to --scope. A profile’s saved --target is used only when it was imported with --service.
  • Request helpers keep the scope’s path. Under --scope http://127.0.0.1:8934/dashboard, cxg.fetch('/api/profile') went to /dashboard/api/profile again. Templates need not name the prefix. See paths keep the scope’s prefix.

A complete run’s report.json now says "status": "ok", not "complete"; incomplete is unchanged. A dead profile still makes the run incomplete with exit 5, with or without --ci.

1.9.1 fixed two things that 1.9.2 keeps:

  • An excluded-records verdict binds when --scope has a path. On 1.9.0 a correct row-filtering fix replayed against --scope http://127.0.0.1:8933/dashboard came back INCONCLUSIVE_REFUSAL; on 1.9.1 and 1.9.2 it is REFUTED. See A filtered list needs a record comparison.
  • cxg pentest run --help describes the session gate. --skip-health-check does not skip the startup check, and --ci refuses a world-accessible --auth-dir.

Still in place from 1.9.0:

  • A row-filtering fix can be refuted. The engine-owned excluded-records oracle compares the records a list returns, so a fix that still answers 200 is not stuck at inconclusive.
  • Read proof and coverage separately. Engine-owned proof, proof_status, inconclusive refusals and not_run reasons keep an empty confirmed list from looking like complete clean coverage. See Proof and coverage outcomes.

The changelog carries the full 1.9.2, 1.9.1 and 1.9.0 release notes. OAuth, OIDC and SAML confirmation remains unavailable. A request sent is not, by itself, proof of a vulnerability or of a working mitigation.

Engine
Bugb-Technologies/cert-x-gen, Apache-2.0
Templates
Bugb-Technologies/cert-x-gen-templates, Apache-2.0
Changelog
Every release, with the diff between any two
Release
v1.9.2