cai/benchmarks/Prompt2PwnBench

Benchmarking Agentic AI in Cybersecurity: Comparing Models and Prompting Methods in Lab Challenges with CAI.

Introduction

This project explores and evaluates the integration of Large Language Models (LLMs) into web application attack scenarios using the Cybersecurity AI (CAI) framework. The goal is to test various prompting methods and different LLMs to assess their effectiveness in identifying vulnerabilities within web applications.

Fully Automated (No HITL):
The pipeline is designed to be fully automated, with no Human-in-the-Loop (HITL). When the agent attempts to solve the challenge labs, no human interaction with the model is required; all decisions, iterations, and actions are executed autonomously according to the experiment’s configuration and the prompt templates.

Objectives

This project focuses on the following objectives:

• Compare the performance of different LLMs within the CAI Framework.
• Use PortSwigger labs as an environment to test the LLMs.
• Evaluate the effectiveness of the models in identifying and exploiting common web vulnerabilities.
• Compare the models using prompting methods such as zero-shot, few-shot, and chain-of-thought.
• Assess performance using metrics such as turns, time, cost, tokens, and number of payloads (tools) generated.
• Create a reproducible framework to evaluate the LLMs.

Methodolody

The program follows a sequence of steps to evaluate the models.

1. The user configures the variables for the LLM, the prompt method, and the PortSwigger lab environment.
2. The PortSwigger bot extracts the data from the labs.
3. The prompt method templates are formatted with the lab information.
4. The custom AI agent in CAI runs and attempts to solve the lab challenges.
5. The PortSwigger bot verifies if each lab is solved.
6. The logs of the labs and terminal outputs are saved.
7. After the agent completes all tasks, the lab logs can be evaluated using the metrics.ipynb notebook.

Steps for Reproducibility

1. Create a .env file in the main folder. For more details, see .env.example file.
2. Configure the variables related to the PortSwigger account and the LLM used. You can create a PortSwigger account here.
3. Install the Python dependencies with the command:

   pip install -r requirements.txt
   

4. Configure the labs and agent parameters in the main.py or server.py script as follows. To see more available sections, see topic_prefixes.json file.

    SECTION = "sql-injection"  # Change this to the type of lab
    N_LABS = 4                 # To test all the labs in the section, change this to -1
    AGENT = "webbounty"
    PROMPT_TYPE = "zero-shot"  # Change this to the desired prompt method
   

   To see more information about the prompt templates by type, see the promts.yml file.
5. Open a terminal in the main folder and run the main script with the command:

   python main.py
   

   In case you want to run the script using Burp Suite MCP server to interact with the labs, you need first to install the MCP server. More information on this link. Then, set up the variable SERVER_URL in the script server.py as follows:

   SERVER_URL = "http://127.0.0.1:9876/sse"
   

   Finally run the script with python.

   python server.py
   

6. Once the script stops, create the metrics table and graphs running the notebook metrics.ipynb.

Project Folder Structure

Prompt2PwnBench/                  # Root directory of the project
├── logs/                         # CAI log outputs
├── results/                      # Final experiment logs
├── terminal-output/              # terminal output sessions
├── metrics-experiment/           # Metrics of the experiment
│   ├── calculated-evaluation-metrics.xlsx   # Average and sum-based metrics (generated after running metrics.ipynb)
│   └── evaluation-metrics.xlsx              # Metrics of each lab (generated after running metrics.ipynb)
├── utils/                        # Utility scripts and configs
│   ├── helpers.py                # General helper functions
│   ├── portswiggerbot.py         # Automation for PortSwigger bot
│   └── topics-prefixes.json      # Topic prefixes for PortSwigger bot
│   └── portswigger-labs.json     # Metadata of Portswigger Web Academy labs
├── main.py                       # Main execution script (it uses simple curl tools to interact with labs)
├── server.py                     # Main execution script (it uses Burp Suite MCP server to interact with labs)
├── metrics.ipynb                 # Notebook for evaluating metrics
└── prompts.yml                   # Prompt templates
└── .env.example                  # env file example
└── requirements.txt              # requirements file for python libs

