White Paper · Attack Path Research
Five anonymized, real-world exploit chains and why isolated findings understate real risk.
Integrity and anonymization note
The case studies in this paper are drawn from real FireCompass engagements and have been anonymized for publication. Client names, hostnames, endpoints, payloads, and other identifying details have been removed or generalized. The proprietary techniques the FireCompass agents use to discover and chain these conditions are intentionally not described. Each chain reflects findings that were observed and validated; nothing has been added for narrative effect.
Executive overview
Most security programs still test assets one at a time and triage findings one at a time. Attackers do neither. They combine weaknesses that look minor in isolation into paths that end in account takeover, remote code execution, or access to data and systems that no single finding would have reached. The gap between how defenders measure risk and how attackers realize it is where breaches happen.
This paper presents five anonymized, real-world chains uncovered by FireCompass autonomous penetration-testing agents. In each, individually unremarkable issues, a redacted endpoint, a permissive allowlist, a reused credential, an unthrottled form, combined into a materially serious outcome. None of the five required a novel vulnerability class. Each required something most tooling does not do: following a finding past the point where a scanner would stop, and testing whether it connects to the next one.
Risk lives in the connections between findings, not only in the findings themselves.
A control that holds on its own can still be the weak link in a chain. Severity assigned to an isolated issue routinely understates the impact that issue enables when combined with its neighbors.
For security leaders, the implication is about coverage and method: point-in-time, sampled, finding-by-finding testing cannot surface attack paths it never assembles. Continuous, exploit-validated, path-aware testing can. The case studies below show what that difference looks like in practice.
Why attack chains defeat finding-by-finding testing
Three structural habits leave organizations exposed even when they run regular penetration tests, and attackers exploit all three at once.
A medium-severity misconfiguration and a low-severity information disclosure are each scheduled on their own timelines, often weeks or quarters apart. The attacker who connects them does not wait for either remediation window. The severity of a chain is governed by where it ends, not by the average of its links.
Redaction on one endpoint, a CAPTCHA on one login path, or an allowlist that names a reputable domain all read as “controlled” on a checklist. The cases that follow show each of these defeated not because the control was absent, but because it was incomplete in a way that only became visible when an agent kept going.
An average organization deeply tests only a fraction of its assets each year, while attackers continuously probe everything. Defenders see isolated, noisy alerts, while attackers chain findings, reuse credentials, and pivot between apps and infrastructure. The remedy is not more alerts. It is validated proof of which paths are actually walkable.
How to read these case studies
Each case is presented the same way: a short narrative of what the agents found and how the conditions connected; a path diagram showing the route visually; an attack-path table breaking the path into discrete steps with severity; and a key takeaway.
| Severity | Meaning |
|---|---|
| CRITICAL | Direct, high-confidence path to severe impact: remote code execution, full account takeover, or access to sensitive systems or data. Address immediately. |
| HIGH | Strong likelihood of significant impact, typically requiring one additional condition or a feasible attacker action. Prioritize. |
| MEDIUM | Meaningful weakness that materially contributes to a chain or exposes useful information. Remediate on a planned timeline. |
| LOW | Limited direct impact in isolation; relevant mainly as a contributing factor. |
| INFO | Observation or disclosure with no direct impact alone, but useful to an attacker for reconnaissance or chaining. |
A note on the step rows. Some rows in the attack-path tables describe agent actions or reconnaissance rather than vulnerabilities; these are labeled STEP and carry no severity of their own.
Case study 1: Content Security Policy bypass to stored XSS
During testing of an authenticated web application, the agents identified a ticket-submission feature whose input was stored server-side and later rendered on a ticket-listing page within an authenticated session, the classic precondition for stored XSS. The application, however, enforced a Content Security Policy that blocked inline script execution, so a conventional payload placed in the ticket title could not run. Many automated tools record a possible issue here and stop.
The agents instead parsed the full CSP and identified the weakness that mattered: the policy allowlisted a broad set of external origins, among them a widely used, publicly reachable domain that also exposes a usable public API endpoint. Because a browser trusts every endpoint an allowlisted origin serves, not merely its homepage, the payload could be delivered through that trusted endpoint. The CSP raised no objection, the stored payload executed, and the cross-site scripting condition was confirmed with a working proof of concept.
Figure 1. The CSP held against a direct payload; the chain routed around it through a trusted allowlisted origin.
| # | Stage | What the agents did or found | Severity |
|---|---|---|---|
| 1 | Discovery | Identified a ticket-submission feature; input was stored and later rendered in an authenticated ticket-listing view. | STEP |
| 2 | Control | The Content Security Policy blocked inline script execution, preventing a conventional stored-XSS payload from firing. | STEP |
| 3 | Analysis | Parsed the full CSP and flagged an over-permissive allowlist trusting a popular public domain that exposes a usable API endpoint. | INFO |
| 4 | Bypass | Delivered the payload through the trusted, allowlisted origin; because the policy explicitly trusted that origin, the browser permitted it. | STEP |
| 5 | Impact | Stored XSS executed within an authenticated session; proof of concept confirmed. | HIGH |
Case study 2: Spring Boot Actuator exposure to remote code execution
The entry point was a Spring Boot application exposing its Actuator endpoints to the internet. Sensitive values on the /env endpoint were redacted, a control that, in isolation, looked adequate. The heap dump told a different story: once downloaded and parsed, /heapdump contained the same environment variables in cleartext, because redaction applied to the endpoint’s output, not to the live objects held in memory.
The recovered values were not, by themselves, secret: S3 bucket names and regions. The bucket, however, was configured for public read access, turning a benign disclosure into an exposure. Its contents included files never intended to be public, among them an internal configuration file referencing an internal portal that was itself publicly reachable. The portal presented a login page, but the same bucket held the corresponding credentials, base64-encoded rather than encrypted and therefore trivially decoded. Authenticated to the portal, the agents reached a search feature backed by a Flask application using the Jinja2 templating engine. The search parameter was vulnerable to server-side template injection, which yielded remote code execution on the host.
Figure 2. A redacted endpoint, a public bucket, and encoding mistaken for encryption combine into full server compromise.
| # | Stage | What the agents did or found | Severity |
|---|---|---|---|
| 1 | Exposure | Spring Boot Actuator endpoints were reachable from the public internet. | INFO |
| 2 | Disclosure | /env redacted secrets, but /heapdump returned the same environment variables in cleartext from live memory. | INFO |
| 3 | Recon | Recovered an S3 bucket name and region, not secrets in themselves. | STEP |
| 4 | Misconfiguration | The referenced S3 bucket allowed public read access. | MEDIUM |
| 5 | Disclosure | The bucket held non-public files, including an internal configuration file linking to a publicly reachable internal portal. | MEDIUM |
| 6 | Access | Base64-encoded portal credentials in the bucket were decoded and used to authenticate. | HIGH |
| 7 | Exploitation | The Jinja2-backed search parameter on the Flask portal was vulnerable to SSTI, yielding remote code execution. | CRITICAL |
Case study 3: Five findings, two converging paths to critical exposure
A framing note for accuracy. These five findings were confirmed independently. This paper presents them as two converging attack paths, the way an attacker would assemble them, rather than asserting a single proven linear chain. The value of the case is exactly that: each finding’s isolated severity hides how they reinforce one another.
Path A: account takeover
A login endpoint intended to be protected by Cloudflare Turnstile could be reached through a separate, unprotected entry point, allowing automated requests to proceed without completing the challenge. The OTP verification endpoint used during account activation accepted repeated invalid submissions without effective rate limiting or lockout, making OTP brute force practical at scale, particularly from distributed sources. And a bypass in the API login flow defeated multi-factor authentication for affected accounts. Each of these controls, bot protection, rate limiting, and a second factor, is independently expected to stop account takeover; here all three were undermined.
Path B: infrastructure exposure
A Prometheus node_exporter was exposed to the public internet on its standard port without authentication, leaking detailed host and environment fingerprinting. Separately, a server-side request forgery flaw in a URL-handling endpoint allowed unauthenticated, attacker-controlled outbound requests, and those requests reached loopback and link-local metadata addresses, a server-side foothold and a classic precursor to deeper compromise.
Path A
↓
↓
↓
Path B
↓
↓
↓
Figure 3. Two reinforcing paths. Authentication controls fall in sequence on one; recon plus SSRF establish a foothold on the other.
| Path | Finding | Detail | Severity |
|---|---|---|---|
| A | Turnstile/CAPTCHA bypass | A login endpoint reachable outside Turnstile protection accepted automated requests without a valid challenge token. | CRITICAL |
| A | OTP brute force | OTP verification accepted repeated invalid codes without effective rate limiting or account lockout. | CRITICAL |
| A | MFA bypass | The API login flow could be bypassed for MFA-enabled accounts, defeating the second factor. | CRITICAL |
| B | Exposed node_exporter | Prometheus node_exporter was public and unauthenticated, leaking host and environment fingerprinting and runtime profiles. | HIGH |
| B | SSRF | A URL-handling endpoint allowed unauthenticated, attacker-controlled outbound requests. | CRITICAL |
| B | Metadata reached | The SSRF reached loopback and link-local metadata addresses, establishing a server-side foothold. | CRITICAL |
Case study 4: Cross-environment credential reuse
During the crawl phase of a web application test, the agents encountered authentication information exposed in a UAT (user-acceptance testing) environment. Following the trail led to an endpoint that leaked a working set of credentials, the first reportable finding. The agents did not stop at the environment where the leak occurred.
The same credentials were tried against the production mirrors of the application. Although production never leaked the secret itself, it accepted the same identity and granted access, a second finding, and the most serious, because the exposure existed where the data did not leak. Extending the test to staging, development, and the remaining environments showed the same pattern: one credential set was honored everywhere. The leak existed in one place; the trust existed everywhere.
Figure 4. One leaked credential set fans out across every environment. Production’s exposure came from shared identity, not its own leak.
| # | Stage | What the agents did or found | Severity |
|---|---|---|---|
| 1 | Discovery | The crawl phase surfaced authentication information exposed in the UAT environment. | STEP |
| 2 | Disclosure | An endpoint leaked a working set of credentials. | HIGH |
| 3 | Reuse to production | The same credentials were authenticated to production mirrors, which had not leaked the secret themselves. | CRITICAL |
| 4 | Reuse to lower environments | The same credentials were accepted across staging, development, and the remaining environments. | HIGH |
Case study 5: Two lateral movements to an internal network foothold
A framing note for accuracy. The two lateral movements below were discovered through different mechanisms off the same estate and the same public entry point. They are presented in the sequence an attacker would run them, an application-layer pivot first, an infrastructure-layer pivot second, rather than as a single mechanically linked chain. Each step was observed and validated; the internal foothold was reached, not inferred.
The entry point was a public-facing back-office web application in a banking and reinsurance estate, the tier that handles payouts, ledgers, and related money-movement workflows. On its own it presented an authenticated single-page application behind a corporate identity provider, and a finding-by-finding review would have stopped at a handful of medium-severity observations. The agents kept going, and the same application became the pivot point for two separate escalations.
First lateral movement: from one application to another
The public application shipped its JavaScript with source maps left publicly readable, and those maps had their embedded source content populated, meaning the full original source, not merely minified code, was downloadable by anyone. That source exposed the internal structure the front end talked to: backend base URLs, route names, and the location of a separate, internet-facing development and test backend belonging to the same estate. Following those leaked URLs, the agents reached that second backend’s finance and ledger APIs and found them entirely unauthenticated. A bulk export endpoint returned live records of real payouts, identifiers, amounts, statuses, and dates, with no credential required. In one hop the agents had moved from the customer-facing application to a separate backend and were exfiltrating genuine financial data.
Second lateral movement: from the external surface into the internal network
Service scanning of the same estate turned up a second internet-exposed host running a database with authentication disabled. That database was not an application data store: it held the entire backend of the organization’s self-hosted VPN platform, including the enrolled employees’ TOTP seeds, RSA private keys, X.509 client certificates, the admin password hash, and the VPN’s cookie-signing secrets. With the seed and certificate material in hand, the agents reconstructed a valid VPN client configuration and generated valid one-time codes on demand, defeating the VPN’s multi-factor requirement not by bypassing it but by holding the secrets that produce it, and established a real tunnel into the internal VPC. From inside, they enumerated hosts that are invisible from the internet: a Windows machine with Remote Desktop exposed, a second unauthenticated database carrying another block of employee VPN credentials, an internal line-of-business application, and an internal service publishing its full API schema through an open, unauthenticated Swagger interface. Separately, the harvested VPN admin-API token and secret granted full control of the VPN management plane, which would let an attacker inject new internal routes toward the payment and ledger subnets, placing the internal payout and refund services, otherwise firewalled from the outside, one hop away.
Movement 1 · Application layer
↓
↓
↓
Movement 2 · Infrastructure layer
↓
↓
↓
Figure 5. One public application, two lateral movements: an application-layer pivot from one app to another exposing live financial data, and an infrastructure-layer pivot across the perimeter into the internal VPC.
| # | Stage | What the agents did or found | Severity |
|---|---|---|---|
| 1 | Entry | Mapped a public back-office application (payouts and ledger tier) behind a corporate identity provider. | STEP |
| 2 | Disclosure | Publicly readable JavaScript source maps with embedded source content exposed full client source, internal backend base URLs, and route names, including a separate internet-facing dev and test backend. | MEDIUM |
| 3 | Lateral movement 1 | Followed the leaked URLs to that second backend; its finance and ledger APIs required no authentication. | HIGH |
| 4 | Impact (data) | A bulk export endpoint returned live records of real payouts (identifiers, amounts, statuses, dates) with zero authentication. | HIGH |
| 5 | Exposure | Service scanning of the same estate found a second internet-exposed host running a database with authentication disabled. | HIGH |
| 6 | Credential harvest | The database held the VPN platform’s full backend: every enrolled employee’s TOTP seed, RSA private keys, X.509 client certificates, the admin password hash, and cookie-signing secrets. | CRITICAL |
| 7 | Lateral movement 2 | Reconstructed a valid VPN client configuration and generated valid TOTP codes, defeating VPN MFA, and established a real tunnel into the internal VPC. | CRITICAL |
| 8 | Internal recon | Enumerated internal-only hosts: a Windows machine with open Remote Desktop, a second unauthenticated credential database, an internal application, and a service exposing its full schema via open Swagger. | HIGH |
| 9 | Infrastructure control | Harvested VPN admin-API token and secret granted full control of the VPN management plane, enabling route injection toward the internal payment and ledger subnets, one hop from the internal payout and refund services. | CRITICAL |
Cross-cutting lessons
Across five unrelated engagements, the same patterns recur. They are worth naming because each is invisible to testing that examines findings in isolation.
In every case the severe outcome emerged from the relationships between findings, an allowlist, a shared identity, a reused trust boundary, not from any single issue’s intrinsic severity.
Redacted output, a CAPTCHA on one path, an allowlist naming a reputable domain: each read as controlled, and each became the seam the chain exploited.
Allowlisted origins, shared credentials, and inter-environment trust are precisely what let one finding hand off to the next. Trust relationships deserve the same scrutiny as code.
A medium and a low can compose into a critical. Backlogs ordered purely by per-finding severity will deprioritize exactly the links that complete a chain.
None of these chains required a novel vulnerability. They required following findings to their conclusion and proving the path, something sampled, point-in-time testing rarely does.
How FireCompass agents discover attack chains
FireCompass is an agentic AI platform for automated penetration testing, continuous automated red teaming, and attack surface management, covering web applications, APIs, cloud, and infrastructure across both external and internal environments. The autonomous agents discover assets, then discover, chain, and exploit vulnerabilities across them continuously, rather than in a single annual window.
Two design choices make the chains in this paper findable. First, the agents validate exploitability rather than reporting potential issues, which keeps false positives low and means a reported path has been demonstrated, not merely inferred. Second, the platform reasons about multi-stage attack paths: it treats the output of one finding as a candidate input to the next, which is the behavior that carried each case study past the point where conventional tooling stops. Engagements can run fully autonomously or with expert-in-the-loop validation, and FireCompass holds a USPTO-awarded patent for its automated red teaming technology.
What is deliberately omitted. This paper describes what the agents achieved and why the chains were possible. The specific methods the agents use to discover and assemble these paths are proprietary and are intentionally not disclosed here.
Defensive recommendations
The following actions address both the specific weaknesses in the case studies and the patterns behind them.
Break the chains in these cases
Change how risk is found and measured
Standards mapping
The vulnerability classes in these case studies map to well-established industry categories. The mapping below is provided for orientation; it reflects the nature of the findings, not a compliance assessment of any organization.
| Case | OWASP Top 10 (2021) | Representative CWE |
|---|---|---|
| CSP bypass to stored XSS | A03 Injection | CWE-79 (XSS); CWE-693 (Protection Mechanism Failure) |
| Actuator to RCE | A05 Security Misconfiguration; A01 Broken Access Control; A03 Injection | CWE-200; CWE-732; CWE-1336 (SSTI) |
| Converging paths | A07 Identification and Authentication Failures; A10 SSRF; A05 Security Misconfiguration | CWE-307; CWE-287; CWE-918; CWE-200 |
| Credential reuse | A07 Identification and Authentication Failures; A01 Broken Access Control | CWE-522; CWE-200 |
| Two lateral movements to internal foothold | A01 Broken Access Control; A05 Security Misconfiguration; A07 Identification and Authentication Failures | CWE-306 (Missing Authentication for Critical Function); CWE-522 (Insufficiently Protected Credentials); CWE-200 |
Conclusion
Five engagements, five chains, one lesson: the risk that matters is the risk attackers can assemble, and it rarely matches the risk a finding-by-finding view reports. A redacted endpoint, a permissive allowlist, an unthrottled form, and a reused credential are easy to deprioritize alone. Followed to their conclusion, they reached stored script execution, remote code execution, account takeover, access across an entire estate, and a validated foothold inside an internal network.
Closing that gap is less about discovering exotic vulnerabilities than about testing the way an adversary operates: continuously, across the whole surface, validating each path end to end. That is the behavior these cases illustrate, and it is the standard organizations should hold their testing to.
Severity is a property of paths.
Findings are only the links.
See which chains already exist between the findings in your backlog.
About FireCompass
FireCompass is an agentic AI platform for automated penetration testing, red teaming, and attack surface management, spanning web applications, APIs, cloud, and infrastructure across external and internal environments. It discovers shadow assets and validates risk through safe exploitation and multi-stage attack-path analysis, delivering evidence-backed results with near-zero false positives and prioritizing what is actually exploitable. FireCompass can run fully autonomously or with expert-in-the-loop validation, holds a USPTO-awarded patent for its automated red teaming technology, and is trusted by Fortune 500 enterprises and recognized by industry analysts including Gartner, GigaOm, and IDC.
Learn more at firecompass.com.
© 2026 FireCompass. This white paper is provided for informational purposes. Case studies are anonymized from real engagements; identifying details and proprietary techniques have been omitted.
