/

CVE-2026-49225

Severity:

HIGH RISK

(8.3)

IDOR (CWE-639) in Vvveb Product Revision Management

CVE-2026-49225

Deferred

Vulnerability type

Category:

Broken Object-Level Authorization (IDOR)

CWE:

CWE-639

Impact:

Unauthorized disclosure, modification, and deletion of product revision data

Severity:

HIGH RISK

(8.3)

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

A broken object-level authorization flaw in Vvveb allows a low-privileged Vendor to access product revisions belonging to another Vendor. Depending on the operation, an attacker may read historical content, restore it over a live product, or delete revision records when they can influence revision identifiers and related parameters.

Affected context

The issue occurs in Vvveb backend product revision operations when requests are routed through the product revision controller and database queries trust caller-controlled product, language, and timestamp values. Deployments are at risk where authorization checks do not bind revision reads, restores, and deletes to the currently authenticated Vendor's ownership scope.

Exploit preconditions

  • Attack surface: Vvveb's authenticated backend product revision functionality
  • Required access: A valid low-privileged Vendor account
  • Trigger point: Revision read, restore, or deletion operations
  • Why exploitation is possible: Caller-controlled object identifiers are used without consistently applying the authenticated Vendor or administrator ownership context to database operations

Why this happens

The underlying bug is broken object-level authorization, mapped to CWE-639. The product revision route reuses content revision handling, while the associated database logic accepts product_id, language_id, and created_at values from the request without constraining queries to records owned by the current Vendor. This insecure pattern lets an authenticated user influence which tenant-owned object is accessed or changed instead of deriving authorization from trusted server-side identity and ownership data.

Potential impact

  • An attacker may read private historical product content belonging to another Vendor.
  • An attacker could restore unauthorized revisions over live product pages.
  • An attacker may delete revision records and remove audit history.
  • Product content could be corrupted or replaced across tenant boundaries.
  • Exposed historical content could support further privacy or business-impacting attacks.

General mitigation guidance

Mitigation generally focuses on enforcing authorization at the object and data-access layers rather than relying on route reuse or caller-supplied identifiers.

Common defensive patterns include:

  • Deriving the effective Vendor or administrator identity from the authenticated session.
  • Applying ownership or tenant predicates to every revision read, restore, and delete query.
  • Rechecking authorization immediately before state-changing operations.
  • Avoiding trust in client-supplied ownership, tenant, or object-scope fields.
  • Using centralized authorization policies and secure-by-default data-access abstractions.
  • Limiting Vendor privileges to the minimum product and revision scope required.
  • Preserving tamper-resistant audit records separately from user-manageable revision data where appropriate.

How teams detect issues like this

Organizations can look for this weakness through:

  • Static analysis that identifies database queries using request parameters without authenticated ownership constraints.
  • Code review checks for reused controllers whose authorization assumptions differ from the target resource.
  • Tests that attempt cross-Vendor access to read, restore, and delete operations using valid low-privilege accounts.
  • Policy enforcement requiring tenant or ownership predicates on all multi-tenant data access paths.
  • Monitoring for unusual revision access, cross-tenant identifiers, unexpected restores, and bulk deletion activity.
  • Automated application security testing or code review tools that flag missing object-level authorization checks.

Sources

SourceLink
github.comgithub.com/givanz/Vvveb/commit/e7413a29dcf1ccd04bbc44ebe26f20979223de14
github.comgithub.com/givanz/Vvveb/releases/tag/1.0.8.4
github.comgithub.com/givanz/Vvveb/security/advisories/GHSA-gmrp-ccwf-xggq

Frequently asked

questions

A low-privileged Vendor account may be sufficient when the account can reach the affected revision operations and influence the relevant object parameters.

No. The issue concerns authorization boundaries between product owners; an attacker may target another Vendor's records using their own authenticated account.

Enforce server-side object ownership or tenant authorization for every revision read, restore, and delete operation, using identity derived from the authenticated session rather than trusting request fields.

Apply centralized authorization policies, test cross-tenant access paths, constrain all data queries by ownership, and review shared controllers for resource-specific authorization assumptions.

Find out what's already
exploitable in your codebase.