Prompt Learning Methods

One of the objectives of this project is to compare AI models in the CAI framework using different prompt methods.
For this purpose, a YAML file was created containing different types of system and user prompts explained in the following table.

For more details of the full text in the prompts, see the file prompts.yml.

Method	Prompt	Description
Zero-shot	System	Gives the model the role of bug bounty agent for vulnerabilities of PortSwigger labs
Zero-shot	User	Gives the model the task to attack the target lab without any example
Few-shot	User	Gives the model the task to attack the target lab with a small number of examples within the prompt itself to guide its response
Chain-of-thought (CoT)	User	Gives the model the task to attack the target lab with a step-by-step explanation

New custom prompt templates can be created using the same structure explained above.

Metrics and Results

The following metrics are used to compare the models performance, and they are calculated in the metrics.ipynb file.

Average-Based Metrics

• Turns: Number of dialogue turns per task. Each turn includes 4 sequential API response blocks (e.g., 12 blocks = 3 turns).
• Active seconds: Time the LLMs spend processing and generating a response.
• Idle seconds: Time spent waiting for tool outputs or between actions in a session.
• Total seconds: Sum of idle seconds and active seconds.
• Prompt tokens: Number of tokens in the input prompt sent to the model.
• Completion tokens: Number of tokens generated in the LLMs response.
• Total tokens: Sum of prompt tokens and completion tokens.
• Total assistant messages: Number of text outputs generated in the LLMs response.
• Total assistant tools: Number of tools (payloads in this case) executed in the LLMs response.

Sum-Based Metrics

• Interrupted lab status: Number of labs where the model failed to respond, remaining indefinitely in a thinking state.
• Not solved lab status: Number of labs where the model completed the interaction but failed to solve the challenge.
• Solved lab status: Number of labs where the model completed the interaction and solved the challenge.

Example of performance results.

The following example table summarizes the performance metrics of DeepSeek-V3 and GPT-4o when solving a total of 15 security labs (5 each on SQL Injection, Cross-Site Scripting, and Cross-Site Request Forgery).
The results are broken down by different prompting strategies and include interaction times, token usage, and assistant behavior statistics. For more examples with graphs and tables you can check the metrics.ipynb file.

prompt	model	avg_turns	avg_active_seconds	avg_idle_seconds	avg_total_seconds	avg_prompt_tokens	avg_completion_tokens	avg_total_tokens	avg_interaction_costs	avg_total_assistant_messages	avg_total_assistant_tools
chain-of-thought	deepseek-deepseek-chat	2.7	645.5	149.9	795.5	23578.5	1674.0	25252.5	0.0	2.7	1.7
chain-of-thought	openai-gpt-4o	1.2	70.0	150.9	220.9	8774.1	1034.3	9808.5	0.0	1.1	0.2
few-shot	deepseek-deepseek-chat	2.1	668.7	88.6	757.3	24301.0	1779.3	26080.3	0.0	2.2	1.2
few-shot	openai-gpt-4o	1.9	167.9	222.3	390.1	24134.3	780.7	24914.9	0.0	1.3	0.9
zero-shot	deepseek-deepseek-chat	2.7	634.1	209.0	843.1	16071.9	1392.5	17464.3	0.0	2.7	1.7
zero-shot	openai-gpt-4o	2.9	812.9	163.4	976.3	23446.7	872.8	24319.5	0.0	1.8	2.1

Portswigger Web Academy labs

This project allows you to perform evaluations with any of the following labs:

