Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach public /graphql endpoint
-
DeliverySubmit createUrlUpload with internal URL
-
ExploitServer fetches metadata endpoint
-
ExecutionRetrieve response via ActiveStorage blob URL
-
ImpactExfiltrate internal data or cloud credentials
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Credential Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires that the Chaskiq GraphQL endpoint (POST /graphql) be network-reachable by the attacker and that the createUrlUpload mutation be invokable without authentication, which the CVSS PR:N and description confirm is the default. Impact is maximized when the instance runs on cloud infrastructure exposing an unprotected instance-metadata service (e.g. AWS IMDSv1 at 169.254.169.254) or other internal HTTP services the server can reach. Limiting factors: the severity of outcome depends on what internal/metadata endpoints are actually reachable from the host and whether hardening such as IMDSv2, egress filtering, or network segmentation is in place; these reduce but do not eliminate the SSRF itself. |
| Impact | All available signals point to a genuine, high-priority issue rather than a CVSS-inflated paper risk. The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a network-reachable, low-complexity, unauthenticated attack requiring no user interaction, and the impact metrics (VC:H, SC:H) correctly capture an SSRF that reads confidential data from the vulnerable system and from a subsequent system (e.g. a cloud metadata service). The description aligns cleanly with the vector - unauthenticated POST /graphql is consistent with PR:N, and arbitrary URL fetching with blob retrieval supports VC:H/SC:H - so there is no network-vs-local conflict to flag. EPSS is not provided in the input, so exploitation probability cannot be quantified. The vulnerability is NOT in CISA KEV and no exploit-code flag is supplied, so this is 'no public exploit identified at time of analysis'; however, a detailed public technical write-up (hackmd) and the exact vulnerable source file are referenced, which materially lowers the effort to develop a working exploit even though that does not equate to confirmed active exploitation. Net assessment: real priority for anyone running Chaskiq, especially on cloud infrastructure with reachable instance-metadata endpoints, tempered by the product's limited deployment footprint. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a crafted createUrlUpload GraphQL mutation to the public POST /graphql endpoint pointing at an internal URL such as a cloud instance-metadata endpoint (e.g. 169.254.169.254). The server fetches that URL server-side and exposes the full response through the returned ActiveStorage blob URL, letting the attacker read internal services or steal cloud credentials. No public exploit code is confirmed, but a step-by-step technical write-up and the vulnerable source are publicly referenced, and the low-complexity network vector makes exploitation straightforward. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 16, 2026
Server-side request forgery in Chaskiq through 2.0.3 allows unauthenticated attackers to make the server fetch arbitrary URLs-including internal network resources and cloud instance metadata endpoints-by submitting crafted requests to the createUrlUpload GraphQL mutation. The fetched content is stored as an ActiveStorage blob and returned to the attacker, enabling exfiltration of sensitive data such as IAM credentials from IMDSv1 endpoints. With a CVSS 9.2 severity and no authentication required, this is a high-priority issue; at time of analysis, no public exploit code was identified, though a technical writeup is publicly available. Note: confirmed actively exploited (CISA KEV) is not applicable; no public exploit identified at time of analysis.
RemediationAI
No vendor-released patch identified at time of analysis. Administrators should monitor the Chaskiq project for updates and apply them as soon as a fixed version is announced. In the interim, implement the following compensating controls: (1) Disable or restrict access to the createUrlUpload GraphQL mutation, either by modifying the application code to remove the mutation or by using a WAF to block requests containing 'createUrlUpload' to /graphql; note that this may break legitimate URL upload functionality for users. (2) Enforce network egress filtering on the Chaskiq host to block outbound requests to internal IP ranges (e.g., 169.254.169.254, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) and cloud metadata endpoints; this may interfere with other server-initiated outbound connections. (3) Require authentication for the /graphql endpoint by adding an authentication layer (e.g., reverse proxy with basic auth or OAuth), though this could impact API integrations. (4) Enable cloud provider instance metadata service v2 (IMDSv2) if running on AWS, which adds a token requirement and mitigates simple SSRF-based credential theft. (5) Segment the network so that the Chaskiq server cannot reach sensitive internal services. Regular security assessments and monitoring for anomalous outbound requests from the Chaskiq server are also recommended. For further details, consult the VulnCheck advisory at https://www.vulncheck.com/advisories/chaskiq-through-2.0.3-ssrf-via-createurlupload-graphql-mutation.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability is a classic server-side request forgery (SSRF) rooted in CWE-918: the Chaskiq application fails to validate or restrict the URL supplied to the createUrlUpload GraphQL mutation. According to the referenced source code (app/graphql/mutations/create_url_upload.rb lines 29-66 and app/controllers/graphql_controller.rb lines 3-33), the mutation accepts a URL, causes the server to perform an HTTP request to that URL, and then stores the response body as an ActiveStorage blob. The blob's URL is returned to the caller, allowing retrieval of the fetched content. Because the mutation is exposed via the unauthenticated POST /graphql endpoint, any remote attacker can direct the server to internal IP ranges (e.g., 169.254.169.254 for AWS IMDSv1, 169.254.169.254 for GCP, or other internal services) and read the responses. The CPE cpe:2.3:a:chaskiq:chaskiq:*:*:*:*:*:*:*:* indicates that all versions of Chaskiq are potentially affected, though the issue is confirmed through version 2.0.3. The root cause is the absence of URL allowlisting, protocol enforcement, or network-level egress restrictions on the server-side fetch operation.
Know when Chaskiq gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:H/SI:N/SA:N
Unauthenticated network-reachable GraphQL mutation (AV:N/AC:L/PR:N/UI:N); SSRF reads data from other systems so S:C with C:H, and no integrity or availability impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Chaskiq through 2.0.3 contains a server-side request forgery vulnerability that allows unauthenticated attackers to fetch arbitrary URLs via the createUrlUpload GraphQL mutation. Attackers can submit internal URLs, including cloud instance metadata endpoints, through POST /graphql and retrieve the full response via the returned ActiveStorage blob URL.
Executive ViewAI
Chaskiq, a customer engagement platform, is affected by a critical server-side request forgery vulnerability (CVE-2026-111663) in versions up to 2.0.3. Attackers can exploit this flaw to access internal network resources and cloud metadata endpoints, potentially exfiltrating sensitive credentials such as IAM keys, which could lead to broader cloud infrastructure compromise. No public exploit identified at time of analysis, and no vendor patch is available, making immediate mitigation critical to protect organizational assets.
Interim mitigations: Disable the createUrlUpload GraphQL mutation if not required. Block outbound traffic from Chaskiq servers to cloud metadata endpoints (169.254.169.254) and internal IP ranges. Enforce IMDSv2 to require token-based access to instance metadata. Deploy WAF rules to detect and block SSRF attempts. Implement network segmentation to limit outbound access. Monitor logs for suspicious outbound requests.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
Unauthenticated remote attackers can invoke the stripeCreateIntent GraphQL mutation in Chaskiq (through commit 46dfdd1)
Unauthenticated remote access to Stripe Billing Portal sessions in Chaskiq through commit 46dfdd1 allows any attacker to
Server-side request forgery in Chaskiq through 2.0.3 allows unauthenticated remote attackers to make the server fetch ar
EUVD-2026-102954
GHSA-rggr-4j68-hc5w
NVD
CVE.org
Exploit-DB