1. The AI Attack Surface

Introduction

In Chapter 1, you built the mental models: the context window as a flat trust boundary, retrieval as a pipeline with eight writable stages, agency as the difference between a system that answers and a system that acts. This chapter attacks every one of them.

The people who maintain the industry’s threat list opened their 2026 edition with the posture that should frame everything you read here:

Stop trying to build a model that cannot be fooled. Build the system around it, so that when the model is fooled, and it will be, nothing important breaks.

– Steve Wilson and Rock Lambros, project leads, OWASP GenAI LLM Top 10 (2026)

That is not resignation. It is the reason this chapter is organised the way it is. You are not learning attacks so you can enumerate them; you are learning them so you can find the place in an architecture where a successful attack stops being contained and starts being expensive.

This section gives you the map and the vocabulary. By the end you should be able to take a system you have never seen, place its components on a lifecycle, and name both the category that attacks each one and the Chapter 3 layer that defends it.

What will I get out of this?

By the end of this section, you will be able to:

  1. Locate a given AI system’s components on the AI lifecycle and identify which attack surfaces each stage exposes.
  2. Classify an observed incident into the correct OWASP LLM Top 10 (2026) category, and justify the classification against adjacent categories.
  3. Explain why the 2026 rankings moved, and what the gap between practitioner belief and incident evidence reveals about prioritising defences.
  4. Determine when a risk crosses from the LLM Top 10 into the Agentic Top 10, using the model-as-component versus model-as-actor boundary.
  5. Select the appropriate framework – OWASP LLM, OWASP Agentic, or MITRE ATLAS – for a given task, and explain why the others do not fit.
  6. Profile the threat actors realistically targeting a given deployment, and state what each one changes about your defensive priorities.
  7. Trace any attack category forward to the Chapter 3 Blueprint layer that owns its control.

The AI Lifecycle as an Attack Surface

Every stage of an AI system’s lifecycle – from initial training to production inference and ongoing monitoring – presents opportunities for attackers. The diagram below maps these stages and names the attack that lands at each one.

graph LR
    subgraph "Training Phase"
        A["Data Collection<br/>& Curation"]
        B["Model Training<br/>& Pre-training"]
    end

    subgraph "Customization Phase"
        C["Fine-tuning<br/>& Alignment"]
        D["RAG Pipeline<br/>Setup"]
    end

    subgraph "Deployment Phase"
        E["Model Packaging<br/>& Distribution"]
        F["Infrastructure<br/>& API Setup"]
    end

    subgraph "Inference Phase"
        G["Prompt Processing<br/>& Generation"]
        H["Tool Use &<br/>Agentic Actions"]
    end

    subgraph "Monitoring Phase"
        I["Logging &<br/>Feedback Loops"]
    end

    A --> B --> C --> D --> E --> F --> G --> H --> I
    I -.->|"retraining feedback"| A

    A -.- PA["Data Poisoning<br/>LLM05"]
    B -.- PB["Backdoor Insertion<br/>LLM05"]
    C -.- PC["Malicious LoRA Adapter<br/>LLM04"]
    D -.- PD["RAG Corpus Poisoning<br/>LLM09"]
    E -.- PE["Artifact Substitution<br/>LLM04"]
    F -.- PF["Credential Theft<br/>LLM06"]
    G -.- PG["Prompt Injection<br/>LLM01"]
    H -.- PH["Excessive Agency<br/>LLM03"]
    I -.- PI["Memory Poisoning<br/>ASI06"]

    style PA fill:#8b0000,color:#fff
    style PB fill:#8b0000,color:#fff
    style PC fill:#8b0000,color:#fff
    style PD fill:#8b0000,color:#fff
    style PE fill:#8b0000,color:#fff
    style PF fill:#8b0000,color:#fff
    style PG fill:#8b0000,color:#fff
    style PH fill:#8b0000,color:#fff
    style PI fill:#8b0000,color:#fff

The key insight: there is no safe stage. Attackers target training data months before a model ships. They poison RAG corpora without touching the model itself. They craft prompts that override system instructions in real time. They steal models through inference APIs.

Notice also that the feedback arrow closes the loop. A monitoring pipeline that feeds production interactions back into retraining turns an inference-time attack into a training-time one, which is why the last stage points back at the first.

Here is the map for the rest of the course. Every row names a stage, the section of this chapter that attacks it, and the Chapter 3 layer that owns the control:

