CVE matching, MITRE ATT&CK technique annotations, and composite risk scoring — with a finding-suppression workflow to cut false positives from your report. Then send the result: one command renders a finished scan into a self-contained, print-ready HTML report that opens with no external network reference.
A scan ends with a directory of artifacts. An engagement ends with something a client reads.
nsauditor-ai report closes that gap: point it at a finished run and it renders an
executive HTML report — one self-contained, print-ready file that
opens with no external network reference of any kind. It survives an email
attachment, a laptop with no connectivity, and a reviewer’s locked-down browser.
Add --brand when the report goes out under your own name and the cover page carries it.
--format jira writes a Jira-importer CSV instead, so a findings list
becomes a backlog. ⚠️ That CSV is written for Jira’s own CSV importer — the field
mapping is done inside Jira, and this is not a live-instance integration we have verified.
A report that quietly skips a container reads exactly like a report that had nothing to skip. So every report carries a container census: where finding-like records sit in a place the report does not read, that place is named and counted on the page. Silence is disclosed — never rendered as absence.
report is a Pro capability and is included in Enterprise. It produces no PDF: the
HTML is print-ready, and your browser prints it when a PDF is what the client asked for.
# 1 · a normal scan, as always nsauditor-ai scan --host 192.168.1.0/24 --plugins all # 2 · turn that finished run into the document you send nsauditor-ai report --from out/192.168.1.0_<timestamp> --format executive # or the same run as a Jira-importer CSV — you map the fields in Jira nsauditor-ai report --from out/192.168.1.0_<timestamp> --format jira
Requires nsauditor-ai v0.2.49+ alongside your Pro or Enterprise licence. The report reads a run that
already finished — it never re-scans, and it never reaches the network to render.
Version-based CVE matching is just the start. Every finding is scored — CVSS weighted by verification status, with an uplift for findings carrying an initial-access technique — and the queue is then ordered exploit-first. Findings are emitted unverified — you adjudicate what stays, not the scanner.
A finding-suppression workflow lets you mark items accepted-risk or false-positive; suppressed findings drop out of the report and the risk rollup. Every decision is recorded per scan.
Severity ranks how bad a vulnerability would be if it were exploited. It cannot tell you whether anyone is exploiting it. Pro closes that gap at scan time: every finding carrying a CVE is joined by CVE ID against a local CISA KEV catalog and a local FIRST EPSS scores file, then banded and reordered exploit-first.
The justification travels with the finding — the KEV flag, the EPSS score with its percentile, the CVE ids that matched, and the store’s own as-of date. Your ranking is always something you can date and defend. Both catalogs are free, public and operator-supplied: point Pro at files you control and the join runs entirely on your machine.
Your existing riskScore does not move — exploitPriority is a new axis
beside it. And this is enrichment, not detection: it reorders what the scanner already found.
See Pro end to end — recorded on the 0.42 line:
The Pro overview covers exploit-first triage with CISA KEV and FIRST EPSS — free public feeds you download and point Pro at, failing closed when stale — CVE matching from detected service versions with fully offline support, the suppression workflow where findings are emitted unverified and you adjudicate, AI analysis on your own API keys, and risk-ranked reports built for one-click print to PDF.
# 1 · Download the feeds (public, no account needed for either) mkdir -p ~/.nsauditor/feeds curl -fsSL https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json -o ~/.nsauditor/feeds/kev.json curl -fsSL https://epss.empiricalsecurity.com/epss_scores-current.csv.gz | gunzip > ~/.nsauditor/feeds/epss.csv # 2 · Point the scanner at them (add both lines to your shell profile to persist) export NSAUDITOR_EXPLOIT_KEV_STORE=~/.nsauditor/feeds/kev.json export NSAUDITOR_EXPLOIT_EPSS_STORE=~/.nsauditor/feeds/epss.csv # 3 · Scan as usual — findings that carry CVEs arrive banded and ordered exploit-first nsauditor-ai scan --host 192.168.1.0/24 --plugins all
The stores are the feeds' own formats — no conversion step. Refresh KEV within 14 days and EPSS within 10 (a cron works);
a stale or unparseable store fails closed and the scan says so — it never silently reports
“not exploited”. Setting these outside a shell? ~ expands only in a shell —
in a --env file or Claude Desktop’s MCP env config, write the absolute path (e.g.
/Users/you/.nsauditor/feeds/kev.json); a path the scanner cannot read is reported as no-store, never as
“not exploited”. Full walk-through: getting-started → exploit intelligence.
Exploit intelligence is a Pro-tier capability and is off until you configure it. Enterprise includes Pro.
Pro sharpens the queue. Enterprise turns the result into something an assessor reads — 29 Enterprise plugins across AWS, Azure and GCP, and one read-only scan mapped to eight frameworks with an explicit out-of-scope column.
It is also where suppression stops being a filter and becomes a record. Pro’s finding-suppression workflow drops an accepted-risk item out of your report and its risk rollup. The Enterprise compliance engine takes the same decision and gives it an owner, a rationale, a date and an expiry inside the evidence pack — and as of EE 0.36.0 the report checks that approval’s signature against the key material the approver’s registry entry declares, rather than repeating what the record says about itself. A missing verdict reads not checked and never failed.
None of that is part of a Pro licence. If your buyer is an auditor rather than a remediation queue, that is the tier to look at.
CISA KEV + FIRST EPSS joined by CVE ID at scan time, banded KNOWN_EXPLOITED / ELEVATED / BASELINE, queue ordered exploit-first. Operator-supplied catalogs; the join runs locally. See how →
Auto-generated CPEs from detected services matched against the NVD feed — offline, no API calls. Know which CVEs affect each host before writing a single line of your report.
Every finding is annotated with the ATT&CK techniques it relates to, with kill-chain context. Compliance teams love it. Clients understand it. Takes zero extra effort on your part.
Five specialized agents run concurrently — Auth, Crypto, Config, Service, and Exposure. Each produces structured findings for its category, then feeds the risk engine.
CVSS weighted by verification status — VERIFIED 1.0×, UNVERIFIED 0.6×, suppressed 0.0× — with a 15% uplift for findings carrying an initial-access ATT&CK technique. Reports render severity-grouped, highest-impact first, and suppressed findings drop out of the rollup.
report --from <run> --format executive renders a finished scan into one self-contained, print-ready HTML file that opens with no external network reference — optional cover-page branding via --brand. --format jira writes a Jira-importer CSV. Every scan still writes HTML, JSON and Markdown as before. See how →
Same OpenAI / Claude / Ollama providers you use in CE — but Pro injects CVE matches, MITRE techniques, and risk scores into every prompt. Vastly better output.
Unlimited scan history in SQLite. CVE-level delta detection — new vulnerabilities since last scan, not just host diffs. Risk trend analysis (improving / degrading / stable).
Configurable profiles (strict / moderate / minimal), additional patterns for AWS keys, DB connection strings, and JWTs. Full redaction audit log for compliance.
The MCP server registers seven tools and lists all seven to every client; the licence gate is applied when a tool is called. Pro unlocks probe_service and get_vulnerabilities on top of the three every tier can run.
Agents run via Promise.allSettled — if one category has no relevant services, it's skipped. Results feed the risk engine.
report --from <run> → executive HTML or Jira-importer CSV
list_plugins completes the every-tier set;
scan_cloud and
get_findings are Enterprise. Seven tools in total — all seven are listed to every client, and the licence is checked when one is called.
Start the MCP server with nsauditor-ai-mcp — works with Claude Desktop, Cursor, and any MCP-compatible AI assistant.
# @nsasoft/nsauditor-ai-ee is a private (restricted) package. # Use the npm read-token delivered with your license email. npm config set //registry.npmjs.org/:_authToken npm_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Or, project-scoped, in an .npmrc file echo "//registry.npmjs.org/:_authToken=npm_xxxx..." >> ~/.npmrc
# One line — installs both the CE platform and the Pro package npm install -g nsauditor-ai @nsasoft/nsauditor-ai-ee
# The CE license installer verifies the JWT signature before persisting # and stores the key in macOS Keychain (or ~/.nsauditor/.env mode 0600 elsewhere). nsauditor-ai license install pro_eyJhbGciOiJFUzI1NiIs... ✓ Pro license installed Stored at: macOS Keychain (service=nsauditor-ai) Org: you@example.com Expires: 2027-04-29 # Verify nsauditor-ai license --status ✓ Pro license active
nsauditor-ai scan --host 192.168.1.0/24 --plugins all # View your AI report in browser open out/192.168.1.0_*/scan_response_ai.html # macOS xdg-open out/192.168.1.0_*/scan_response_ai.html # Linux # Each scan writes HTML, JSON, and Markdown reports — print the HTML to PDF for clients nsauditor-ai scan --host 10.0.0.0/24 --plugins all open out/10.0.0.0_*/scan_response_ai.html # print → PDF # And turn that finished run into the one file you send the client nsauditor-ai report --from out/10.0.0.0_<timestamp> --format executive
A scanner on an isolated network has a standing problem: the vulnerability data it matches against lives on the internet, and it does not. Enterprise ships a dependency-complete bundle carrying both editions, an install script and SHA-256 checksums — a restricted distribution — so the install and the CVE data can both be carried in.
The condition travels with this path and is part of the offer, not a footnote:
the bundle is a restricted distribution rather than a public
npm install. It is not architecture-restricted — the install
script is verified on native aarch64 as well as amd64, so an arm64 enclave is
covered by this path. The published container image is amd64 only; that is a
different delivery vehicle from this bundle.
No CVE, KEV or EPSS data ships with the product. You download the NVD feeds you want on a connected host, bundle them, and carry the archive across. Your own CISA KEV catalogue and FIRST EPSS scores can ride the same archive. Both fail closed when stale, so an out-of-date catalogue never reports “not exploited”.
⚠️ A carried bundle is integrity-checked, not authenticated. The recorded SHA-256 detects a file altered in transit, but it travels inside the archive it covers, so it cannot establish who built it.
The install, end to end. On a connected host, authenticate with the download token from your purchase email and fetch the bundle:
npm pack @nsasoft/nsauditor-ai-ee-airgap@0.44.0
tar xzf nsasoft-nsauditor-ai-ee-airgap-0.44.0.tgz
Carry the extracted directory to the isolated host and run its script. It verifies the carried checksums before installing anything, installs Community Edition first (Enterprise declares a peer dependency on it), and forces every install offline:
./install.sh
nsauditor-ai license --plugins
Then carry the vulnerability data, which is separate and never ships with the product:
# connected host
nsauditor-ai feed bundle --from ./nvd-downloads --out feeds.json.gz \
--kev ./known_exploited_vulnerabilities.json --epss ./epss_scores.csv.gz
# isolated host — imports the feeds you downloaded, from a bundle you carried; restricted distribution
nsauditor-ai feed import --file feeds.json.gz --extras-dir ./stores
export NSAUDITOR_OFFLINE_ONLY=1
nsauditor-ai scan --host aws --env ./org.env --compliance soc2 --out ./out
NSAUDITOR_OFFLINE_ONLY=1 refuses to start if an outbound path is also configured,
which rules out the opt-in RFC 3161 timestamping path inside the enclave. A host with no
sha256sum or shasum is refused rather than installed onto.
What is verified before the bundle ships. Every release re-builds it and runs a delivery
gate against those exact tarballs: all 44 declared production dependencies resolve from the carried
closure, 29 Enterprise plugins load, a store-backed scan returns findings from carried CVE data, and
the run makes zero network attempts. The gate never reads npm’s exit status —
every production dependency is an optionalDependency, so a NIC-down install of the
unvendored package exits 0 having installed almost nothing.
Verify the delivery yourself — not the installer. The installer’s exit code is the
one thing not to trust on an isolated host, and it is structural rather than a bug: every production
dependency is an optionalDependency, so npm skips an unfetchable one silently
and still exits 0. After install.sh, confirm what actually landed —
nsauditor-ai license --plugins must report the Enterprise plugins active, and a
require.resolve sweep of the declared production dependencies must reach 44 of 44
— the carrier shipped in EE 0.43.0 measured 44 of 44 at that release. The same sweep against the ordinary, non-bundled package on an isolated host reaches
0 of 44 — with npm still exiting 0. The full command is in the walkthrough.
# on a connected host — bundle the feeds you downloaded nsauditor-ai feed bundle --from ./nvd-downloads --out feeds.json.gz # carry it across, then on the isolated host ./install.sh # verifies checksums first, installs offline nsauditor-ai feed import --file feeds.json.gz export NSAUDITOR_OFFLINE_ONLY=1 nsauditor-ai scan --host aws --compliance soc2
Subscribe directly to unlock CVE matching, MITRE ATT&CK annotations,
risk scoring, and parallel analysis agents — and the report subcommand that turns a
finished scan into one self-contained HTML file you can send, or a Jira-importer CSV.
Cancel anytime — reverts to Community Edition with no data lost.