/

CVE-2026-42864

Severity:

CRITICAL RISK

(9.9)

SSRF in FireFighter Jira Bot Endpoint

CVE-2026-42864

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-306, CWE-918

Impact:

Cloud Credential Theft and Internal Network Data Exfiltration

Severity:

CRITICAL RISK

(9.9)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

FireFighter's Jira bot creation endpoint exposes an unauthenticated server-side request forgery (SSRF) primitive by allowing arbitrary URLs to be fetched and attached to Jira tickets without access control or URL validation.

An attacker who can reach the application's ingress may coerce the pod into contacting internal or cloud-metadata endpoints and exfiltrate sensitive responses, including temporary AWS credentials in some EC2/EKS setups.

Affected context

This vulnerability affects FireFighter deployments that:

  • Expose the /api/v2/firefighter/raid/jira_bot endpoint publicly or to untrusted networks
  • Run on infrastructure where the application pod/instance can reach internal HTTP endpoints (e.g., AWS Instance Metadata Service, internal APIs, service mesh endpoints)
  • Do not enforce IMDSv2 on EC2/EKS or otherwise restrict metadata service access

In this context, an unauthenticated caller can supply arbitrary URLs for the Jira bot to fetch as attachments, turning the application into a proxy for internal HTTP requests and data exfiltration.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint /api/v2/firefighter/raid/jira_bot exposed via the application's ingress.
  • Required access: Network-level ability to reach the FireFighter ingress; no valid user account or token is required due to AllowAny permissions.
  • Trigger point: Submission of a crafted POST request whose attachments payload references attacker-controlled URLs to be fetched server-side.
  • Why exploitation is possible:
  • The view is configured with permission_classes = [permissions.AllowAny] despite documentation implying a Bearer token requirement (CWE-306: Missing Authentication for Critical Function).
  • The server uses httpx.get() on attacker-supplied URLs without validation or restriction, allowing SSRF to arbitrary HTTP endpoints (CWE-918: Server-Side Request Forgery).
  • The HTTP response body is then attached to a Jira ticket, providing a direct exfiltration channel back to the attacker via Jira.

Why this happens

The issue stems from combining a missing authentication check with unvalidated outbound HTTP requests based on user-controlled input.

At the access control layer, the Jira bot creation view is declared with permissions.AllowAny, which effectively bypasses authentication, even though the docstring claims a Bearer token is required. This mismatch between intended and actual authorization behavior aligns with CWE-306: Missing Authentication for Critical Function.

At the request handling layer, the application accepts an attachments payload that includes URLs, then calls httpx.get() on those URLs without applying allowlists, blocklists, or network boundary checks. This pattern directly maps to CWE-918: Server-Side Request Forgery (SSRF), where a server is tricked into making HTTP requests to internal or sensitive endpoints that the attacker cannot reach directly.

Because cloud environments like AWS commonly expose instance metadata services and internal management APIs on HTTP endpoints accessible from workloads, SSRF in a pod or instance context can escalate into credential theft and further compromise.

Potential impact

  • Theft of temporary AWS credentials from the instance metadata service on EC2/EKS deployments that do not enforce IMDSv2
  • Exfiltration of responses from internal HTTP services (e.g., internal APIs, admin panels, service discovery endpoints)
  • Access to cloud provider metadata, configuration, or environment-specific secrets exposed over HTTP within the VPC or cluster network
  • Pivoting from the application pod to other internal services via SSRF, potentially aiding lateral movement
  • Abuse of Jira as a data exfiltration channel by embedding sensitive responses as ticket attachments

General mitigation guidance

Effective mitigation for this type of vulnerability typically combines strong authentication, network boundary controls, and strict outbound request handling:

  • Enforce authentication and authorization on sensitive endpoints:
  • Ensure endpoints that perform actions on behalf of the system (such as creating tickets or fetching remote resources) require authenticated callers and appropriate role-based access control.
  • Align documentation with actual permission checks so that security assumptions are enforced in code.
  • Harden outbound HTTP requests:
  • Avoid making arbitrary outbound requests based directly on user-supplied URLs.
  • Where remote fetching is necessary, apply allowlists for approved domains and protocols, and reject IP literals, link-local, loopback, and private address ranges.
  • Normalize and re-parse URLs server-side to prevent bypasses through redirects, DNS rebinding, or encoded forms.
  • Reduce blast radius in cloud environments:
  • Enforce IMDSv2 and restrict metadata service access using instance or pod configuration.
  • Apply least-privilege IAM roles for application pods/instances so that exposed credentials grant minimal capabilities.
  • Use network policies, security groups, and service meshes to prevent workloads from reaching sensitive internal endpoints unless explicitly required.
  • General secure-by-default patterns:
  • Treat any user-influenced URL or network target as untrusted and subject it to central validation utilities.
  • Log and monitor outbound requests originating from application components that handle untrusted input.

How teams detect issues like this

Organizations can detect and monitor for this vulnerability class using a combination of code-level and operational strategies:

  • Static analysis and code scanning:
  • Flag Django or DRF views that:
  • Use permission_classes = [AllowAny] or equivalent on endpoints performing sensitive actions (ticket creation, remote fetching, integrations).
  • Invoke HTTP client libraries (e.g., httpx, requests, urllib) with URLs derived from request data without validation or allowlisting.
  • Add rules that look for direct use of networking APIs in request handlers alongside user-controlled inputs.
  • Code review and architectural checks:
  • During review, verify that security-sensitive endpoints match documented authentication requirements and that no "temporary" AllowAny configurations are left in production paths.
  • Require that all external calls from user-facing endpoints pass through a shared, validated HTTP client or proxy with enforced policies (domain allowlists, address filters).
  • Runtime and logging-based detection:
  • Monitor logs for unusual outbound HTTP patterns from application pods, such as calls to metadata IPs (e.g., 169.254.169.254) or other internal ranges.
  • Implement egress monitoring and alert on calls to known sensitive endpoints from application workloads.
  • Automated policy enforcement:
  • Use CI/CD checks to block deployments when endpoints expose unauthenticated access where authentication is expected.
  • Employ security testing tools (DAST/IAST) configured to probe for SSRF by injecting internal target URLs into parameters that influence remote fetches.

Sources

SourceLink
github.comgithub.com/ManoManoTech/firefighter-incident/security/advisories/GHSA-fqvv-jvhr-g5jc

Frequently asked

questions

Yes, if the FireFighter ingress is exposed to the internet or an untrusted network. The affected Jira bot endpoint does not require authentication, so anyone who can reach it can attempt to trigger SSRF and data exfiltration.

No. Despite the docstring indicating a Bearer token is required, the actual permission configuration allows any caller. Exploitation only requires network reachability to the endpoint.

The safest pattern is to enforce proper authentication and authorization on the Jira bot endpoint, and to centralize outbound HTTP requests through a validated client that only connects to explicitly allowed domains and blocks access to internal and metadata addresses.

Prevent SSRF and related issues by treating all user-controlled URLs as untrusted, enforcing strict allowlists for outbound connections, limiting pod/instance access to metadata and internal services, and ensuring that security requirements (like authentication) are enforced in code and verified through automated tests and code review.

Find out what's already
exploitable in your codebase.