Lifecycle stage Attacked in Defended by
Data collection & curation S3 路 Data and Training Attacks Layer 1 路 Secure Your Data
Model training & pre-training S3 路 Data and Training Attacks Layer 2 路 Secure Your AI Models
Fine-tuning & alignment S3 路 Data and Training Attacks Layer 2 路 Secure Your AI Models
RAG pipeline setup S3 路 Data and Training Attacks Layer 1 路 Secure Your Data
Model packaging & distribution S4 路 Model and Infrastructure Attacks Layer 2 路 Secure Your AI Models
Infrastructure & API setup S4 路 Model and Infrastructure Attacks Layer 3 路 Secure Your AI Infrastructure
Prompt processing & generation S2 路 Prompt-Level Attacks Layer 5 路 Secure Access to AI Services
Tool use & agentic actions S5 路 Agentic AI Attack Vectors Layer 5 路 Secure Access to AI Services
Output consumption & human trust S6 路 Output and Trust Exploitation Layer 4 路 Secure Your Users
Logging & feedback loops S3 路 Data and Training Attacks Layer 1 路 Secure Your Data
Edge and on-device deployment S7 路 Small Language Model Threats Layer 3 路 Secure Your AI Infrastructure

Two stages sit outside the training-to-inference chain and are easy to miss. Output consumption is a surface because the consumer – a human or a downstream parser – makes decisions on content the model generated. Edge deployment is a surface because a model running on a device you do not control has no server-side guardrail in front of it.


Who Are the Threat Actors?

Not all attackers are the same. The last column is the one that matters operationally: knowing who realistically targets your deployment tells you which control to fund first.

Threat actor Motivation Typical targets Capability What it changes for you
Opportunists Curiosity, bragging rights Public chatbots, open APIs Low – published jailbreaks and injection templates Assume every public jailbreak will be tried on day one. Rate limiting and input filtering handle most of it
Competitors IP theft, market advantage Proprietary models, training data, system prompts Medium – targeted API extraction, social engineering Treat query volume as an exfiltration signal, not just a billing line
Cybercriminals Financial gain API credits, compute, customer data Medium to high – credential theft, LLMjacking, ransomware Credential hygiene and spend caps outrank model-level hardening
Nation-states Intelligence, disruption Critical infrastructure AI, defence models Very high – supply chain attacks, insider recruitment, zero-days Provenance and integrity verification across the whole supply chain, not just your own code
Malicious insiders Revenge, financial gain, ideology Training pipelines, model weights, internal tools High – already inside the perimeter Perimeter controls are irrelevant. Audit trails and separation of duties are the control
Security researchers Responsible disclosure, reputation Anything with a bounty or academic interest Varies – often find novel techniques first Have a disclosure channel. Without one, findings go public instead of to you
The Democratization Problem

AI attack tools are unusually accessible. Jailbreak prompts spread on social media within hours. Injection templates are shared on GitHub. The barrier to entry for attacking AI systems is far lower than for traditional exploitation – you do not need to write code to manipulate a chatbot.

The practical consequence is that the low-capability row of the table above is not the low-risk row. An opportunist running a copied template against an over-permissioned agent gets the same outcome as a skilled attacker. Capability limits how attackers find a weakness, not how much damage the weakness does.


OWASP LLM Top 10 (2026)

The OWASP Top 10 for LLM Applications is the industry-standard framework for categorizing LLM vulnerabilities. The 2026 edition, published on 4 August 2026 by the OWASP GenAI Security Project, is the current release and the reference framework for the rest of this chapter.

graph TB
    subgraph "Input Attacks"
        LLM01["LLM01<br/>Prompt Injection"]
        LLM08["LLM08<br/>Hidden Context<br/>Exposure"]
    end

    subgraph "Data & Training"
        LLM05["LLM05<br/>Data and Model<br/>Poisoning"]
        LLM04["LLM04<br/>Supply Chain"]
        LLM09["LLM09<br/>Vector and Embedding<br/>Weaknesses"]
    end

    subgraph "Output & Behavior"
        LLM02["LLM02<br/>Sensitive Information<br/>Disclosure"]
        LLM10["LLM10<br/>Improper Output<br/>Handling"]
        LLM07["LLM07<br/>Misinformation"]
    end

    subgraph "System & Operations"
        LLM03["LLM03<br/>Excessive Agency"]
        LLM06["LLM06<br/>Unbounded Consumption"]
    end

    style LLM01 fill:#8b0000,color:#fff
    style LLM02 fill:#8b0000,color:#fff
    style LLM03 fill:#8b0000,color:#fff
    style LLM04 fill:#8b0000,color:#fff
    style LLM05 fill:#8b0000,color:#fff
    style LLM06 fill:#8b0000,color:#fff
    style LLM07 fill:#8b0000,color:#fff
    style LLM08 fill:#8b0000,color:#fff
    style LLM09 fill:#8b0000,color:#fff
    style LLM10 fill:#8b0000,color:#fff
