CyPerf Strikes: An Overview of Simulated Exploits and Vulnerabilities
Introduction
As the cybersecurity landscape continues to transform, network testing tools like CyPerf play a crucial role in simulating real-world attacks to validate defenses. Keysight's CyPerf product offers an extensive library of strikes that enable comprehensive testing of network security devices such as firewalls, intrusion prevention systems (IPS), and other security appliances. This article explores the diverse categories of strikes available in CyPerf, ranging from classic web vulnerabilities to cutting-edge AI prompt injections, presents specific examples, and provides insights into how these exploits work from a network traffic perspective. CyPerf leverages over two decades of leadership in network security testing to uncover vulnerabilities across public, private, and hybrid environments. Backed by continuous research from our Application and Threat Intelligence (ATI) team, CyPerf delivers regular updates, ensuring the most current threat simulations.
Understanding Strikes
A strike in CyPerf is a simulated attack pattern that mimics real-world malicious traffic. These strikes are generally used to test whether security devices (a.k.a. DUTs - Devices Under Test) can properly detect, block, and report malicious activities. Examples of DUTs come from companies like Cisco, Palo Alto Networks, and Fortinet, among others.
Strikes in CyPerf can be divided based on their direction:
- Client-to-Server (c2s): Exploits originating from the client targeting the server. DUTs inspect traffic from the client before reaching the server. Examples: SQL injection, RCE attempts, malicious API calls, etc.
- Server-to-Client (s2c): Malicious responses or data sent from the server to the client. DUTs inspect server responses before reaching the client. Examples: Malicious PDF in email, PII leakage in LLM response, XSS in web page, etc.
CyPerf has dedicated agents (traffic generators) that can act as both client and server endpoints. Our software-based test agents are fully infrastructure-agnostic, enabling seamless deployment across virtual machines, containers, cloud instances, or standard off-the-shelf servers - whether on-premises or in private and public cloud environments. DUTs sit inline between CyPerf endpoints. Strikes are configured in test scenarios with various parameters. Based on the DUT response, the strike can be blocked (DUT correctly identifies and blocks the strike) or allowed (strike reaches destination, which means that the DUT failed to recognize the strike). If there is no DUT configured between CyPerf endpoints, strikes are allowed in case of a successful test run, as you can see below:
Figure 1: CyPerf Strikes Statistics Dashboard
Strike Types Overview
Figure 2: CyPerf Attack Library Tab
CyPerf comes with predefined (we call them precanned) attacks, which are lists of strikes, available in the Attack Library tab. In the above image, you can see precanneds such as: 'ALL DAN Gemini AI LLM Prompt Injection', 'Auth Bypass Attacks', 'Chrome Browser Attacks', 'Critical Strikes', etc.
Figure 3: CyPerf Customize Attack Tab
In the Customize Attack tab, you can select whichever strike (including malware strikes) you want to include in your custom list. You can also add strikes to a target application, and traffic will be mapped to the same IPs.
In both tabs, you can filter attacks based on attributes such as target, vector, intent, severity, etc.
Figure 4: Strike Metadata Details
Every strike has meaningful metadata: a description, direction, severity, references (CVE, CVSS, ZDI, etc.), paper links, and keywords that can be used to categorize the strike.
CyPerf's strike library contains several types of strikes:
AI/LLM Strikes
A cutting-edge category targeting Large Language Models and AI systems (OpenAI, Gemini, and Grok are supported):
- Prompt Injection Attacks: DAN (Do Anything Now) jailbreaks, ASCII art obfuscation, CodeChameleon, invisible prompts, mathematical function-based injections
- PII Leakage Exploits: Protected Health Information (PHI), banking data, biometric information, employee records, government documents
- Evasion Techniques: Flip attacks, ReNeLLM transformations, SMILES-Prompting
Web Application Exploits
Traditional web vulnerabilities targeting applications and frameworks:
- SQL Injection
- Cross-Site Scripting - XSS
- Command Injection/Execution
- Directory/Path Traversal
- Remote Code Execution - RCE
- Authentication Bypass
- File Upload Vulnerabilities
- PHP File Include
- Insecure Deserialization
- XXE - XML External Entity
Memory Corruption Exploits
Low-level vulnerabilities in software implementations:
- Buffer Overflow: Stack and heap-based overflows
- Memory Corruption: Arbitrary memory access and manipulation
- Use After Free: Dangling pointer exploitation
- Integer Overflow: Arithmetic overflow leading to memory corruption
Enterprise Application Vulnerabilities
Targeting commercial and open-source enterprise software:
- Microsoft Products: Windows, IIS, Exchange, SharePoint
- Apache Software: HTTP Server, Tomcat, Struts, Log4j, Solr, OFBiz
- Oracle Products: WebLogic, Database, E-Business Suite
- Adobe Products: ColdFusion, Flash, Acrobat
- Other Vendors: Cisco, Atlassian, Jenkins, WordPress, Joomla, Zoho, etc.
Denial of Service Attacks
We are simulating several well-known volumetric attacks, such as Slowloris.
Malware
The library is updated monthly with the most popular malware samples, simulating their transfer over the wire.
How to Run a Test and View Statistics
In this animation, you can see how to run a test with strikes and view the resulting statistics:
Animation 1: Running a CyPerf Strikes Test
The captures can be downloaded by clicking Result -> Download -> Captures:
Figure 5: Results Button
Figure 6: Download Captures
CyPerf uses Keysight's proprietary goal-seeking algorithm to help test agents maintain stable and consistent key performance indicators (KPIs). It allows users to set objectives such as attacks per second and maximum concurrent attacks at a predetermined rate:
Figure 7: Objectives and Timeline Configuration
Examples
We will follow in this section some examples, explaining the vulnerability concept, how it is exploited, and its consequences.
Example: Strike AI LLM Prompt Injection DAN STAN - Grok
Year: 2025 | Direction: Client-to-Server (c2s) | Severity: High
Vulnerability Description: This strike targets xAI's Grok model using a "STAN" (Strive To Avoid Norms) jailbreak technique. The attack instructs the LLM to adopt an unrestricted persona that ignores safety constraints and ethical guidelines, in order to get unfiltered responses.
Figure 8: Network Capture of Strike AI LLM Prompt Injection DAN STAN - Grok
How It Works: The attacker sends a carefully crafted prompt that creates a dual-persona scenario, forcing the AI to respond both as its normal self and as an unrestricted "STAN" character. It instructs how to act when using the "STAN" character. This jailbreak template exploits the model's instruction-following capabilities to bypass content moderation and safety filters.
Consequences:
- Content Policy Bypass: Circumvents content moderation and safety filters
- Code Generation: Attackers can generate malicious code or exploit instructions
- Abuse of AI Services: Enables creation of harmful, biased, or illegal content through organization's AI infrastructure
Example: Strike AI LLM PII Leakage Protected Health Information (PHI) Disclosure - OpenAI
Year: 2024 | Direction: Server-to-Client (s2c) | Severity: High
Vulnerability Description: Especially when integrated into applications, LLMs can inadvertently expose sensitive data, proprietary algorithms, or confidential information through their outputs. Such leaks may lead to unauthorized access, privacy breaches, and intellectual property risks. This strike demonstrates a data exfiltration attack against AI systems with database access. A simple prompt discloses Protected Health Information (PHI) from connected data sources, exposing sensitive medical records. To mitigate this risk, LLM applications should implement robust data sanitization to prevent user information from being incorporated into the training model. Additionally, defining restrictions in the system prompt regarding permissible data types can help reduce the likelihood of sensitive information disclosure.
Figure 9: Network Capture of Strike AI LLM PII Leakage Protected Health Information (PHI) Disclosure - OpenAI
How It Works: Due to insufficient data sanitization, a user receives a response that includes another user's personal information. When LLMs are integrated with databases (common in RAG - Retrieval Augmented Generation systems), attackers can craft prompts that bypass access controls. Using a simple but deliberate prompt, the AI system retrieves and exposes sensitive information including patient names, medical record numbers, treatments, insurance information, etc.
Consequences:
- HIPAA Violations: Exposure of PHI can result in big fines
- RAG System Vulnerabilities: LLMs with database access create data leakage risks
- Broad Applicability: We might encounter this in various fields, getting to financial records, corporate secrets, customer data, etc.
References:
Example: Strike Langflow Code Validation Missing Authentication Vulnerability
CVE-2025-3248 | Direction: c2s | Severity: High | CVSS: 9.8
Vulnerability Description: Langflow's /api/v1/validate/code endpoint completely lacks authentication and directly executes user-supplied Python code.
Figure 10: Network Capture of Strike Langflow Code Validation Missing Authentication Vulnerability
How It Works: Attackers send malicious Python code to the vulnerable endpoint without any credentials. The code uses Python's exec() function with subprocess imports to execute arbitrary system commands.
Consequences:
- Complete Server Compromise: Achieve RCE with Langflow service user privileges
- AI Infrastructure Access: Langflow manages LLM applications, API keys, and prompts
- Data Exfiltration: Direct access to AI models, training data, and sensitive configurations
References:
Example: Strike SolarWinds Serv-U Path Traversal Vulnerability
CVE-2024-28995 | Direction: c2s | Severity: High | CVSS: 9.8
Vulnerability Description: SolarWinds Serv-U file transfer software contains a critical path traversal vulnerability. The path traversal filter validates only the platform-specific slash (/ for Linux, \ for Windows) before later normalizing the separators. Consequently, if you supply the opposite slash, the check is bypassed and the slashes are corrected afterward. This behavior represents a classic "time-of-check versus time-of-use" (TOCTOU) flaw, allowing attackers to read arbitrary files from the server without authentication.
Figure 11: Network Capture of Strike SolarWinds Serv-U Path Traversal Vulnerability
How It Works: Attackers exploit the InternalDir and InternalFile parameters by using forward slash sequences (../) to navigate the directory structure. The incomplete validation allows traversal to any readable file on the system, including Windows system files (boot.ini, SAM), Linux configuration files (/etc/passwd, /etc/shadow), SSH keys, and application configuration files containing credentials.
Consequences:
- Unauthenticated File Access: No credentials required to exploit the vulnerability
- Credential Theft: Access to configuration files containing database passwords and API keys
- Enterprise Data Exposure: Serv-U typically handles sensitive corporate file transfers
References:
Example: Strike Palo Alto Networks PAN-OS Command Injection Vulnerability
CVE-2024-3400 | Direction: c2s | Severity: Critical | CVSS: 10.0
Vulnerability Description: PAN-OS GlobalProtect contains a critical command injection vulnerability in the /global-protect/login.esp endpoint. The application fails to validate the SESSID cookie, allowing attackers to inject OS commands that execute with root privileges. This vulnerability was actively exploited in MidnightEclipse Operation.
Figure 12: Network Capture of Strike Palo Alto Networks PAN-OS Command Injection Vulnerability
How It Works: Attackers craft a malicious SESSID cookie combining directory traversal and command injection. The cookie value is written to a file path and then used in a shell command without proper sanitization. Attackers use techniques like backticks for command substitution and ${IFS} to bypass space filtering, achieving remote code execution with root privileges.
Consequences:
- Firewall Compromise: Palo Alto Networks GlobalProtect firewall device can get compromised
- Root-Level Access: Complete system control with the highest privileges
- Lateral Movement: In one successful compromise, the attacker leveraged a highly privileged service account from a Palo Alto Networks firewall to pivot into the internal network using SMB and WinRM
References:
- Zero-Day Exploitation of Unauthenticated Remote Code Execution Vulnerability in GlobalProtect (CVE-2024-3400)
- Palo Alto - Putting The Protecc In GlobalProtect (CVE-2024-3400)
Example: Strike Google Chrome NotifyCompleted Use After Free
CVE-2022-3038 | Direction: Server-to-Client (s2c) | Severity: High | CVSS: 8.8
Vulnerability Description: This vulnerability in Google Chrome's network stack allows malicious web servers to trigger a use-after-free condition during file upload operations, potentially leading to remote code execution in the victim's browser.
Figure 13: Network Capture of Strike Google Chrome NotifyCompleted Use After Free
How It Works: The attack uses malicious JavaScript served by a compromised web server to create a race condition in Chrome's resource loader. The exploit uses the FileSystem API (webkitRequestFileSystem) to create a temporary file, then initiates an upload of this file via fetch() with FormData to a controlled server. Immediately after starting the upload, the script deletes the file entry and removes the iframe before the upload completes, then recursively repeats this process to maximize exploitation chances. The critical component is a Web Worker running in parallel that continuously floods the browser's network stack with requests. This worker helps the main thread "win the PostTask race" by keeping Chrome's resource loader busy, increasing the likelihood that the file removal happens at precisely the right moment before Chrome processes the upload completion callback. When this timing succeeds, Chrome attempts to access the already-freed file object, triggering the use-after-free condition that can lead to memory corruption and potential remote code execution.
Consequences:
- Memory Corruption: Browser accesses freed memory, leading to unpredictable behavior
- Remote Code Execution: Potential RCE in browser context with user privileges
- No User Interaction: Drive-by attack triggers automatically when visiting malicious site
References:
Example: Strike Apache Log4j JndiManager JNDI Injection RCE LDAP
CVE-2021-44228 | Direction: c2s | Severity: Critical | CVSS: 10.0
Vulnerability Description: Log4Shell is one of the most critical vulnerabilities discovered in modern computing history. It allows remote code execution through JNDI (Java Naming and Directory Interface) injection in the Apache Log4j logging library, which is embedded in millions of applications worldwide.
Figure 14: Network Capture of Strike Apache Log4j JndiManager JNDI Injection RCE LDAP
How It Works: Attackers embed a specially crafted JNDI lookup string in any logged input, commonly through HTTP headers like User-Agent. This exploit uses Log4j's recursive variable expansion feature combined with sophisticated obfuscation techniques to evade detection. The ${::-x} syntax is a special expression that extracts single characters, allowing attackers to spell out "jndi:ldap" character by character instead of using the literal string that security tools might block. The ${bundle:application:...} portion uses lookups to create additional layers of nested variable references, making the malicious payload even harder to detect with pattern matching. When Log4j encounters this string in a log message, it automatically processes these variable expressions recursively, unwrapping each layer until it constructs the complete JNDI lookup URL pointing to an attacker-controlled LDAP server. The server responds with a reference to a malicious Java class, which Log4j then retrieves and instantiates, granting the attacker remote code execution with the application's full privileges.
Consequences:
- Universal Impact: Log4j is embedded in millions of applications across cloud platforms (AWS, Azure, Google Cloud), enterprise software (VMware, Cisco, Apple, X), gaming servers (Minecraft), and IoT devices
- Supply Chain Risk: Deeply embedded in software dependency chains
- Real-World Impact: Belgian Defense Ministry compromised
References:
Conclusion
CyPerf's extensive strike library provides a rich simulation environment for understanding and defending against a wide array of network-based attacks. From traditional web exploits and SQL injections to emerging AI prompt attacks, these strikes help security professionals validate their defenses across diverse threat landscapes. The examples discussed here represent just a fraction of the extensive strike library available in CyPerf. As new vulnerabilities emerge, CyPerf continues to evolve, ensuring comprehensive coverage of the latest threats in network security testing.