it.elsas/security-intel

Official6 tools

by romans-repos · Python

Daily Ed25519-signed security intelligence for AI-agent stacks; CVEs & advisories, paid via x402.

Delivers daily signed security intelligence including CVEs and advisories for AI agent stacks.

Topics

ai-agentscveed25519mcpsecurityx402cisa-kevosvsshsigsupply-chainthreat-intelligenceverification

Captured live from the server via tools/list.

get_today

Today's full curated security report for the MCP / AI-agent ecosystem (PAID — $0.10 USDC, charged automatically via x402 on Base; no account needed). Returns the latest signed, independently cross-validated digest of security incidents, advisories (CVE/GHSA/OSV/KEV) and notable changes affecting MCP servers, agents and their dependencies — each item with severity, why it matters, and a recommended action. Every report is Ed25519-signed; verify it yourself (see https://elsas.it/docs#verify). Try it free first with `get_sample_report` (yesterday's report, identical format).

Parameters (1)

stackany
Optional comma-separated filter, e.g. "devops,security", to return only relevant items. Stacks: devops, coding, qa, finance, healthcare, legal, content, security, knowledge.

get_sample_report

FREE preview — yesterday's full report, identical in format and signing to the paid `get_today`. Call this first to see exactly what you get before paying: real curated security items, severities, recommendations, and an Ed25519 signature you can verify (https://elsas.it/docs#verify). The only difference from get_today is freshness (this is the previous day's report).

Parameters (2)

run_idany
Optional specific report id (from `list_available`). Defaults to the most recent report that is not today's paid one.
stackany
Optional comma-separated filter (same stacks as get_today).

list_available

List available validated reports. Cheap to call, returns no full bodies. Only shows reports that passed validation (signed, TL;DR, no AUTO-CORRECTED). The current (newest) report is excluded — it's the paid product.

No parameters.

check_affected

Check your installed packages against recent security advisories. Pay-per-value: $0 when nothing affects your versions (status all_clear/verify is always free), otherwise priced per confirmed match via x402 — you only pay when you learn you are actually exposed. Zero-friction input: paste your dependency file straight into `lockfile` — no need to hand-extract package/version. Auto-detected formats: package-lock.json, yarn.lock, requirements.txt (== pins), poetry.lock, Pipfile.lock, go.mod, go.sum, Cargo.lock, and CycloneDX / SPDX JSON SBOMs. Or pass an explicit `components` list of {package, version, ecosystem?} (you may pass both — they are merged). Built for agents that poll on their own clock: pass `since` (a cursor) to match ONLY advisories first published after your last check, so a repeated poll is free until something NEW hits you — and you pay at most once per new exposure. The returned `cursor` is interchangeable with get_since's cursor; store it and pass it back next time. Use `min_severity` to ignore (and not pay for) matches below your threshold. Returns advisories that affect (or may affect) your versions, each with the primary-source URL so you can verify independently. Trust-safe: when a version range cannot be parsed, or an advisory is product-level (no version data), it is reported as "verify" rather than silently cleared. Pair with the signed report for an auditable trail.

Parameters (6)

componentsany
optional list of {package, version, ecosystem?}.
lockfileany
optional raw lockfile or SBOM text — parsed server-side into components (exact pinned versions only). Auto-detected; combine with `components` if you like. Practical size limit ~1MB; for a larger tree, dedupe or send `components` directly.
lockfile_typeany
optional hint/filename to force the parser (e.g. "go.mod", "requirements.txt", "cyclonedx") when auto-detect is ambiguous.
sinceany
optional cursor — only match advisories first published after it. Omit on the first call; pass the returned `cursor` thereafter.
min_severityany
optional floor — one of low|medium|moderate|high|critical. Matches below it are dropped (and not charged for).
previewboolean
if true, return only the shape (counts + max severity) used to quote a price — no advisory bodies. The gateway uses this; you do not need to set it.

get_since

Delta feed for agents that poll on their own clock: what's new since you last checked. Free. Pass the `cursor` from your previous call (omit on first call); poll as often as you like. Returns a lightweight index of new items — id, title, item_type, CVE id, severity, the signed report_id each was published in, and published_at — plus a new `cursor` and `count`. count == 0 means nothing new since you last looked. To get the full bodies (affected ranges, sources, assessment, remediation) for what's new, call the paid get_today (or check_affected to test your own deps). Optional `stack` filters by relevant_for tags (same as get_today). Returns: {cursor, count, index}.

Parameters (2)

cursorany
stackany

get_items

Full bodies for items you discovered via `get_since` (PAID — pay-per-value, priced per delivered item via x402; $0 if none of the ids are found). `get_since` gives you a free index (id, title, severity, …) so you can decide what matters to you; `get_items` returns the actionable payload — affected ranges, primary sources, assessment and remediation — only for the ids you ask for. Each item carries the `report_id` of the signed report it was first published in: fetch that report via `get_sample_report(run_id=report_id)` to verify the Ed25519 signature yourself.

Parameters (2)