​

LLM01: Prompt Injection

Prompt injection occurs when an attacker crafts input that overrides or manipulates the LLM’s intended instructions. It succeeds for the structural reason established in Chapter 1 Section 4 – everything in the context window arrives as one flat token sequence with no privilege levels.

  • Direct injection: attacker types malicious instructions into the interface
  • Indirect injection: instructions hidden in data the model processes – documents, web pages, emails
  • New in 2026: cross-modal injection, where instructions are hidden inside an image or audio track
  • Attacked in: Section 2 路 Defended by: Layer 5, Layer 6

LLM08: Hidden Context Exposure

Formerly System Prompt Leakage. Broadened in 2026 to cover all non-user-facing context – the system prompt, retrieved policy text, tool and function schemas, and any other material the application assembles into the context window.

  • Technique: crafted prompts that reconstruct or infer hidden configuration
  • Why it matters: leaked context reveals business logic, tool permissions and refusal conditions, giving attackers a roadmap
  • The design rule: assume hidden context is discoverable. OWASP’s guidance is that disclosure should have little or no direct security impact – if leaking your system prompt is a crisis, the system prompt was doing a job it cannot do
  • Attacked in: Section 2 路 Defended by: Layer 5

LLM05: Data and Model Poisoning

Poisoning targets the training pipeline – corrupting the data used to train, fine-tune, or align a model to introduce biases, backdoors, or vulnerabilities. The 2026 edition folds fine-tuning subversion into this category.

  • Scope: training data manipulation, fine-tuning attacks, RLHF poisoning
  • Why it matters: poisoned models produce subtly wrong outputs that are extremely difficult to detect
  • Attacked in: Section 3 路 Defended by: Layer 1, Layer 2

LLM04: Supply Chain

Compromised components anywhere in the AI development and deployment pipeline – model weights, datasets, pre-built adapters, software dependencies. The 2026 edition adds artifact trust failure: a promoted model artifact that is not what it claims to be.

  • Scope: malicious models on hubs, poisoned fine-tuning adapters, compromised dependencies
  • Why it matters: one poisoned artifact compromises every deployment that uses it
  • Attacked in: Sections 3 and 4 路 Defended by: Layer 2, Layer 3

LLM09: Vector and Embedding Weaknesses

Weaknesses in how RAG systems store and retrieve information – missing access controls on vector stores, embedding-space manipulation, and adversarial documents that game retrieval ranking.

  • Scope: RAG poisoning, embedding manipulation, unauthorized vector store access
  • Why it matters: as Chapter 1 Section 6 established, a vector index has no concept of a user. Permission filtering that is not inside the retrieval query is not a control
  • Attacked in: Section 3 路 Defended by: Layer 1, Layer 3

LLM02: Sensitive Information Disclosure

The model reveals confidential data in its responses – training data, PII, internal system details, or proprietary information.

  • Scope: training data extraction, PII leakage through memorization, side-channel extraction of weights or architecture
  • Why it matters: the one category where practitioner ranking and incident evidence agree exactly, which makes it the highest-confidence entry on the list
  • Attacked in: Section 6 路 Defended by: Layer 1, Layer 5

LLM10: Improper Output Handling

Model output passed to downstream systems without validation – enabling XSS, SQL injection, and command injection through AI-generated content. Fell from fifth to tenth in 2026, the largest drop on the list.

  • Scope: code injection via generated output, unvalidated function calls, and newly in 2026, ANSI/terminal escape sinks, auto-fetching renderers, and insecure code generated by assistants at scale
  • Why it matters: the LLM becomes an attack vector against your own backend
  • Attacked in: Sections 4 and 6 路 Defended by: Layer 5, Layer 6

