Elastic Security 9.6 now integrates MITRE ATLAS (Adversarial Threat Landscape for Artificial-Intelligence Systems) directly into its detection rule management workflow. On the surface that reads like a routine platform update. In practice, it is the first mainstream SIEM acknowledgement of something I have been telling CISOs for two years: most security programs have zero visibility into attacks against their AI systems, and they don't even know which attacks they should be looking for.
Every enterprise I assess in 2026 is running LLM-powered copilots, RAG pipelines, autonomous agents, or AI-assisted development tools. Almost none of them can answer the question: if an attacker prompt-injects our customer-facing agent tomorrow and uses it to exfiltrate the contents of our knowledge base, which detection rule fires? The answer is usually silence. Elastic's ATLAS integration matters because it forces that coverage conversation into the same tooling analysts already use for ATT&CK gap analysis — you can now see, explicitly, which ATLAS tactics and techniques your enabled rules address and which are dark.
This post breaks down what the integration actually does, walks through the ATLAS techniques I see weaponized most often in real engagements, and provides ready-to-deploy detections your SOC can use whether or not you run Elastic.
What Changed in Elastic Security 9.6
Per Elastic's Security Labs announcement, version 9.6 delivers three concrete capabilities:
- ATLAS-mapped detection rules. Elastic's prebuilt rule set now carries ATLAS tactic and technique metadata alongside the existing MITRE ATT&CK mappings. Rules relevant to AI threats — such as those covering suspicious API abuse patterns, anomalous cloud service usage, or data exfiltration behaviors that apply to LLM workloads — are tagged accordingly.
- Coverage visualization. The rule management interface now lets you pivot by ATLAS matrix, mirroring the ATT&CK coverage view. You can identify ATLAS tactics (e.g., ML Attack Staging, Exfiltration, Impact) where you have no enabled coverage.
- Gap-driven rule enablement. Analysts can filter rules by uncovered ATLAS technique and enable them directly, closing the loop between framework mapping and operational detection.
This is coverage mapping, not new detection logic out of the box. That distinction matters: the value is in revealing where your existing telemetry and rules intersect with AI-specific attack techniques, and where you need to build custom detections or ingest new data sources (LLM gateway logs, agent tool-call telemetry, vector database audit logs) to get real coverage.
Technical Analysis: The ATLAS Techniques That Actually Get Weaponized
ATLAS catalogs adversary behavior against AI-enabled systems across tactics like Reconnaissance, Resource Development, ML Attack Staging, Initial Access, Execution, Persistence, Discovery, Collection, Exfiltration, and Impact. From my incident response casework over the past 18 months, four technique families account for the overwhelming majority of real-world AI system abuse:
1. Prompt Injection (AML.T0051) — Direct and Indirect
Direct prompt injection against chat-facing models is table stakes. The dangerous variant in 2026 is indirect prompt injection: attacker-controlled content embedded in web pages, emails, documents, or tickets that an agentic workflow ingests. I have investigated cases where a poisoned knowledge-base article instructed an internal support agent to forward conversation transcripts to an external webhook. The agent had tool permissions to send HTTP requests — the model simply did what the injected instructions said.
Observable indicators: prompt content containing instruction-override phrases (ignore all previous instructions, you are now, new system prompt, base64-encoded payloads), especially originating from ingested external content rather than authenticated users.
2. LLM Data Exfiltration (AML.T0024 / Exfiltration via AI systems)
Attackers co-opt the model's legitimate capabilities — summarization, retrieval, code generation — to stage and move data. Common patterns: instructing the agent to embed sensitive retrieval results into a markdown image URL pointing to an attacker domain, or having a code-assistant agent write a script that uploads files to a paste or file-sharing service.
Observable indicators: agent runtimes (Python, Node.js) spawning network tools, egress to paste sites or unknown file hosts from servers hosting AI workloads, and LLM session logs showing retrieval volume far above baseline.
3. AI Supply Chain and Plugin/Tool Abuse (AML.T0010 / ATLAS Resource Development)
Malicious models on public hubs, trojanized agents, and over-permissioned tool integrations. An agent with read_file, execute_shell, and send_email tools is a persistence and exfiltration platform waiting for one successful injection.
Observable indicators: agent processes spawning shells, reading credential stores or SSH keys, and tool-call sequences that chain read-then-network-egress.
4. Unauthenticated LLM Endpoint Exposure
Shodan still returns thousands of exposed Ollama, vLLM, and LiteLLM instances with no authentication. Exposed endpoints get hijacked for free inference (resource theft — often called LLMjacking), and worse, they become pivot points: an attacker who can query your internal model can interrogate your RAG corpus.
Observable indicators: inbound connections to ports 11434 (Ollama), 8000/8080 (vLLM/LiteLLM defaults) from untrusted sources, and anomalous spikes in token consumption.
Exploitation Status
These are not theoretical. Indirect prompt injection, LLMjacking of exposed endpoints, and agent tool abuse are all actively observed in the wild in 2025-2026. There is no single CVE here — this is a technique-level threat landscape, which is exactly why framework mapping via ATLAS is the right defensive response. Detection engineering against AI workloads is a behavioral problem, not a signature problem.
Detection & Response
This is a technical threat surface, so the following detections are platform-agnostic and deployable regardless of whether you use Elastic, Sentinel, or Velociraptor. If you are on Elastic 9.6, use the ATLAS coverage view to confirm which of these behaviors your existing rules already touch, then fill the gaps with the detections below.
Sigma Rules
---
title: Prompt Injection Indicators in LLM Gateway Request Logs
id: 3f8a1c92-6d4e-4b7a-9c15-2e8f6a1b3d90
status: experimental
description: Detects common direct and indirect prompt injection phrases in LLM proxy, gateway, or application logs. Apply to log sources capturing user prompts and ingested external content (RAG pipelines, agent tool inputs).
references:
- https://atlas.mitre.org/techniques/AML.T0051
- https://www.elastic.co/security-labs/blog/mitre-atlas-elastic-security-detection-coverage
author: Security Arsenal
date: 2026/01/15
tags:
- attack.initial_access
- atlas.aml.t0051
logsource:
category: application
product: llm_gateway
detection:
selection_override:
message|contains:
- 'ignore all previous instructions'
- 'ignore previous instructions'
- 'disregard your instructions'
- 'you are now DAN'
- 'new system prompt'
- 'override system prompt'
- 'reveal your system prompt'
- 'print your instructions'
selection_encoding:
message|contains:
- 'aWdub3JlIGFsbCBwcmV2aW91cw==' # base64 of 'ignore all previous'
condition: selection_override or selection_encoding
falsepositives:
- Security research and red team testing of internal AI systems
- Users quoting injection examples in support conversations
level: medium
---
title: AI Agent Runtime Spawning Shell or Network Tools
id: 8c2e5b71-4f3a-4d96-8b27-1a9c4e6d2f85
status: experimental
description: Detects Python or Node.js processes associated with AI agent runtimes (LangChain, AutoGen, CrewAI, custom agents) spawning shells, curl, wget, or other data-movement tools. High-fidelity indicator of prompt injection leading to tool abuse or data exfiltration.
references:
- https://atlas.mitre.org/tactics/AML.TA0011
- https://www.elastic.co/security-labs/blog/mitre-atlas-elastic-security-detection-coverage
author: Security Arsenal
date: 2026/01/15
tags:
- attack.execution
- attack.exfiltration
- attack.t1059
- atlas.aml.t0024
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\python.exe'
- '\python3.exe'
- '\node.exe'
- '\uvicorn.exe'
selection_parent_cmdline:
ParentCommandLine|contains:
- 'langchain'
- 'autogen'
- 'crewai'
- 'agent'
- 'llm'
- 'openai'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\curl.exe'
- '\wget.exe'
- '\certutil.exe'
- '\bitsadmin.exe'
condition: selection_parent and selection_parent_cmdline and selection_child
falsepositives:
- AI agent frameworks with legitimate shell tool integrations (tune on known agent hosts)
- Developer workstations running local agents
level: high
---
title: LLM Agent Process Reading Credential or SSH Material
id: 5d1f9a46-2c8b-4e73-9a54-7b3e1c8f5d62
status: experimental
description: Detects AI agent runtimes accessing SSH keys, cloud credential files, or browser credential stores — a strong post-injection collection behavior observed in agent tool-abuse incidents.
references:
- https://atlas.mitre.org/tactics/AML.TA0008
- https://www.elastic.co/security-labs/blog/mitre-atlas-elastic-security-detection-coverage
author: Security Arsenal
date: 2026/01/15
tags:
- attack.credential_access
- attack.collection
- attack.t1552
- atlas.aml.t0010
logsource:
category: file_event
product: linux
detection:
selection_process:
Image|startswith:
- '/usr/bin/python'
- '/usr/local/bin/python'
- '/usr/bin/node'
selection_path:
TargetFilename|contains:
- '/.ssh/id_'
- '/.aws/credentials'
- '/.azure/'
- '/.config/gcloud/'
- '/etc/shadow'
- '.env'
condition: selection_process and selection_path
falsepositives:
- Agents legitimately configured with cloud SDK access (scope to specific service accounts and paths)
level: high
The first rule is deliberately medium severity — prompt injection attempts are constant against internet-facing bots, and you want them for trending, not paging. The second and third rules target post-exploitation behavior where your confidence should be much higher. Note the third rule uses a Linux logsource: the majority of production agent infrastructure runs on Linux containers, and that is where I consistently find the biggest telemetry gap.
KQL Hunt Query (Microsoft Sentinel / Defender)
This query hunts for prompt injection attempts and agent-driven exfiltration behavior in environments shipping LLM gateway logs and endpoint telemetry to Sentinel. Adjust the custom table name to your ingestion pipeline.
// Hunt: Prompt injection attempts + downstream agent host network behavior
let injection_terms = dynamic(['ignore all previous instructions','ignore previous instructions','disregard your instructions','new system prompt','reveal your system prompt','print your instructions','you are now DAN']);
let suspicious_egress = dynamic(['pastebin.com','transfer.sh','file.io','temp.sh','webhook.site','requestbin','ngrok.io','ngrok-free.app']);
let Injections =
LLMGateway_CL
| where TimeGenerated > ago(24h)
| where message_s has_any (injection_terms)
| project InjectionTime=TimeGenerated, Host=Computer, User=user_s, Session=session_id_g, Snippet=substring(message_s,0,200);
Injections
| summarize InjectionCount=count(), Samples=make_set(Snippet,3) by Host, User
| join kind=leftouter (
DeviceNetworkEvents
| where TimeGenerated > ago(24h)
| where RemoteUrl has_any (suspicious_egress)
| project DeviceName, Process=InitiatingProcessFileName, Parent=InitiatingProcessParentFileName, RemoteUrl, RemoteIP, EgressTime=TimeGenerated
) on $left.Host == $right.DeviceName
| summarize arg_max(EgressTime, *) by Host, User
| project Host, User, InjectionCount, Samples, Process, Parent, RemoteUrl, RemoteIP, EgressTime;
// Secondary: baseline token-consumption anomaly per service account (LLMjacking / resource theft)
LLMGateway_CL
| where TimeGenerated > ago(7d)
| summarize TotalTokens=sum(tolong(tokens_total_d)), Requests=count() by user_s, bin(TimeGenerated, 1h)
| extend AvgTokens = toscalar(LLMGateway_CL | where TimeGenerated > ago(30d) | summarize avg(todouble(tokens_total_d)))
| where TotalTokens > AvgTokens * 5 and TotalTokens > 500000
| project TimeGenerated, user_s, Requests, TotalTokens, AvgTokens;
The join is the part that matters operationally: an injection attempt followed within the same window by the host talking to a paste site or webhook service is your incident. Injection attempts alone are noise; injection attempts correlated with egress are your escalation path.
Velociraptor VQL Hunt
For DFIR teams, this artifact hunts agent hosts for suspicious process lineage and live network connections to high-risk egress destinations.
-- Hunt: AI agent runtimes with shell children or suspicious egress
-- Deploy as a hunt across AI workload server groups
LET suspicious_ports = (11434, 8080, 8000, 5000)
LET suspicious_procs = pslist()
WHERE Name =~ '(?i)(python|node|uvicorn|gunicorn)'
AND CommandLine =~ '(?i)(langchain|autogen|crewai|agent|llm|openai|ollama)'
SELECT Pid,
Ppid,
Name,
CommandLine,
Exe,
Username,
CreateTime,
parse_pe(file=Exe).TimeDateStamp AS BinaryCompileTime
FROM suspicious_procs
-- Enrich: children of agent runtimes (shell/tool spawning)
LET agent_pids = SELECT Pid FROM suspicious_procs
SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Ppid IN agent_pids.Pid
AND Name =~ '(?i)(cmd|powershell|pwsh|bash|sh|curl|wget|nc|ncat|socat)'
-- Enrich: live connections from agent processes to unusual remote hosts
SELECT Pid, Name, Status, Laddr, Lport, Raddr, Rport
FROM netstat()
WHERE Status =~ 'ESTAB'
AND Pid IN agent_pids.Pid
AND Raddr !~ '^(10\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.|192\\.168\\.|127\\.)'
Run this against your AI workload server group after any suspected injection incident. In my experience, the process lineage view — an agent runtime spawning curl to an external IP — is the single fastest way to confirm tool abuse without waiting on LLM provider logs.
Remediation / Hardening Script
This Bash script audits a Linux AI workload host for the most common exposure issues: unauthenticated LLM endpoints listening on all interfaces, agent processes with excessive privileges, and missing telemetry forwarding. Run it across your AI infrastructure as a configuration assessment.
#!/usr/bin/env bash
# AI Workload Exposure Audit — Security Arsenal
# Checks for unauthenticated LLM endpoints, risky agent configs, and telemetry gaps.
set -euo pipefail
REPORT="ai_exposure_audit_$(date +%Y%m%d_%H%M%S).txt"
exec > >(tee "$REPORT") 2>&1
echo "=== AI Workload Exposure Audit: $(hostname) — $(date -u) ==="
echo -e "\n[1] LLM service listeners bound to non-loopback interfaces"
# Flags Ollama (11434), vLLM/LiteLLM (8000/8080), Gradio (7860) exposed on 0.0.0.0
ss -tlnp 2>/dev/null | grep -E ':(11434|8000|8080|7860|5000)\b' | grep -v '127.0.0.1' \
&& echo " [!!] FINDING: LLM-related service exposed on a non-loopback address. Bind to localhost or place behind an authenticated gateway." \
|| echo " [OK] No LLM listeners on external interfaces."
echo -e "\n[2] Ollama default exposure check"
if systemctl is-active --quiet ollama 2>/dev/null; then
grep -q 'OLLAMA_HOST' /etc/systemd/system/ollama.service.d/*.conf 2>/dev/null \
&& echo " [OK] OLLAMA_HOST override present." \
|| echo " [!!] FINDING: Ollama active with no OLLAMA_HOST override. Default binds 127.0.0.1 — confirm no reverse proxy exposes it unauthenticated."
fi
echo -e "\n[3] Agent runtimes running as root"
ps -eo user,pid,cmd | grep -iE '(langchain|autogen|crewai|agent|llm)' | grep '^root' \
&& echo " [!!] FINDING: Agent runtime running as root. Move to a dedicated low-privilege service account with scoped tool permissions." \
|| echo " [OK] No root-owned agent runtimes."
echo -e "\n[4] Credential files readable by agent service accounts"
for f in /home/*/.aws/credentials /home/*/.ssh/id_rsa /home/*/.ssh/id_ed25519 /root/.aws/credentials; do
[ -f "$f" ] && [ "$(stat -c '%a' "$f")" -gt 600 ] && echo " [!!] FINDING: $f has permissive mode $(stat -c '%a' "$f") — chmod 600 and audit which agent service accounts can read it."
done
echo -e "\n[5] Egress policy spot-check (can the agent reach paste/webhook sites?)"
for host in pastebin.com webhook.site transfer.sh; do
timeout 3 curl -sI "https://$host" -o /dev/null 2>/dev/null \
&& echo " [!!] FINDING: egress to $host permitted — restrict agent egress via proxy allowlist." \
|| echo " [OK] $host unreachable (blocked or filtered)."
done
echo -e "\n[6] Telemetry forwarding"
if systemctl is-active --quiet filebeat || systemctl is-active --quiet fluent-bit || systemctl is-active --quiet vector; then
echo " [OK] Log forwarder active — confirm LLM gateway and agent tool-call logs are in scope."
else
echo " [!!] FINDING: No log forwarder detected. AI workload telemetry is not reaching the SIEM — this is the primary ATLAS coverage gap."
fi
echo -e "\n=== Audit complete: $REPORT ==="
Remediation and Hardening Recommendations
- Upgrade to Elastic Security 9.6 and run the ATLAS coverage view today. Treat every ATLAS tactic with zero enabled rules as a finding in your next detection-engineering sprint. The release notes and rule documentation are at the Elastic Security Labs blog: https://www.elastic.co/security-labs/blog/mitre-atlas-elastic-security-detection-coverage
- Instrument the AI data path, not just the endpoints. SIEM coverage of ATLAS techniques requires telemetry most organizations do not collect: LLM gateway request/response logs (with prompt content, respecting privacy controls), agent tool-call transcripts, RAG retrieval logs, and vector database access logs. Ship these to your SIEM as first-class sources.
- Enforce least privilege on agent tools. Every tool integration is an attack primitive. Agents should run as dedicated low-privilege service accounts, tool allowlists should be explicit, and any tool capable of outbound HTTP should route through an egress proxy with a domain allowlist.
- Authenticate and isolate every LLM endpoint. Nothing on ports 11434/8000/8080/7860 should be reachable without authentication, and ideally nothing AI-related should be internet-exposed at all. Scan your own external attack surface for these ports weekly.
- Treat retrieved content as untrusted input. Indirect prompt injection succeeds because RAG pipelines concatenate attacker-controllable content into the model's context. Implement content isolation (separating instructions from retrieved data), instruction hierarchy enforcement where your model provider supports it, and output filtering that blocks credential-shaped and URL-embedded responses.
- Baseline token and retrieval volume. LLMjacking and RAG exfiltration both manifest as volume anomalies. Alert on per-service-account token consumption exceeding 5x the 30-day hourly average and on retrieval counts per session that imply bulk knowledge-base reads.
- Add AI abuse scenarios to your IR playbooks and tabletop exercises. Your ransomware playbook does not cover "the support agent mailed our knowledge base to a webhook." Write the playbook now, before the incident.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.