idsarrayrequired
item ids (from get_since's index) to retrieve.
previewboolean
if true, return only the shape (count + max severity) used to quote a price — no bodies. The gateway uses this; you do not need to set it.

README.md5 KBView on GitHub

elsas-verify

Independently verify the daily security-intelligence reports published by elsas.it — offline, with no trust in our servers and no access to our keys.

elsas.it is signed security intelligence for AI agents, served over MCP and paid per call with x402 (USDC on Base — accountless, your wallet is your identity). Two shapes:

Atomic primitives (high-frequency, sub-cent): is_exploited (is this CVE in CISA-KEV? $0.001), check_cve (CVSS + KEV + EPSS, $0.01), check_package (OSV verdict for one package@version, $0.002), search_cves ($0.01), scan_dependencies (whole-lockfile OSV scan, pay-per-vuln, free when clean).
Premium digest: get_today — the daily curated, cross-validated report ($0.10).

Every response is Ed25519-signed (SSHSIG, namespace elsas-report) — so you can prove it's authentic and untampered without trusting our servers and without our keys. That's the differentiator: unsigned CVE APIs ask you to trust them; we let you verify. This repo is everything you need to do that offline.

Don't trust us — verify.

Verify in 30 seconds

Requirements: openssh-client (ssh-keygen) and python3 — present on any Linux/macOS. No install, no network needed for the verification itself.

bash

git clone https://github.com/romans-repos/elsas-verify.git
cd elsas-verify
./verify-report.sh examples/sample-report.json allowed_signers

Expected output:

code

VALID: authentic & untampered
  Signer:  elsas@elsas.it
  Hash:    sha256:…
Good "elsas-report" signature for elsas@elsas.it with ED25519 key SHA256:gLVNll72kb8Iyni2vNMR6oHGqVh0Ynz+lBMhbS+cSa4

Verify a live report

bash

# Fetch the current public sample + its detached signature
curl -s https://elsas.it/sample                          > report.json
curl -s https://elsas.it/.well-known/report.json.sig     > report.json.sig
# Verify against the pinned key in this repo
./verify-report.sh report.json allowed_signers

You can also verify by hand with stock OpenSSH:

bash

ssh-keygen -Y verify \
  -f allowed_signers \
  -I elsas@elsas.it \
  -n elsas-report \
  -s report.json.sig < report.json

Verify an atomic-tool verdict

The atomic tools return a JSON verdict with an embedded _signature block (signed_payload = the exact signed bytes; signature = an armored SSHSIG). Verify it offline — by shell, or with the drop-in library for your language:

bash

# shell (ssh-keygen + python3 stdlib)
./verify-verdict.sh examples/sample-verdict.json allowed_signers

// Node — zero dependencies (built-in crypto). npm i @elsas/verify
import { verifyVerdict } from '@elsas/verify';
const { ok, reason } = verifyVerdict(verdict);   // pinned elsas key, offline
if (!ok) throw new Error(`unverified elsas verdict: ${reason}`);

python

# Python — pip install elsas-verify  (only dep: cryptography)
from elsas_verify import verify_verdict
ok, info = verify_verdict(verdict)
assert ok, info["reason"]

Each verifier does two independent checks: (1) the verdict body matches the signed bytes (tamper-evidence), and (2) the SSHSIG verifies under the pinned elsas key (a signature by any other key is rejected). No network call is needed to verify.

Trust model

Signatures use SSHSIG (Ed25519) via ssh-keygen -Y sign. Verification is offline and zero-trust: you hold the payload, you verify locally.
The root of trust is allowed_signers — our public key, identity-pinned to elsas@elsas.it. A substituted signers file with a different key is rejected by the -I flag.
Confirm the pinned key independently against the live copy:
bash
```
curl -s https://elsas.it/.well-known/allowed_signers
```
Key fingerprint: SHA256:gLVNll72kb8Iyni2vNMR6oHGqVh0Ynz+lBMhbS+cSa4
Each report also carries a _integrity.content_hash (sha256 over the canonical JSON) for tamper evidence — see SIGNATURE-VERIFY.md.

What's in here

File	Purpose
`verify-report.sh`	Dependency-free report verifier (ssh-keygen + python3 stdlib)
`verify-verdict.sh`	Dependency-free atomic-verdict verifier
`packages/node/`	`@elsas/verify` — zero-dep Node library + CLI
`packages/python/`	`elsas-verify` — Python library + CLI (`pip install`)
`allowed_signers`	Our public signing key — the root of trust
`schemas/report-v4.json`	JSON schema of a report payload
`examples/sample-report.json` (+ `.sig`)	A real, signed report to verify against
`examples/sample-verdict.json`	A real, signed atomic-tool verdict to verify against
`SIGNATURE-VERIFY.md`	The full verification recipe and trust details

What's not here

This repo is the verification surface only. The curation pipeline, scoring prompts, relevance taxonomy, infrastructure and any operational configuration are intentionally not published — they are neither needed to verify a report nor useful to a third party. Verifiability does not require disclosing how the sausage is made; it requires that the result is checkable. That's what this is.

License

Tooling in this repository is released under the MIT License. Report payloads themselves carry their own license terms inside the report (_integrity._license_coverage).

Service: https://elsas.it · Docs: https://elsas.it/docs · Sample: https://elsas.it/sample

Install

claude_desktop_config.json

{
  "mcpServers": {
    "security-intel": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://elsas.it/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.