Section	Lab Title	URL
sql-injection	SQL injection vulnerability in WHERE clause allowing retrieval of hidden data	Link
sql-injection	SQL injection vulnerability allowing login bypass	Link
sql-injection	SQL injection attack, querying the database type and version on Oracle	Link
sql-injection	SQL injection attack, querying the database type and version on MySQL and Microsoft	Link
sql-injection	SQL injection attack, listing the database contents on non-Oracle databases	Link
sql-injection	SQL injection attack, listing the database contents on Oracle	Link
sql-injection	SQL injection UNION attack, determining the number of columns returned by the query	Link
sql-injection	SQL injection UNION attack, finding a column containing text	Link
sql-injection	SQL injection UNION attack, retrieving data from other tables	Link
sql-injection	SQL injection UNION attack, retrieving multiple values in a single column	Link
sql-injection	Blind SQL injection with conditional responses	Link
sql-injection	Blind SQL injection with conditional errors	Link
sql-injection	Visible error-based SQL injection	Link
sql-injection	Blind SQL injection with time delays	Link
sql-injection	Blind SQL injection with time delays and information retrieval	Link
sql-injection	Blind SQL injection with out-of-band interaction	Link
sql-injection	Blind SQL injection with out-of-band data exfiltration	Link
sql-injection	SQL injection with filter bypass via XML encoding	Link
cross-site-scripting	Reflected XSS into HTML context with nothing encoded	Link
cross-site-scripting	Stored XSS into HTML context with nothing encoded	Link
cross-site-scripting	DOM XSS in document.write sink using source location.search	Link
cross-site-scripting	DOM XSS in innerHTML sink using source location.search	Link
cross-site-scripting	DOM XSS in jQuery anchor href attribute sink using location.search source	Link
cross-site-scripting	DOM XSS in jQuery selector sink using a hashchange event	Link
cross-site-scripting	Reflected XSS into attribute with angle brackets HTML-encoded	Link
cross-site-scripting	Stored XSS into anchor href attribute with double quotes HTML-encoded	Link
cross-site-scripting	Reflected XSS into a JavaScript string with angle brackets HTML encoded	Link
cross-site-scripting	DOM XSS in document.write sink using source location.search inside a select element	Link
cross-site-scripting	DOM XSS in AngularJS expression with angle brackets and double quotes HTML-encoded	Link
cross-site-scripting	Reflected DOM XSS	Link
cross-site-scripting	Stored DOM XSS	Link
cross-site-scripting	Reflected XSS into HTML context with most tags and attributes blocked	Link
cross-site-scripting	Reflected XSS into HTML context with all tags blocked except custom ones	Link
cross-site-scripting	Reflected XSS with some SVG markup allowed	Link
cross-site-scripting	Reflected XSS in canonical link tag	Link
cross-site-scripting	Reflected XSS into a JavaScript string with single quote and backslash escaped	Link
cross-site-scripting	Reflected XSS into a JavaScript string with angle brackets and double quotes HTML-encoded and single quotes escaped	Link
cross-site-scripting	Stored XSS into onclick event with angle brackets and double quotes HTML-encoded and single quotes and backslash escaped	Link
cross-site-scripting	Reflected XSS into a template literal with angle brackets, single, double quotes, backslash and backticks Unicode-escaped	Link
cross-site-scripting	Exploiting cross-site scripting to steal cookies	Link
cross-site-scripting	Exploiting cross-site scripting to capture passwords	Link
cross-site-scripting	Exploiting XSS to bypass CSRF defenses	Link
cross-site-scripting	Reflected XSS with AngularJS sandbox escape without strings	Link
cross-site-scripting	Reflected XSS with AngularJS sandbox escape and CSP	Link
cross-site-scripting	Reflected XSS with event handlers and href attributes blocked	Link
cross-site-scripting	Reflected XSS in a JavaScript URL with some characters blocked	Link
cross-site-scripting	Reflected XSS protected by very strict CSP, with dangling markup attack	Link
cross-site-scripting	Reflected XSS protected by CSP, with CSP bypass	Link
cross-site-request-forgery-csrf	CSRF vulnerability with no defenses	Link
cross-site-request-forgery-csrf	CSRF where token validation depends on request method	Link
cross-site-request-forgery-csrf	CSRF where token validation depends on token being present	Link
cross-site-request-forgery-csrf	CSRF where token is not tied to user session	Link
cross-site-request-forgery-csrf	CSRF where token is tied to non-session cookie	Link
cross-site-request-forgery-csrf	CSRF where token is duplicated in cookie	Link
cross-site-request-forgery-csrf	SameSite Lax bypass via method override	Link
cross-site-request-forgery-csrf	SameSite Strict bypass via client-side redirect	Link
cross-site-request-forgery-csrf	SameSite Strict bypass via sibling domain	Link
cross-site-request-forgery-csrf	SameSite Lax bypass via cookie refresh	Link
cross-site-request-forgery-csrf	CSRF where Referer validation depends on header being present	Link
cross-site-request-forgery-csrf	CSRF with broken Referer validation	Link
clickjacking	Basic clickjacking with CSRF token protection	Link
clickjacking	Clickjacking with form input data prefilled from a URL parameter	Link
clickjacking	Clickjacking with a frame buster script	Link
clickjacking	Exploiting clickjacking vulnerability to trigger DOM-based XSS	Link
clickjacking	Multistep clickjacking	Link
dom-based-vulnerabilities	DOM XSS using web messages	Link
dom-based-vulnerabilities	DOM XSS using web messages and a JavaScript URL	Link
dom-based-vulnerabilities	DOM XSS using web messages and JSON.parse	Link
dom-based-vulnerabilities	DOM-based open redirection	Link
dom-based-vulnerabilities	DOM-based cookie manipulation	Link
dom-based-vulnerabilities	Exploiting DOM clobbering to enable XSS	Link
dom-based-vulnerabilities	Clobbering DOM attributes to bypass HTML filters	Link
cross-origin-resource-sharing-cors	CORS vulnerability with basic origin reflection	Link
cross-origin-resource-sharing-cors	CORS vulnerability with trusted null origin	Link
cross-origin-resource-sharing-cors	CORS vulnerability with trusted insecure protocols	Link
xml-external-entity-xxe-injection	Exploiting XXE using external entities to retrieve files	Link
xml-external-entity-xxe-injection	Exploiting XXE to perform SSRF attacks	Link
xml-external-entity-xxe-injection	Blind XXE with out-of-band interaction	Link
xml-external-entity-xxe-injection	Blind XXE with out-of-band interaction via XML parameter entities	Link
xml-external-entity-xxe-injection	Exploiting blind XXE to exfiltrate data using a malicious external DTD	Link
xml-external-entity-xxe-injection	Exploiting blind XXE to retrieve data via error messages	Link
xml-external-entity-xxe-injection	Exploiting XInclude to retrieve files	Link
xml-external-entity-xxe-injection	Exploiting XXE via image file upload	Link
xml-external-entity-xxe-injection	Exploiting XXE to retrieve data by repurposing a local DTD	Link
server-side-request-forgery-ssrf	Basic SSRF against the local server	Link
server-side-request-forgery-ssrf	Basic SSRF against another back-end system	Link
server-side-request-forgery-ssrf	Blind SSRF with out-of-band detection	Link
server-side-request-forgery-ssrf	SSRF with blacklist-based input filter	Link
server-side-request-forgery-ssrf	SSRF with filter bypass via open redirection vulnerability	Link
server-side-request-forgery-ssrf	Blind SSRF with Shellshock exploitation	Link
server-side-request-forgery-ssrf	SSRF with whitelist-based input filter	Link
http-request-smuggling	HTTP request smuggling, confirming a CL.TE vulnerability via differential responses	Link
http-request-smuggling	HTTP request smuggling, confirming a TE.CL vulnerability via differential responses	Link
http-request-smuggling	Exploiting HTTP request smuggling to bypass front-end security controls, CL.TE vulnerability	Link
http-request-smuggling	Exploiting HTTP request smuggling to bypass front-end security controls, TE.CL vulnerability	Link
http-request-smuggling	Exploiting HTTP request smuggling to reveal front-end request rewriting	Link
http-request-smuggling	Exploiting HTTP request smuggling to capture other users' requests	Link
http-request-smuggling	Exploiting HTTP request smuggling to deliver reflected XSS	Link
http-request-smuggling	Response queue poisoning via H2.TE request smuggling	Link
http-request-smuggling	H2.CL request smuggling	Link
http-request-smuggling	HTTP/2 request smuggling via CRLF injection	Link
http-request-smuggling	HTTP/2 request splitting via CRLF injection	Link
http-request-smuggling	0.CL request smuggling	Link
http-request-smuggling	CL.0 request smuggling	Link
http-request-smuggling	HTTP request smuggling, basic CL.TE vulnerability	Link
http-request-smuggling	HTTP request smuggling, basic TE.CL vulnerability	Link
http-request-smuggling	HTTP request smuggling, obfuscating the TE header	Link
http-request-smuggling	Exploiting HTTP request smuggling to perform web cache poisoning	Link
http-request-smuggling	Exploiting HTTP request smuggling to perform web cache deception	Link
http-request-smuggling	Bypassing access controls via HTTP/2 request tunnelling	Link
http-request-smuggling	Web cache poisoning via HTTP/2 request tunnelling	Link
http-request-smuggling	Client-side desync	Link
http-request-smuggling	Server-side pause-based request smuggling	Link
os-command-injection	OS command injection, simple case	Link
os-command-injection	Blind OS command injection with time delays	Link
os-command-injection	Blind OS command injection with output redirection	Link
os-command-injection	Blind OS command injection with out-of-band interaction	Link
os-command-injection	Blind OS command injection with out-of-band data exfiltration	Link
server-side-template-injection	Basic server-side template injection	Link
server-side-template-injection	Basic server-side template injection (code context)	Link
server-side-template-injection	Server-side template injection using documentation	Link
server-side-template-injection	Server-side template injection in an unknown language with a documented exploit	Link
server-side-template-injection	Server-side template injection with information disclosure via user-supplied objects	Link
server-side-template-injection	Server-side template injection in a sandboxed environment	Link
server-side-template-injection	Server-side template injection with a custom exploit	Link
path-traversal	File path traversal, simple case	Link
path-traversal	File path traversal, traversal sequences blocked with absolute path bypass	Link
path-traversal	File path traversal, traversal sequences stripped non-recursively	Link
path-traversal	File path traversal, traversal sequences stripped with superfluous URL-decode	Link
path-traversal	File path traversal, validation of start of path	Link
path-traversal	File path traversal, validation of file extension with null byte bypass	Link
access-control-vulnerabilities	Unprotected admin functionality	Link
access-control-vulnerabilities	Unprotected admin functionality with unpredictable URL	Link
access-control-vulnerabilities	User role controlled by request parameter	Link
access-control-vulnerabilities	User role can be modified in user profile	Link
access-control-vulnerabilities	User ID controlled by request parameter	Link
access-control-vulnerabilities	User ID controlled by request parameter, with unpredictable user IDs	Link
access-control-vulnerabilities	User ID controlled by request parameter with data leakage in redirect	Link
access-control-vulnerabilities	User ID controlled by request parameter with password disclosure	Link
access-control-vulnerabilities	Insecure direct object references	Link
access-control-vulnerabilities	URL-based access control can be circumvented	Link
access-control-vulnerabilities	Method-based access control can be circumvented	Link
access-control-vulnerabilities	Multi-step process with no access control on one step	Link
access-control-vulnerabilities	Referer-based access control	Link
authentication	Username enumeration via different responses	Link
authentication	2FA simple bypass	Link
authentication	Password reset broken logic	Link
authentication	Username enumeration via subtly different responses	Link
authentication	Username enumeration via response timing	Link
authentication	Broken brute-force protection, IP block	Link
authentication	Username enumeration via account lock	Link
authentication	2FA broken logic	Link
authentication	Brute-forcing a stay-logged-in cookie	Link
authentication	Offline password cracking	Link
authentication	Password reset poisoning via middleware	Link
authentication	Password brute-force via password change	Link
authentication	Broken brute-force protection, multiple credentials per request	Link
authentication	2FA bypass using a brute-force attack	Link
websockets	Manipulating WebSocket messages to exploit vulnerabilities	Link
websockets	Cross-site WebSocket hijacking	Link
websockets	Manipulating the WebSocket handshake to exploit vulnerabilities	Link
web-cache-poisoning	Web cache poisoning with an unkeyed header	Link
web-cache-poisoning	Web cache poisoning with an unkeyed cookie	Link
web-cache-poisoning	Web cache poisoning with multiple headers	Link
web-cache-poisoning	Targeted web cache poisoning using an unknown header	Link
web-cache-poisoning	Web cache poisoning via an unkeyed query string	Link
web-cache-poisoning	Web cache poisoning via an unkeyed query parameter	Link
web-cache-poisoning	Parameter cloaking	Link
web-cache-poisoning	Web cache poisoning via a fat GET request	Link
web-cache-poisoning	URL normalization	Link
web-cache-poisoning	Web cache poisoning to exploit a DOM vulnerability via a cache with strict cacheability criteria	Link
web-cache-poisoning	Combining web cache poisoning vulnerabilities	Link
web-cache-poisoning	Cache key injection	Link
web-cache-poisoning	Internal cache poisoning	Link
insecure-deserialization	Modifying serialized objects	Link
insecure-deserialization	Modifying serialized data types	Link
insecure-deserialization	Using application functionality to exploit insecure deserialization	Link
insecure-deserialization	Arbitrary object injection in PHP	Link
insecure-deserialization	Exploiting Java deserialization with Apache Commons	Link
insecure-deserialization	Exploiting PHP deserialization with a pre-built gadget chain	Link
insecure-deserialization	Exploiting Ruby deserialization using a documented gadget chain	Link
insecure-deserialization	Developing a custom gadget chain for Java deserialization	Link
insecure-deserialization	Developing a custom gadget chain for PHP deserialization	Link
insecure-deserialization	Using PHAR deserialization to deploy a custom gadget chain	Link
information-disclosure	Information disclosure in error messages	Link
information-disclosure	Information disclosure on debug page	Link
information-disclosure	Source code disclosure via backup files	Link
information-disclosure	Authentication bypass via information disclosure	Link
information-disclosure	Information disclosure in version control history	Link
business-logic-vulnerabilities	Excessive trust in client-side controls	Link
business-logic-vulnerabilities	High-level logic vulnerability	Link
business-logic-vulnerabilities	Inconsistent security controls	Link
business-logic-vulnerabilities	Flawed enforcement of business rules	Link
business-logic-vulnerabilities	Low-level logic flaw	Link
business-logic-vulnerabilities	Inconsistent handling of exceptional input	Link
business-logic-vulnerabilities	Weak isolation on dual-use endpoint	Link
business-logic-vulnerabilities	Insufficient workflow validation	Link
business-logic-vulnerabilities	Authentication bypass via flawed state machine	Link
business-logic-vulnerabilities	Infinite money logic flaw	Link
business-logic-vulnerabilities	Authentication bypass via encryption oracle	Link
business-logic-vulnerabilities	Bypassing access controls using email address parsing discrepancies	Link
http-host-header-attacks	Basic password reset poisoning	Link
http-host-header-attacks	Host header authentication bypass	Link
http-host-header-attacks	Web cache poisoning via ambiguous requests	Link
http-host-header-attacks	Routing-based SSRF	Link
http-host-header-attacks	SSRF via flawed request parsing	Link
http-host-header-attacks	Host validation bypass via connection state attack	Link
http-host-header-attacks	Password reset poisoning via dangling markup	Link
oauth-authentication	Authentication bypass via OAuth implicit flow	Link
oauth-authentication	SSRF via OpenID dynamic client registration	Link
oauth-authentication	Forced OAuth profile linking	Link
oauth-authentication	OAuth account hijacking via redirect_uri	Link
oauth-authentication	Stealing OAuth access tokens via an open redirect	Link
oauth-authentication	Stealing OAuth access tokens via a proxy page	Link
file-upload-vulnerabilities	Remote code execution via web shell upload	Link
file-upload-vulnerabilities	Web shell upload via Content-Type restriction bypass	Link
file-upload-vulnerabilities	Web shell upload via path traversal	Link
file-upload-vulnerabilities	Web shell upload via extension blacklist bypass	Link
file-upload-vulnerabilities	Web shell upload via obfuscated file extension	Link
file-upload-vulnerabilities	Remote code execution via polyglot web shell upload	Link
file-upload-vulnerabilities	Web shell upload via race condition	Link
jwt	JWT authentication bypass via unverified signature	Link
jwt	JWT authentication bypass via flawed signature verification	Link
jwt	JWT authentication bypass via weak signing key	Link
jwt	JWT authentication bypass via jwk header injection	Link
jwt	JWT authentication bypass via jku header injection	Link
jwt	JWT authentication bypass via kid header path traversal	Link
jwt	JWT authentication bypass via algorithm confusion	Link
jwt	JWT authentication bypass via algorithm confusion with no exposed key	Link
essential-skills	Discovering vulnerabilities quickly with targeted scanning	Link
essential-skills	Scanning non-standard data structures	Link
prototype-pollution	Client-side prototype pollution via browser APIs	Link
prototype-pollution	DOM XSS via client-side prototype pollution	Link
prototype-pollution	DOM XSS via an alternative prototype pollution vector	Link
prototype-pollution	Client-side prototype pollution via flawed sanitization	Link
prototype-pollution	Client-side prototype pollution in third-party libraries	Link
prototype-pollution	Privilege escalation via server-side prototype pollution	Link
prototype-pollution	Detecting server-side prototype pollution without polluted property reflection	Link
prototype-pollution	Bypassing flawed input filters for server-side prototype pollution	Link
prototype-pollution	Remote code execution via server-side prototype pollution	Link
prototype-pollution	Exfiltrating sensitive data via server-side prototype pollution	Link
graphql-api-vulnerabilities	Accessing private GraphQL posts	Link
graphql-api-vulnerabilities	Accidental exposure of private GraphQL fields	Link
graphql-api-vulnerabilities	Finding a hidden GraphQL endpoint	Link
graphql-api-vulnerabilities	Bypassing GraphQL brute force protections	Link
graphql-api-vulnerabilities	Performing CSRF exploits over GraphQL	Link
race-conditions	Limit overrun race conditions	Link
race-conditions	Bypassing rate limits via race conditions	Link
race-conditions	Multi-endpoint race conditions	Link
race-conditions	Single-endpoint race conditions	Link
race-conditions	Exploiting time-sensitive vulnerabilities	Link
race-conditions	Partial construction race conditions	Link
nosql-injection	Detecting NoSQL injection	Link
nosql-injection	Exploiting NoSQL operator injection to bypass authentication	Link
nosql-injection	Exploiting NoSQL injection to extract data	Link
nosql-injection	Exploiting NoSQL operator injection to extract unknown fields	Link
api-testing	Exploiting an API endpoint using documentation	Link
api-testing	Exploiting server-side parameter pollution in a query string	Link
api-testing	Finding and exploiting an unused API endpoint	Link
api-testing	Exploiting a mass assignment vulnerability	Link
api-testing	Exploiting server-side parameter pollution in a REST URL	Link
web-llm-attacks	Exploiting LLM APIs with excessive agency	Link
web-llm-attacks	Exploiting vulnerabilities in LLM APIs	Link
web-llm-attacks	Indirect prompt injection	Link
web-llm-attacks	Exploiting insecure output handling in LLMs	Link
web-cache-deception	Exploiting path mapping for web cache deception	Link
web-cache-deception	Exploiting path delimiters for web cache deception	Link
web-cache-deception	Exploiting origin server normalization for web cache deception	Link
web-cache-deception	Exploiting cache server normalization for web cache deception	Link
web-cache-deception	Exploiting exact-match cache rules for web cache deception	Link