Intercept the request. Tamper with it. Watch the defense.
Browser → Burp Suite-style proxy → Server. Every lab gives you an editable HTTP request and a real, working defense to break against.
API & Infrastructure
Burp Suite Interception
Every request you 'trust' from the browser can be intercepted and rewritten before it reaches the server.
Open labMalicious File Upload
A file named photo.jpg can still be a fully executable PHP web shell.
Open labServer-Side Request Forgery (SSRF)
A feature that fetches a URL on the user's behalf can be tricked into fetching URLs the user was never supposed to reach.
Open labAuth, Session & Access Control
JWT Tampering
Anyone can read a JWT's payload. The only thing stopping them from editing it is the signature.
Open labHMAC Request Signing
A signature over the exact bytes of a request proves nothing in transit was altered.
Open labReplay Attack Protection
A perfectly valid, perfectly signed request — captured once and resubmitted a thousand times.
Open labInsecure Direct Object Reference (IDOR)
If an ID in the URL is the only thing standing between you and someone else's data, it isn't a security control.
Open labOpen Redirect
A redirect endpoint that trusts a client-supplied destination becomes a trusted-looking link to anywhere.
Open labMass Assignment
Binding an entire request body straight onto a database model lets the client set fields nobody meant to expose.
Open labClickjacking
If your page can be loaded inside an invisible iframe, a click the user thinks lands on one page can actually land on yours.
Open labSubdomain Takeover
A DNS record still pointing at a service you no longer own is an invitation for someone else to claim it.
Open labBusiness Logic Flaw (Negative Quantity Abuse)
Code that's technically executing exactly as written can still produce an outcome nobody intended, because nobody told it a negative number was invalid.
Open labWeb & Injection Attacks
SQL Injection
String-concatenated SQL turns user input into executable database commands.
Open labCross-Site Scripting (XSS)
If user input is ever rendered as HTML instead of text, an attacker can run their own JavaScript in someone else's browser.
Open labCross-Site Request Forgery (CSRF)
The browser will happily attach your session cookie to a request that a malicious site made you submit without knowing it.
Open labXML External Entity (XXE) Injection
A permissive XML parser will happily fetch a file (or a URL) just because a document told it to.
Open labOS Command Injection
Any code that hands user input to a shell is one metacharacter away from running the attacker's own commands.
Open labInsecure Deserialization
Deserializing untrusted data can reconstruct more than an object — in some languages, it can reconstruct an attacker's chosen code path.
Open labServer-Side Template Injection (SSTI)
A template engine that evaluates user input as template syntax instead of plain data can be walked straight into remote code execution.
Open labGraphQL Introspection & Batching Abuse
A flexible query language is flexible for attackers too — introspection maps out your entire schema, and nested queries can multiply cost exponentially.
Open labPayments & Business Logic
Client-Side Price Tampering
If the checkout price comes from the browser instead of the database, the browser gets to pick the price.
Open labRace Condition / TOCTOU (Coupon Double-Redemption)
Between checking a coupon is unused and marking it used, a fast enough attacker can slip through twice.
Open labPayment Webhook Signature Bypass
A payment webhook endpoint that doesn't verify its sender will fulfill orders for payments that never happened.
Open labAI & LLM Security
Prompt Injection
An LLM can't reliably tell the difference between your instructions and text that just happens to look like instructions.
Open labInsecure Output Handling (LLM → XSS/Code Execution)
Treating an LLM's output as safe just because it came from your own model is the same mistake as trusting any other untrusted input.
Open labSensitive Information Disclosure via LLM
A model that has access to your system prompt, other users' data, or internal documentation can be talked into repeating it back.
Open labExcessive Agency (LLM Agent Tool Abuse)
An agent that can call any tool it wants, without a human checking, will eventually call the wrong one.
Open labModel Denial of Service
A single cleverly-shaped request can consume disproportionately more compute than a normal one — and LLM calls are not cheap to begin with.
Open labInsecure Function-Calling / Plugin Design
If a tool's parameters are free-form strings instead of validated, typed fields, the model's word choice becomes your input validation.
Open labRAG / Vector Store Cross-Tenant Data Leakage
A retrieval step that forgets to filter by tenant will happily hand the model someone else's private documents.
Open lab