LLM07: Misinformation

The model generates false or misleading content with high confidence – hallucinations presented as fact, fabricated citations, confident answers outside its knowledge.

  • Scope: hallucinations, fabricated references, overreliance on model outputs
  • Why it matters: the widest belief-versus-evidence gap on the 2026 list. Practitioners rank it near the bottom; the incident record puts it near the top. When fluent output drives a tool call, a wrong answer becomes a wrong action
  • Attacked in: Section 6 路 Defended by: Layer 4, Layer 5

LLM03: Excessive Agency

An LLM-based system granted more capability, permission, or autonomy than its task requires – and an attacker exploiting that excess. Climbed from sixth to third in 2026, the most consequential move on the list, because agentic deployments are where the damage is now landing.

  • Three root causes, three different fixes: excessive functionality (remove the tool), excessive permissions (scope the credential), excessive autonomy (gate the irreversible action)
  • Why it matters: it is the vulnerability that converts any model malfunction – injection or plain hallucination – into a real-world consequence
  • Attacked in: Section 5 路 Defended by: Layer 3, Layer 5

LLM06: Unbounded Consumption

Attackers exploit resource usage to cause denial of service, financial damage, or resource exhaustion. Climbed four places in 2026, reframed around cost asymmetry – the attacker triggers expensive computation at negligible cost to themselves.

  • Scope: prompt flooding, context stuffing, recursive generation, credential-driven cost attacks, and model extraction by API querying
  • Why it matters: reasoning models with large output budgets, multimodal inputs, and agentic fan-out all multiply the cost of a single malicious request
  • Attacked in: Section 4 路 Defended by: Layer 5, Layer 6

What Changed in 2026, and Why It Matters

The 2026 edition was the first built on evidence as well as opinion. Alongside the community vote, the project classified 7,714 real incidents from public vulnerability and AI-harm databases, using the 6,639 that carried enough detail. The vote carried 75% of the weight and the incident data 25%.

The disagreements between the two are more instructive than the list itself:

Read the gaps, not just the ranks

Prompt injection ranks #1 on the vote, but falls out of the top 10 on raw incident counts. That gap is a defense effect, not evidence the risk is overstated: teams fight injection hard, so fewer clean exploits reach a public database. A low incident count for a heavily defended risk tells you the defence is working, not that you can stop paying for it.

Misinformation runs the other way. Voters placed it near the bottom; the evidence placed it near the top. It landed at #7 as a compromise. This is the direction that actually hurts – a risk the field under-rates relative to what it has already been burned by.

The transferable skill: when you prioritise risks for your own system, ask which of your low-incident categories are low because you defend them, and which are low because nobody has looked.

Both numbering schemes will be in circulation for some time – tooling, audit reports and vendor mappings written before August 2026 all cite the 2025 identifiers. This table is your translation key:

2025 Category 2026 Movement
LLM01 Prompt Injection LLM01 Held #1; scope expanded to cross-modal attacks
LLM02 Sensitive Information Disclosure LLM02 Held #2; belief and evidence agree
LLM03 Supply Chain LLM04 Down 1; adds artifact-trust failure
LLM04 Data and Model Poisoning LLM05 Down 1; absorbs fine-tuning subversion
LLM05 Improper Output Handling LLM10 Down 5 – the furthest fall on the list
LLM06 Excessive Agency LLM03 Up 3 – the most consequential move
LLM07 System Prompt Leakage LLM08 Renamed Hidden Context Exposure and broadened
LLM08 Vector and Embedding Weaknesses LLM09 Down 1; scope unchanged
LLM09 Misinformation LLM07 Up 2; pushed by incident data
LLM10 Unbounded Consumption LLM06 Up 4; reframed around cost asymmetry

Choosing a Framework

Four frameworks cover this ground, and they are not interchangeable. Each answers a different question:

OWASP LLM Top 10 OWASP Agentic Top 10 MITRE ATLAS OWASP AISVS
Answers What can go wrong? What can go wrong when it acts? How does an attacker get from access to impact? What do I verify, and how would someone confirm it?
Unit Vulnerability category Agentic risk category Tactic and technique Testable requirement
Scope Model as a component in your application Model as an actor with tools, memory and consequences Full adversarial lifecycle, ML and LLM The application you built, end to end
Size 10 categories 10 categories (ASI01-ASI10) 16 tactics, 178 techniques 12 chapters, 191 requirements, 3 levels
Use it for Risk registers, stakeholder and compliance conversations, developer training Reviewing any system with tool access or persistent memory Formal threat modelling, red team planning, detection engineering Design review, code review, audits, supplier questionnaires
Do not use it for Planning an attack chain Systems with no agency Everyday vocabulary – too granular Deciding which risks matter – it does not rank

