Oct 7, 2026·7 min read·19 visits
The Payload CMS Stripe plugin REST proxy failed to validate user roles or restrict executable SDK methods. This allowed any standard authenticated user to issue refunds, alter billing models, or exfiltrate customer metadata using the server's master Stripe Secret Key.
An access control vulnerability in `@payloadcms/plugin-stripe` allows authenticated low-privilege users to bypass authorization boundaries and execute arbitrary, highly privileged operations on the connected Stripe platform via an exposed REST proxy.
The @payloadcms/plugin-stripe npm package provides integration capabilities between Payload CMS and the Stripe payment platform. When developers enable the optional REST API proxy via the plugin configuration, an endpoint is automatically exposed at /api/stripe/rest to handle incoming payment management queries from frontend components.
A critical design flaw exists in @payloadcms/plugin-stripe versions prior to 3.90.0 and 4.0.0-canary.34 where the REST proxy endpoint does not implement sufficient access control. Any authenticated user, regardless of their role or administrative privileges, can reach this endpoint and interact directly with the Stripe SDK. Because the backend server acts as a proxy, all requests are executed under the authority of the server's master Stripe API Secret Key.
This exposure allows standard authenticated users to execute highly privileged administrative operations directly on the connected Stripe account, bypassing the CMS admin interface. The vulnerability has been assigned CVE-2026-105848 and carries a CVSS v4.0 score of 6.4, indicating moderate-to-high severity. Organizations utilizing this plugin in multi-user environments with the proxy enabled face significant operational risk.
The underlying security issues can be classified under CWE-749 (Exposed Dangerous Method or Function) and CWE-862 (Missing Authorization). When configuring the Stripe plugin with the legacy property rest: true, the application automatically registers a POST route handler named stripeREST in the file packages/plugin-stripe/src/routes/rest.ts. This handler processes incoming client-side payloads and forwards them directly to the Stripe service.
The primary authorization check in vulnerable versions only verifies the existence of a standard user session object in the incoming request. If the user is authenticated in any capacity, the application proceeds to parse the request body. No further role-based access control (RBAC) or attribute-based access control (ABAC) checks are performed to ensure the caller has administrative rights.
Furthermore, the route handler extracts the parameters stripeMethod and stripeArgs directly from the user-controlled POST request body without sanitization. These parameters are passed directly to the stripeProxy() utility function, which invokes the corresponding method on the master Stripe SDK instance. Because the application does not validate the requested method against an allowlist, any valid Stripe SDK method can be invoked dynamically.
To understand the precise vulnerability mechanics, we must examine the difference between the legacy route handler and the patched version implemented in commit 2f94a4205e5ba3ec0e91c92ed54f24f429826dd0. In the vulnerable implementation, the endpoint immediately processed dynamic parameters once basic authentication was confirmed.
The patched implementation addresses both authentication and authorization by introducing a strict allowlist and a custom access callback. The route handler now checks if pluginConfig.rest is configured as a configuration object rather than a boolean value. If it is disabled or is not configured with exact properties, the handler rejects the query immediately with an error.
Below is the refactored code structure implemented in packages/plugin-stripe/src/routes/rest.ts that enforces authorization boundaries and method limits:
// Checking authorization using custom callback or defaulting to admin access
let hasAccess: boolean
if (pluginConfig.rest.access) {
try {
hasAccess = await pluginConfig.rest.access({ req })
} catch (err) {
return unexpectedErrorResponse({ err, req })
}
} else {
try {
hasAccess = await hasAdminAccess({ req })
} catch (err) {
return unexpectedErrorResponse({ err, req })
}
}
if (!hasAccess) {
return errorResponse({ message: 'Forbidden', status: 403 })
}
const { stripeArgs, stripeMethod } = req.data ?? {}
// Enforcing strict allowlist validation
if (!pluginConfig.rest.allowedMethods.includes(stripeMethod)) {
return errorResponse({ message: 'Invalid request', status: 400 })
}Additionally, the configuration sanitizer in sanitizeStripeRESTConfig.ts prevents wildcard definitions or loose inputs during initialization. If a developer attempts to use rest: true, the configuration sanitizer throws a migration error. It mandates a non-empty allowedMethods array containing exact, literal method names, and rejects any configuration that attempts to use the wildcard character.
Exploitation of CVE-2026-105848 requires standard, low-privilege authentication on the target Payload CMS instance. The attacker must possess credentials or an active JWT session token associated with a basic CMS account. This requirement represents a low barrier to entry, particularly in applications that allow public registration or host standard user-facing features.
The attacker interacts with the target system by sending a crafted HTTP POST request to the /api/stripe/rest endpoint. The request includes the standard authentication headers and a JSON payload specifying the target Stripe method. To perform unauthorized operations, the attacker populates stripeMethod with highly privileged actions, such as refunds.create or subscriptions.del.
An example of an HTTP request designed to issue an unauthorized refund is shown below:
POST /api/stripe/rest HTTP/1.1
Host: target-payload-cms.com
Content-Type: application/json
Authorization: JWT <standard_user_session_token>
{
"stripeMethod": "refunds.create",
"stripeArgs": [
{
"charge": "ch_3MvY2lKxyz..."
}
]
}The exploitation flow is represented in the diagram below:
Upon receiving this payload, the backend application verifies that the user session is active. It then bypasses any further validation and forwards the arguments to the Stripe SDK. The SDK uses the server's legitimate master credentials to authenticate with Stripe's cloud API, which successfully processes the refund and returns the structured transaction response to the attacker.
The impact of this vulnerability is substantial and directly threatens the financial and operational integrity of organizations using the affected plugin. Because the Stripe REST proxy runs with the server's master API Secret Key, any successful exploitation grants the attacker equivalent administrative power over the connected Stripe account. This level of exposure bypasses all administrative dashboards and payment verification controls.
Attackers can exploit this access to execute disruptive actions, such as issuing massive unauthorized refunds to deplete store balances. They can also delete active customer subscription models, modify billing tiers, or retrieve sensitive customer lists and transactional history. This potential for unauthorized data exfiltration raises severe compliance and privacy concerns under regulations like GDPR and PCI-DSS.
While the vulnerability itself does not lead directly to remote code execution on the local host, the downstream impact on backend business systems is severe. This is reflected in the CVSS v4.0 metrics where subsequent confidentiality and integrity impacts are rated as High (SC:H/SI:H). The attack complexity is low, and no user interaction is required from the victims, making automated exploitation highly feasible once an attacker gains basic access.
Remediation of CVE-2026-105848 requires updating the @payloadcms/plugin-stripe dependency to a secure version. For the 3.x release line, organizations must upgrade to version 3.90.0 or higher. For deployments using the 4.x canary branch, the package must be upgraded to version 4.0.0-canary.34 or higher. These updates remove support for the vulnerable boolean configuration.
After upgrading the library, administrators must refactor their configuration files to replace any instance of rest: true. The secure configuration model requires defining an object that specifies exactly which Stripe methods are permitted. This is accomplished by populating the allowedMethods array and implementing an access callback to restrict execution to administrative roles.
A secure configuration structure is illustrated in the following TypeScript example:
stripePlugin({
stripeSecretKey: process.env.STRIPE_SECRET_KEY,
rest: {
allowedMethods: ['subscriptions.list', 'customers.retrieve'],
access: async ({ req }) => {
// Ensure the user has the 'admin' role
return Boolean(req.user && req.user.roles?.includes('admin'));
}
}
})In environments where immediate patching is not possible, organizations must disable the REST proxy entirely. This is done by setting rest: false or removing the rest property from the plugin configuration, which defaults to undefined (disabled). Furthermore, security teams should audit their Stripe API logs for unusual endpoint invocations originating from backend servers to detect potential prior exploitation.
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
@payloadcms/plugin-stripe Payload CMS | < 3.90.0 | 3.90.0 |
@payloadcms/plugin-stripe (canary) Payload CMS | < 4.0.0-canary.34 | 4.0.0-canary.34 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-749, CWE-862 |
| Attack Vector | Network (AV:N) |
| CVSS v4.0 Score | 6.4 (Medium) |
| Exploit Status | Proof-of-Concept / Easy to reproduce |
| CISA KEV Status | Not Listed |
| Vulnerability Type | Missing Authorization in Stripe REST Proxy |
The product exposes a dangerous method or function to unauthorized or lower-privileged users, or fails to perform authorization checks altogether.
svglib versions prior to 2.3.1 contain an uncontrolled resource consumption vulnerability in the svg2rlg() renderer. When parsing SVG documents containing nested <use> elements, SvgRenderer.renderUse() recursively resolves and deep-copies referenced subtrees without enforcing a global expansion limit. Although the library detects and blocks direct circular references, an attacker can construct an acyclic directed reference graph with high fan-out (an SVG analogue to the XML Billion Laughs attack). Processing a crafted SVG payload of less than 2 KB triggers exponential node duplication, exhausting CPU and memory in applications that convert user-supplied SVGs or HTML documents embedding SVG content.
CVE-2026-132277 (also tracked as GHSA-q87h-c5m7-659j) is an uncontrolled resource consumption and algorithmic complexity vulnerability in the Inscriptis Python library (versions 2.0.0 through 2.7.5). When rendering sibling HTML table elements inside a block-level parent container, the parser fails to pop the parent block's inline padding prefix from the internal canvas prefix stack upon closing the block. Consequently, each subsequent sibling table inherits and accumulates the indentation prefixes of all preceding tables. This causes the output string length and memory allocation of get_text() to grow quadratically with the number of sibling tables, allowing a compact untrusted HTML payload to trigger denial of service via memory exhaustion.
CVE-2026-132276 (GHSA-53pm-wgxf-c6qf) is an algorithmic complexity and Regular Expression Denial of Service (ReDoS) vulnerability in the Python wcmatch wildcard and glob matching library prior to version 11.2. Under default flags, matching a non-matching attacker-controlled filename against a static developer-defined pattern containing multiple star (*) wildcards separated by literal delimiters causes polynomial-time backtracking O(n^k) in the compiled regular expression. A single 255-byte filename evaluated against a 5-star pattern consumes approximately 86 seconds of 100% CPU time, allowing unauthenticated attackers to induce severe availability degradation.
CVE-2026-122244 (GHSA-r2q3-7m4h-63qg) is a high-severity cross-privilege Stored Cross-Site Scripting (XSS) vulnerability in Budibase prior to version 3.50.0. The flaw occurs due to defective character escaping in the JSON formatter utility combined with raw HTML rendering via Svelte's {@html} directive in the Budibase Builder interface. A low-privileged application user or an unauthenticated form visitor can store malicious HTML markup in a shared datasource, which subsequently executes arbitrary JavaScript in the browser session of an administrator or application builder inspecting Handlebars formula bindings.
A tenant-confusion vulnerability in the user initialization endpoint of the Budibase worker service (prior to version 3.50.0) allows unauthenticated remote attackers to bypass the one-time administrative setup guard. By supplying arbitrary tenant identifiers in POST requests to /api/global/users/init, an attacker can force the underlying CouchDB datastore to dynamically provision unlimited tenant databases and persist latent global administrator accounts. This results in datastore resource exhaustion, denial of service, and unauthorized administrative account creation inside non-default tenant contexts.
Paymenter versions prior to 1.5.7 contain an arbitrary method invocation vulnerability within the base Livewire component architecture. The application includes a legacy trait, HasConfirmation, inside app/Livewire/Component.php, which is inherited across 36 client-facing Livewire components. This trait exposes a public remote procedure call (RPC) endpoint named executeConfirmedAction without access controls or method allowlisting. Remote attackers can invoke arbitrary methods on any inheriting component, including Livewire's internal fill() method, enabling them to bypass #[Locked] property protections and manipulate internal component state and hydrated Eloquent models.