/

CVE-2026-41432

Severity:

HIGH RISK

(7.1)

Improper Input Validation / Broken Payment Webhook

CVE-2026-41432

Analyzed

Vulnerability type

Category:

Improper Input Validation / Broken Payment Webhook Authentication

CWE:

CWE-345, CWE-863, CWE-1188

Impact:

Unauthorized Quota / Resource Allocation and Potential Financial Fraud

Severity:

HIGH RISK

(7.1)

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

New API's Stripe webhook handler fails to properly validate incoming events, allowing forged payment notifications to be accepted as legitimate.

An unauthenticated attacker who can reach the webhook endpoint may simulate successful payments and grant arbitrary usage quota to their account without actually being charged.

Affected context

This vulnerability affects deployments of New API that:

  • Integrate with Stripe for billing, metering, or quota management
  • Expose a publicly reachable Stripe webhook endpoint
  • Rely on webhook events to credit account quota or usage rights

The issue arises when the webhook handler trusts the contents of incoming Stripe events without robust authenticity verification, treating them as authoritative records of completed payments.

Exploit preconditions

  • Attack surface: Public-facing Stripe webhook URL exposed by the New API deployment.
  • Required access: No prior authentication; the attacker only needs network access to the webhook endpoint.
  • Trigger point: Submission of a crafted HTTP request that mimics a Stripe event payload.
  • Why exploitation is possible: The webhook handler does not sufficiently verify that requests originate from Stripe (e.g., lacks or misuses signature validation / event verification), so forged notifications are processed as valid payment confirmations and translated into quota credits.

Why this happens

The core issue is an improper trust model for external payment webhooks, aligning with:

  • CWE-345: Insufficient Verification of Data Authenticity – the handler accepts payment events without rigorously confirming they were generated by Stripe.
  • CWE-863: Incorrect Authorization – critical account-impacting operations (issuing quota) can be triggered without authenticating the source of the request.
  • CWE-1188: Insecure Default Initialization – the webhook endpoint is effectively open by default to any caller that can reach it, treating incoming data as trustworthy.

Conceptually, the handler performs state-changing operations (crediting quota) based solely on unverified external input rather than binding actions to an authenticated and authorized payment provider.

Potential impact

  • Attackers may credit arbitrary amounts of quota or usage capacity to their own accounts.
  • Attackers could provision multiple accounts with free access, leading to resource abuse and service overconsumption.
  • The platform may incur infrastructure costs without corresponding revenue.
  • Billing integrity and auditability can be undermined, complicating financial reconciliation.
  • In multi-tenant environments, large-scale abuse could degrade performance or availability for legitimate customers.

General mitigation guidance

Effective mitigation centers on treating payment webhooks as untrusted input and enforcing strong authenticity and authorization checks:

  • Require cryptographic verification of webhook signatures using shared secrets or public keys provided by the payment processor.
  • Validate event metadata, including known Stripe event types, expected fields, and originating account identifiers, before applying business logic.
  • Implement an explicit allowlist of lifecycle events that are permitted to modify quota or billing state.
  • Cross-check webhook data with server-side API verification (e.g., fetching the event or payment object directly from the payment provider) before crediting quota.
  • Apply least-privilege principles to webhook handlers, isolating them and limiting the scope of actions they can trigger without secondary verification.
  • Design the system so that quota or entitlements are never determined solely by a single unverified external callback.

How teams detect issues like this

Organizations can identify and monitor for this class of vulnerability using:

  • Static analysis and code review:
  • Flag webhook handlers that perform state changes (e.g., quota updates, subscription changes) without signature validation or upstream API verification.
  • Look for direct trust in request bodies or headers claiming to be from payment providers without independent verification.
  • Configuration and policy enforcement:
  • Enforce security policies requiring webhook authenticity checks for any payment- or quota-related endpoints.
  • Require explicit configuration of secrets/keys for third-party integrations before enabling related handlers.
  • Runtime monitoring and logging:
  • Log all quota changes along with their provenance (webhook, admin action, internal process) and enable anomaly detection on unusual patterns.
  • Alert on repeated quota credits from the same IP ranges or suspicious, non-standard Stripe event patterns.
  • Automated security testing:
  • Use API security testing tools to attempt unauthenticated calls to webhook endpoints and observe whether state changes occur without valid signatures.

Sources

SourceLink
github.comgithub.com/QuantumNous/new-api/releases/tag/v0.12.10
github.comgithub.com/QuantumNous/new-api/security/advisories/GHSA-xff3-5c9p-2mr4

Frequently asked

questions

Yes. If the Stripe webhook endpoint is exposed on the public internet without network-level restrictions, an attacker can exploit it remotely by sending crafted HTTP requests that resemble Stripe events.

The described issue is exploitable without prior authentication to the application. However, to benefit from the forged credits, the attacker typically needs at least some way to associate the forged events with a target account (for example, by knowing or guessing account identifiers).

The most robust fix is to treat webhooks as untrusted signals and require strong authenticity verification combined with server-side confirmation. That usually means validating cryptographic signatures on incoming events and cross-checking the event or payment details directly with the payment provider's API before any quota or entitlement changes are applied.

Preventive measures include standardizing a secure integration pattern for all third-party callbacks: mandatory signature verification, strict schema and event-type validation, defense-in-depth checks using provider APIs, and code review policies focused on payment and quota-related logic. Incorporating these patterns into shared libraries or frameworks used across services helps ensure future webhook handlers are secure-by-default.

Find out what's already
exploitable in your codebase.