The first three describe threats; AISVS describes what you check. Published 24 June 2026 and modelled on the ASVS that web application security already runs on, it is positioned by OWASP as supplying “the detailed controls to mitigate” the two Top 10 lists – so a category from either list becomes a set of AISVS requirements to verify. Chapter 3 Section 10 works through it, including the identifier discipline that keeps a citation readable across versions.

The boundary between the two OWASP lists is the one to internalise. In the project’s own words: the LLM list owns the risk when the model is a component inside your application; the moment that model becomes an actor – with tools it can call, memory it carries between sessions, and consequences it sets in motion – the risk moves to the Agentic list. Many real incidents sit right on that line, and neither list covers it alone.

MITRE ATLAS

MITRE ATLAS (Adversarial Threat Landscape for AI Systems) maps adversarial tactics and techniques for AI and machine learning systems in a matrix modelled on MITRE ATT&CK. As of release 2026.07 it catalogs 16 tactics and 178 techniques (101 techniques with 77 sub-techniques), alongside 37 mitigations and 68 real-world case studies.

Treat those counts as a snapshot

ATLAS is a living matrix and it is growing quickly – it gained roughly a hundred techniques over the preceding year, largely agent-focused. Do not memorise the numbers or the technique list. Know that the framework exists, understand that it maps the attacker’s journey step by step, and go to atlas.mitre.org when you are doing formal threat modelling. OWASP categories are your everyday vocabulary; ATLAS is your reference work.

Framework versions and counts on this page were verified on 17 August 2026. Counts and versions were checked against each project's own repository or release on the date shown. All of them move; the distinctions they encode do not. Re-check before quoting a number in an audit or a risk register.


OWASP Top 10 for Agentic Applications (2026)

Agentic AI – systems that use tools, make decisions, and act autonomously – created attack surfaces different enough from ordinary LLM usage that the OWASP GenAI Security Project published a dedicated list, released 9 December 2025. Unlike the LLM list it has not yet been revised, so the December 2025 edition is current – do not confuse it with the project’s separate State of Agentic AI Security and Governance report, which reached version 2.01 in June 2026.

In Chapter 1 Section 7 you learned the agent loop: plan, select tool, execute, observe, decide. Each stage of that loop is a target, and this list maps them. The ten categories are covered in depth in Section 5: Agentic AI Attack Vectors; here is the preview.

​

ASI01: Agent Goal Hijacking

Manipulating the goals or objectives an agent is pursuing – redirecting its decision-making toward attacker-chosen outcomes rather than its intended purpose.


ASI02: Tool Misuse and Exploitation

Exploiting the tools and functions available to an agent – tricking it into calling tools in unintended ways, passing malicious parameters, or using legitimate tools for unauthorized purposes.


ASI03: Identity and Privilege Abuse

Leveraging the agent’s identity and access permissions to perform actions the human user shouldn’t be able to do – using the agent as a privilege escalation vector.


ASI04: Agentic Supply Chain Vulnerabilities

Compromising the plugins, tools, APIs, or external services that agents depend on – poisoning the agent’s operational environment rather than the agent itself.


ASI05: Unexpected Code Execution

Exploiting an agent’s ability to generate and execute code – injecting malicious code through prompt manipulation or data poisoning that the agent then runs with its own permissions.

ASI06: Memory and Context Poisoning

Manipulating an agent’s persistent memory or context to influence future decisions – planting false information that the agent will trust and act upon in subsequent interactions.


ASI07: Insecure Inter-Agent Communication

Exploiting the communication channels between agents in multi-agent systems – intercepting, modifying, or injecting messages to manipulate collaborative agent workflows.


ASI08: Cascading Failures

Triggering failures that propagate through interconnected agent systems – exploiting the interdependence of multi-agent architectures to amplify the impact of a single point of compromise.


ASI09: Human-Agent Trust Exploitation

Exploiting the trust relationship between humans and AI agents – using the agent’s perceived authority or helpfulness to manipulate human decisions or bypass human oversight.


