No CVE for Prompt Injection? How to Track AI Agent Vulnerabilities Without Waiting for an Advisory
Many AI agent security findings never get a CVE, and some never reach the database Dependabot reads. When prompt injection is CVE-able, where agent advisories appear, and a monitoring, logging and enforcement setup you can build this week.
Can prompt injection get a CVE? Sometimes. A prompt injection that only talks a model past its guardrails usually does not qualify. One that leads to data exposure or code execution in a specific product often does: CVE-2024-48145, a chat-history exfiltration bug in a chatbot app, is one. The bigger problem for AI agent builders is that many findings never become CVEs at all. On 12 November 2026 Microsoft's Agent Framework repository had eight published security advisories. None had a CVE, and none was in the GitHub Advisory Database that Dependabot reads. If your vulnerability tracking starts and ends with CVE feeds, you would not have seen any of them. This guide explains when the CVE Program considers prompt injection a vulnerability, where agent security findings appear, and how to build a tracking, logging and enforcement setup that does not depend on an advisory arriving first.
System requirements
Who this is for
Developers and security engineers shipping AI agents
Especially agents that read external content (web pages, email, documents, tool output) and can act through tools or MCP servers. DevSecOps teams who own dependency scanning will find steps 06 to 08 most useful.
What you need
A list of your agent's components, curl and jq
The monitoring commands use the public NVD, GitHub and OSV APIs and run the same on Windows (Git Bash or WSL), macOS and Linux. A GitHub token raises the API rate limit from 60 to 5,000 requests an hour.
Checked against
NVD, GitHub, OSV, CVE Program, OWASP and MITRE, on 12 November 2026
Every advisory date, version and CVE status below was read from the advisory or its API record on that date. Advisory status changes, so re-check before you act on a specific entry.
Time
An afternoon for the first pass
Inventory and source list: about an hour. Register and alert routing: an hour or two. Runtime logging and the enforcement gate depend on your stack and are ongoing work.
Why prompt injection is not like SQL injection
A model reads instructions and data in the same input, so there is no parameterised query to fall back on.
Traditional applications keep code and data apart. A parameterised SQL query guarantees that user input is treated as a value and never as part of the command. Language models have no equivalent boundary. The system prompt, the user's request, a retrieved web page, a tool description and a tool's response all arrive as text in one context window. You can label which parts are trusted, but you cannot guarantee the model will respect the labels.
Direct prompt injection is the familiar case: a user types "ignore your previous instructions" into the chat. Indirect prompt injection is the one that matters for agents. The malicious text sits inside content the agent fetches during an ordinary task: a web page, an email, a PDF, a README, a database record, an API response or an MCP tool description. The user never sees the attacker, and may never see the text.
Picture an email assistant asked to summarise the inbox. One message contains hidden text telling it to forward the user's last ten invoices to an outside address. If the agent has a send-email tool and nothing outside the model checks that call, a summary request turns into data loss. OWASP lists prompt injection as LLM01 in its 2025 Top 10, and MITRE ATT&CK added Indirect Prompt Injection as technique T1698 in September 2026.
Does prompt injection get a CVE?
It depends on what the injection leads to. The CVE Program has written down three cases.
A CVE identifies a vulnerability in a specific product, so a technique like "models can be talked into things" does not get one by itself. In February 2025 the CVE Program's AI working group published guidance with a worked example, a party chatbot that picks songs, and three outcomes.
Probably not CVE-able: the prompt talks the model past a guardrail. Under CNA Operational Rule 4.1.7, a detection bypass is not a vulnerability unless the product explicitly claimed to detect that pattern. Potentially CVE-able: the model is steered outside a limit the system could have enforced in ordinary code, such as a fixed list of music sources. The blog says some CNAs may assign a CVE here and others may not, and both are within the rules. Likely CVE-able: the injection triggers a further weakness, such as exposing private data or running code, that breaks the system's security policy. The blog says CNAs should assign CVE IDs in that case.
That is the useful takeaway for builders. The more an injection's impact depends on something your application could have enforced outside the model, the more it looks like a product vulnerability, and the more it is your bug to fix. It also explains why so many agent weaknesses never get a CVE: much of the risk lives in how a particular team wired tools and permissions, not in a shipped package version.
The four agent risks worth tracking
Prompt injection is the entry point. The damage depends on what the agent can reach.
Indirect prompt injection: retrieved content tries to act as an instruction. The control is to treat everything an agent retrieves as untrusted data, keep a record of where each piece came from, and never let retrieved text grant authority on its own.
Tool abuse: the agent calls a tool the user's task did not need, or with parameters the attacker chose. A file reader exposes documents. An HTTP fetcher reaches internal services (server-side request forgery, or SSRF). A shell tool compromises the host. The tool itself may be fine. The problem is that the application lets the model decide on its own when to use it.
Data exfiltration: secrets, customer records, source code or conversation history leave through an outbound request, an email, a rendered link or a tool parameter. The risk is highest when one agent can both read sensitive data and talk to arbitrary destinations.
Excessive agency (OWASP LLM06:2025): the agent holds more permission than the job needs, so a successful injection inherits all of it. A support bot that can read tickets does not need the API that changes account ownership.
Tip
When you triage any new finding, ask two questions first: which of these four does it enable, and does any of my agents have that capability today? That tells you more about urgency than a CVSS score does.
Why MCP makes the attack surface wider
Every MCP server adds tools, descriptions and responses that flow straight into the model's context.
The Model Context Protocol connects an AI application (the host) through an MCP client to MCP servers, which expose tools backed by real APIs, files and databases. That is convenient. It also means one bad link in the chain gets a direct path into what the model reads and what it can do.
The OWASP MCP Security Cheat Sheet names the main risks. Tool poisoning: malicious instructions hidden in a tool's description. Rug pulls: a server changes its tool definitions after you approved it. Confused deputy: a server performs an action with its own broad credentials on behalf of a user who should not have that access. Prompt injection through tool return values. And SSRF, when a fetch tool accepts any URL the model produces, including internal addresses and cloud metadata endpoints.
The MCP infrastructure itself has ordinary software bugs too, and step 05 includes one: a template engine in an MCP gateway that could run arbitrary code. So an MCP server needs the same review as any dependency that runs with your credentials, plus a review of what its tool descriptions tell your model.
Where agent security findings show up
Four real advisories, four different paths. Only one started as a CVE.
CVE-2024-48145 (ChatNet AI 1.0, published October 2024). A crafted chat message could exfiltrate the user's previous and later chat history. It is a clean example of a prompt injection CVE, and also of how thin such records can be: the original record lists the vendor and product as "n/a", CISA's enrichment added a 9.1 CVSS score and a product identifier, and NVD's analysis status is "Deferred". A scanner matching on product names would have had little to work with.
GHSA-9f26-7mqc-9vc4 (Microsoft Agent Framework, 7 October 2026). Declarative workflows that called an MCP tool did not enforce the protected-value boundary, so values marked sensitive, such as environment secrets, could be sent to an external MCP server chosen by the workflow. High severity, CVSS 7.5, fixed in Microsoft.Agents.AI.Workflows.Declarative 1.24.0. CVE field: "No known CVE". It is one of eight advisories the repository published in October 2026. When we checked, none of the eight had a CVE, and none returned a record from the GitHub Advisory Database API.
GHSA-vwf3-4xxj-qg6h (IBM MCP Context Forge). Prompt templates were rendered with an unsandboxed Jinja2 environment, so an authenticated user with permission to create or update prompts could run arbitrary Python on the gateway host. Fixed in mcp-contextforge-gateway 1.0.0. No CVE. The repository advisory was published on 15 June 2026. It reached the reviewed GitHub Advisory Database on 25 August, 71 days later.
CVE-2026-59207 (n8n AI Agents). With the agents module enabled, n8n did not enforce a credential's allowed HTTP request domains, so a member who could use a shared credential could point an MCP tool at their own server and receive the secret. Fixed in 2.27.4 and 2.28.1. The project's advisory came first (24 June 2026), the CVE reached NVD on 9 July, and the GitHub Advisory Database entry followed on 22 July.
Tip
Dependabot alerts come from the GitHub Advisory Database. A repository advisory that never reaches that database, or reaches it weeks later, will not raise a Dependabot alert in the meantime. Watch the security advisories of the agent frameworks and MCP servers you depend on directly.
Build a source list that does not depend on CVEs
Poll NVD, the reviewed GitHub database, OSV and the repository advisories of every agent component you run.
Use four kinds of source. CVE and NVD records give you standard identifiers and, sometimes, scores. The GitHub Advisory Database and OSV give you package names with affected and patched versions, which is what you need to match against your lockfiles. Repository security advisories are the earliest public record for many agent frameworks and MCP servers, and step 05 shows they can be the only one. Framework knowledge bases (OWASP GenAI, MITRE ATLAS, MITRE ATT&CK) do not list product bugs, but they give you shared names for attack techniques.
The commands below are the building blocks of a daily job. NVD limits a date range to 120 days per query. For repository advisories, keep a list of the GitHub repositories behind every agent framework, MCP server and AI SDK you use, and poll each one.
Then add the slower human sources: release notes and changelogs of your frameworks, maintainers' security discussions, and research from teams that publish agent attacks. Treat a blog post or social thread as a lead to verify, not a confirmed vulnerability, until you can tie it to a version and a reproduction.
curl -s "https://services.nvd.nist.gov/rest/json/cves/2.0?keywordSearch=prompt%20injection&pubStartDate=2026-10-01T00:00:00.000&pubEndDate=2026-11-11T23:59:59.999" \
| jq -r '.vulnerabilities[].cve | "\(.id) \(.descriptions[0].value[0:110])"'curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
"https://api.github.com/advisories?ecosystem=npm&affects=n8n&per_page=50" \
| jq -r '.[] | "\(.ghsa_id) \(.cve_id // "no CVE") \(.severity) \(.summary)"'curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
"https://api.github.com/repos/microsoft/agent-framework/security-advisories?state=published&per_page=100" \
| jq -r '.[] | "\(.published_at[0:10]) \(.ghsa_id) \(.cve_id // "no CVE") \(.summary)"'curl -s -X POST https://api.osv.dev/v1/query \
-d '{"package":{"name":"n8n","ecosystem":"npm"},"version":"2.27.3"}' \
| jq -r '.vulns[] | "\(.id) \(.summary)"'Inventory every component your agent trusts
You can only match an advisory to your system if you know what is in it, including the MCP servers.
Write down, per agent: the model provider and model, the agent framework and its version, every MCP server (with where it runs and which credentials it holds), the Python and npm packages, vector databases, container images and the external APIs it calls. MCP servers are the line item most teams miss, because they are configured in editor and desktop settings rather than in a lockfile.
Then run software composition analysis over the code. Dependabot, OSV-Scanner, pip-audit, npm audit, Trivy and Syft with Grype all find known-vulnerable dependency versions. They are necessary and they are not enough. They only know about advisories that reached their databases, and none of them can tell you whether your agent can be talked into misusing a tool.
find . -name ".mcp.json" -o -path "*/.cursor/mcp.json" -o -path "*/.vscode/mcp.json" 2>/dev/nullosv-scanner scan source -r .
pip-audit -r requirements.txt
npm audit --omit=dev
trivy fs --scanners vuln .
syft dir:. -o cyclonedx-json > sbom.json && grype sbom:./sbom.jsonTip
Keep the SBOM. When a repository advisory with no CVE appears, grep the SBOM for the package name and version range. It is the fastest way to answer "are we affected?" without waiting for a scanner database to catch up.
Keep one register for findings with and without CVEs
A finding that lives in a chat thread or a bookmark gets lost. Give each one an internal ID on day one.
Make the internal ID the primary key, and treat CVE and GHSA identifiers as optional fields that you fill in when they exist. That way a design weakness found in your own red-team test, a repository advisory with no CVE and a full CVE all go through the same triage, ownership and verification steps.
Record where the finding came from, which of your components it affects, the affected and fixed versions, which of the four risks from step 03 it enables, who owns the fix, and what evidence closed it. "Closed" should mean a test showed the fix works, not that a dependency was bumped.
Only alert a team when a finding matches a component in your inventory. An alert that says "a new prompt injection paper came out" trains people to ignore alerts. One that says "agent-framework 1.23.0 in billing-agent is affected, fixed in 1.24.0, owner: payments team" gets fixed.
- id: AGSEC-2026-014
title: Declarative MCP call can send protected values to external server
component: Microsoft.Agents.AI.Workflows.Declarative 1.23.0 (billing-agent)
source: repository advisory
ghsa: GHSA-9f26-7mqc-9vc4
cve: null # no CVE assigned; tracked anyway
risk: [data_exfiltration]
fixed_in: 1.24.0
owner: payments-platform
status: fixed
verified: canary secret no longer reaches test MCP server (2026-10-09)
- id: AGSEC-2026-015
title: Research agent follows instructions in fetched pages
component: research-agent (our code)
source: internal red-team test
ghsa: null
cve: null # design weakness in our wiring, not a package bug
risk: [indirect_prompt_injection, tool_abuse]
owner: agents-core
status: investigatingDetect injection at runtime, from actions not words
Log what the agent did and where its inputs came from, then alert on suspicious sequences.
Advisories cover known bugs. They will never tell you that your own agent was manipulated this morning. For that you need runtime events. For each tool call, log the agent and session, the sources of untrusted content in the context at that moment, the tool and a redacted summary of its parameters, the authorisation decision, the destination of any outbound request, any access to sensitive data, and whether a human approved it. Never log raw secrets or tokens.
Then correlate within one execution trace. One event on its own is rarely conclusive. A page fetched from an unknown domain, followed by a read of a credentials file, followed by a request to a host that is not on the allowlist, is a pattern worth an alert. MITRE published a detection strategy built on exactly this idea in November 2026: DET0942, Retrieved Instruction with Unauthorized Agent Action.
Five rules cover most of it: untrusted content followed by sensitive data access; outbound requests to unapproved or internal destinations; tool calls that fail authorisation; operations outside the agent's assigned role; and sensitive data appearing in an outbound payload. Base them on actions and policy violations. Searching model output for phrases like "ignore previous instructions" catches the demos and misses the real attempts.
{
"event_type": "agent_tool_call",
"trace_id": "tr_7f3a",
"agent_id": "research-agent-01",
"untrusted_sources_in_context": ["https://unknown-site.example/page"],
"tool": "http_fetch",
"destination": "collector.unapproved.example",
"params_summary": "POST, 4.2 KB body, contains value tagged secret",
"authorization": "denied: destination not on allowlist",
"risk_tags": ["indirect_prompt_injection", "possible_exfiltration"],
"human_approval": null
}Enforce permissions outside the model
The model can propose a tool call. Code it cannot talk to decides whether the call runs.
Every incident in step 05 has the same shape. A boundary that should have been enforced in code (a protected value, a domain allowlist, a sandbox) was either missing or bypassable. A system prompt that says "never send secrets to external servers" is a request, not a control. Put the control in a layer the model's text cannot change.
In practice that means a gate between the model and the tools. It checks the tool call against the permissions of the user the agent is acting for, validates parameters, limits network destinations, blocks private address ranges for fetch tools, and requires human approval for high-impact actions, especially when untrusted content is in the context. Credentials stay in a broker that hands the tool a short-lived, narrowly scoped token. The model never sees the credential.
The rule to design around: a successful prompt injection should never be enough, on its own, to authorise a sensitive operation. You will not stop every injection. You can make sure an injection that gets through finds nothing to use.
ALLOWED_HOSTS = {"api.example.com", "docs.example.com"}
HIGH_IMPACT = {"send_email", "delete_record", "change_permissions"}
def authorize(call, session):
# The model proposed this call. This function decides.
if call.tool not in session.user.allowed_tools:
return deny("tool not granted to this user")
if call.tool == "http_fetch":
host = urlparse(call.args["url"]).hostname
if host not in ALLOWED_HOSTS or resolves_to_private_ip(host):
return deny("destination not allowed")
if call.tool in HIGH_IMPACT and session.has_untrusted_content:
return require_human_approval(call)
return allow()Test your agent before an attacker does
Plant instructions in content you control and check what the agent tries to do, not what it says.
Build a small test set: a web page, a PDF, an email and a tool response, each with a planted instruction. Point a test copy of the agent at each one with an ordinary task such as "summarise this". Give it the same tools it has in production, but use synthetic data and a canary secret, a fake value you can search for in logs and outbound traffic.
A pass means: the planted instruction did not trigger a tool call the task did not need; any such call was denied by the gate, not by the model's good behaviour; the canary never left the environment; and the attempt shows up in your security events. Add tests for tool description poisoning, cross-agent messages, file access outside the task and privileged operations.
Tools such as NVIDIA garak, Promptfoo's red-team mode and Microsoft PyRIT generate many attack variants and are worth running in CI. None of them proves an agent is safe. Run every test only on systems you own or are authorised to test.
grep -rn "CANARY-7d1f-NOT-A-REAL-SECRET" ./logs ./egress-captureNo CVE, no advisory, no vulnerability: three different statements
| What you found | What it tells you |
|---|---|
| No CVE | Nobody has assigned an identifier. A published advisory may still exist, as in three of the four cases above. |
| No advisory | Nothing public was found. The issue may be unreported, under private disclosure, or fixed silently in a release. |
| No vulnerability | Evidence shows the weakness is not exploitable in your setup. Only your own testing can establish this for your agent. |
Points to consider
- Repository advisories can be thin. Some list no affected package, or say exploitation needs unusual conditions, such as n8n's agents module being switched on. Read the conditions before you escalate.
- Polling many repositories hits rate limits. Authenticate, poll once a day, and store the last-seen advisory ID per repository.
- Severity scores for agent issues vary between sources. Score the finding against your own deployment: which tools and data the affected agent can reach.
- The framework references (OWASP LLM Top 10, MITRE ATLAS, ATT&CK T1698) name techniques. They do not tell you whether your product is affected, so use them for classification, not for alerting.
- Defences reduce risk. No filter, model or gate prevents every prompt injection, which is why step 10 aims to make a successful injection harmless rather than impossible.
Pre-deployment checklist
- Identity: each agent has its own service identity with least-privilege permissions, and user-level authorisation is checked outside the model.
- Injection: direct and indirect injection are tested, retrieved content and tool responses are treated as untrusted, and policy does not live only in the system prompt.
- MCP: every server is reviewed before install, tool descriptions are inspected, changes to tool definitions are detected, and each tool has its own permission.
- Data: secrets stay out of model context, outbound destinations are allowlisted, private ranges are blocked for fetch tools, and logs are redacted.
- Monitoring: NVD, the GitHub Advisory Database, OSV and repository advisories of your agent components are polled, and findings without a CVE go into the register.
- Runtime: tool calls, content provenance and authorisation decisions are logged and correlated per trace, and there is a documented response plan.
Who should do what
| If you are | Do this first |
|---|---|
| A developer shipping one agent | List its MCP servers and frameworks (step 07), then poll their repository advisories (step 06) |
| A security or DevSecOps team | Add repository advisories to your feeds and a register that does not require a CVE (step 08) |
| A platform team | Put a policy gate and credential broker between models and tools (step 10) |
| An MCP server maintainer | Publish a repository advisory for every security fix, and request a CVE when the impact is in your product |
Keep your CVE feeds. They are still the shared language of vulnerability management. But for AI agents they are a lagging and partial signal: the Microsoft Agent Framework advisories in this guide were not in the database Dependabot reads, and the IBM one took 71 days to get there. If I were setting this up for a team today, I would spend the first hour listing every agent framework and MCP server we run and polling their repository advisories daily, and the next week on a policy gate that makes sure no instruction, from any source, can authorise a sensitive action by itself. Do not wait for a CVE to treat an agent weakness as real.
Frequently asked questions
Can prompt injection get a CVE?+
Yes, when it leads to a real security impact in a specific product. CVE-2024-48145, a chat-history exfiltration bug in ChatNet AI 1.0, is one example. The CVE Program's 2025 guidance says a pure guardrail bypass is probably not CVE-able, while an injection that leads to a further weakness such as data exposure or code execution likely is.
Why do so many AI agent advisories have no CVE?+
Some maintainers publish a GitHub repository advisory and never request a CVE. Some findings are design weaknesses rather than bugs in a versioned package. And guardrail bypasses usually fall outside CNA rule 4.1.7. All eight advisories Microsoft's Agent Framework repository had published by 12 November 2026 listed no known CVE.
Will Dependabot warn me about these advisories?+
Only once they reach the GitHub Advisory Database. A repository advisory that is not in the database does not raise a Dependabot alert. When we checked on 12 November 2026, none of the eight Agent Framework advisories was there, and the IBM MCP Context Forge advisory took 71 days to arrive. Poll the repository advisories of your agent components directly.
Which sources should I monitor?+
NVD or the CVE List for identifiers; the GitHub Advisory Database and OSV for package and version matching; the repository security advisories of every agent framework, MCP server and AI SDK you use; and their release notes. Use OWASP GenAI, MITRE ATLAS and MITRE ATT&CK to classify techniques, not to alert.
Can a better system prompt stop prompt injection?+
It can reduce how often the model follows injected text, but it is not a security control, because the attacker's text arrives in the same context. Enforce permissions, network limits, parameter validation and approvals in code the model cannot change.
Is it legal to test my agent with prompt injection?+
Testing systems you own or are authorised to test is standard security practice. Use synthetic data and canary secrets, keep the tests in a controlled environment, and do not plant injection payloads on third-party sites or services.