/

CVE-2026-46408

Severity:

HIGH RISK

(7.6)

Insecure Direct Object Reference in Vvveb Checkout Cart

CVE-2026-46408

Deferred

Vulnerability type

Category:

Insecure Direct Object Reference

CWE:

CWE-639

Impact:

Unauthorized Access to Other Users' Shopping Carts and Checkout Sessions

Severity:

HIGH RISK

(7.6)

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

Vvveb's checkout endpoint previously accepted a user-controlled cart_id and used it directly to enter the payment flow without confirming that the cart belongs to the current user.

A logged-in attacker could reuse another user's cart data during their own checkout session, potentially leading to unauthorized purchases or exposure of sensitive order information.

Affected context

The issue occurs in the e-commerce checkout flow where carts are referenced by identifiers passed from the client to the server.

Installations are impacted when:

  • The checkout endpoint trusts the cart_id supplied by the authenticated user
  • No server-side verification is performed to ensure the cart belongs to that user
  • The same checkout flow is used for all users' carts

In such setups, any authenticated user who can identify or guess another cart_id can attempt to bind that cart to their own checkout session.

Exploit preconditions

  • Attack surface: Web application checkout endpoint exposed over HTTP(S).
  • Required access: Valid authenticated account (attacker must be logged in).
  • Trigger point: Submission of a crafted cart_id parameter to the checkout endpoint to initiate payment using another user's cart.
  • Why exploitation is possible: The server relies on the client-supplied cart_id and does not enforce an ownership check tying the cart to the current user's account before entering the payment flow.

Why this happens

This vulnerability stems from an insecure direct object reference to carts based on a client-provided identifier.

The server-side logic accepts cart_id from the request and uses it to look up cart data and initiate checkout without validating that the referenced cart is owned by the authenticated user.

This maps to CWE-639: Authorization Bypass Through User-Controlled Key, where authorization is effectively delegated to user-controlled identifiers instead of enforcing access control on the server.

Potential impact

  • An attacker could start a checkout using another user's cart contents.
  • Another user's selected products and quantities could be exposed through order or confirmation pages.
  • Unauthorized orders could be placed on behalf of other users in scenarios where payment instruments are stored or pre-authorized.
  • Business logic inconsistencies or billing disputes could arise due to mismatched carts and user identities.

General mitigation guidance

Effective mitigation focuses on enforcing strict server-side authorization for object references:

  • Bind carts to user accounts in server-side state and always derive the active cart from the authenticated session, not from arbitrary client-supplied identifiers.
  • When a cart_id is used, validate that the cart is owned by the authenticated user before performing any read or write operations, especially before entering the payment flow.
  • Avoid exposing predictable or easily guessable cart identifiers; prefer opaque, non-guessable references that are still validated against the current user.
  • Centralize authorization checks for business objects like carts, orders, and payments so that every entry point reuses consistent access-control logic.

How teams detect issues like this

Detection typically involves both preventative and forensic approaches:

  • Static analysis / code review:
  • Look for controller or endpoint code that accepts IDs (such as cart_id, order_id, user_id) from requests and directly queries storage without checking ownership.
  • Flag patterns where access decisions are made solely on the presence of an ID rather than tying the object to the authenticated principal.
  • Security testing / QA:
  • Perform manual or automated tests where authenticated users attempt to use other users' IDs in checkout and account-related endpoints.
  • Use test accounts to verify whether changing cart_id parameters in requests exposes foreign carts.
  • Runtime monitoring:
  • Log cart and order access events with both user ID and cart_id and look for anomalies, such as one user accessing many different cart IDs or multiple users accessing the same cart unexpectedly.

Sources

SourceLink
github.comgithub.com/givanz/Vvveb/security/advisories/GHSA-rmh2-wv73-xpqh

Frequently asked

questions

Yes, in typical deployments the checkout endpoint is accessible over the web. However, exploitation still requires a valid authenticated session in the application.

No elevated privileges are required. A regular logged-in user account is enough, as the flaw is in how the application authorizes access to carts, not in role-based permissions.

The safest pattern is to never trust client-supplied identifiers for authorization. Always tie carts and orders to the authenticated user on the server and enforce an ownership check before any operation, especially in payment flows.

Establish a consistent access-control design where all sensitive objects (carts, orders, profiles) are always fetched using the current user context, use centralized authorization helpers, include IDOR checks in code review and automated testing, and avoid exposing object IDs without robust server-side validation.

Find out what's already
exploitable in your codebase.