ASI10: Rogue Agents

Agents operating outside their intended scope or monitoring – a shadow agent, a compromised one, or one whose emergent behavior no longer matches its mandate.

Where LLM03 ends and the ASI list begins

LLM03: Excessive Agency and the Agentic Top 10 are not competing frameworks – they are two halves of one question. LLM03 is preventive and singular: don’t grant capability the task doesn’t need. The ASI categories are what happens when the system does have that capability and something goes wrong anyway.

Use LLM03 as the entry question for any agentic assessment – does this system have more functionality, permission, or autonomy than its job requires? – then use ASI01-ASI10 to enumerate the specific failures. OWASP makes the link explicit in the LLM03 entry itself, noting that excessive agency manifests as ASI02, ASI03 and ASI08 in agentic systems.

The blunt version: a chatbot that gets prompt-injected can say something wrong. An agent that gets prompt-injected can do something wrong – run code, send email, modify files, or spend money.


Case Study: Microsoft v. Storm-2139 (2024-2025)

Real-World Impact: LLMjacking at Scale

Who: Microsoft’s Digital Crimes Unit, against a cybercrime network it tracks as Storm-2139

When: complaint filed December 2024 in the U.S. District Court for the Eastern District of Virginia; amended complaint in February 2025 naming four defendants, based in Iran, the UK, Hong Kong and Vietnam

What happened: the group harvested exposed Azure OpenAI Service API keys from public sources, built reverse-proxy software that resold access to the hijacked accounts, and used it to generate content that violated the service’s usage policies – including non-consensual intimate imagery via DALL-E. Victims included U.S. enterprises whose credentials had leaked. Microsoft pleaded violations of the Computer Fraud and Abuse Act, the DMCA, the Lanham Act and RICO, plus state-law claims.

How it worked:

  1. Harvested API keys from public code repositories, leaked credential dumps, and other exposed sources
  2. Built a reverse proxy service that fronted the stolen keys and resold access
  3. Buyers used the stolen access to generate content the provider’s policies prohibited
  4. Victims discovered the abuse only when unexpected charges appeared on their bills

On the numbers: you will often see “over $100,000 per day” attached to LLMjacking. That figure is a modelled worst case from security research on the technique – Sysdig’s original 2024 analysis calculated roughly $46,000 per day against a Bedrock-hosted model at maximum quota, and later estimates scaled it past $100,000 for frontier models. It is a useful ceiling for reasoning about exposure. It is not an established damages figure for this case, and Microsoft has not published one.

OWASP mapping: LLM06: Unbounded Consumption – stolen credentials enabled consumption at the victim’s expense, the cost-asymmetry pattern the 2026 edition reframed the category around.

Lesson: API credential security is budget security. The control that would have prevented this is not model-level hardening – it is credential hygiene, spend caps, and anomaly detection on consumption. All three sit in Layer 5 and Layer 6.

Key Takeaways
  • The OWASP LLM Top 10 (2026) is the current industry-standard framework. Eight of its ten identifiers moved from the 2025 edition, and both schemes remain in circulation – keep the translation table handy.
  • Every stage of the AI lifecycle presents a distinct attack surface, and the feedback loop from monitoring back into training means an inference-time attack can become a training-time one.
  • The 2026 rankings were the first checked against real incident data. Where belief and evidence disagree – prompt injection high on the vote, misinformation high in the record – the gap tells you something about your own priorities.
  • Excessive Agency climbed to #3 because agency is what converts a model failure into a real-world consequence. It is also the hinge into the Agentic Top 10.
  • Pick the framework by the question: OWASP LLM for what can go wrong, OWASP Agentic for what can go wrong when it acts, MITRE ATLAS for how the attacker gets from access to impact.
  • Threat actor capability determines how an attacker finds a weakness, not how much damage it does. A copied jailbreak against an over-permissioned agent is as dangerous as a novel one.

Test Your Knowledge

Ready to test your understanding of the AI attack surface and threat frameworks? Head to the quiz to see how well you can map attack vectors to the AI lifecycle.


Up next

Now that you have the full attack surface map and understand the OWASP framework, it’s time to dive into the most common and well-understood attack category: prompt injection. In the next section, you’ll see exactly how attackers manipulate LLM inputs – with sanitized examples you can study and discuss.