/

CVE-2026-82283

Severity:

HIGH RISK

(8.1)

Broken Access Control (CWE-639) in VoltAgent Memory API

CVE-2026-82283

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-639

Impact:

Unauthorized access, modification, and deletion of conversation data

Severity:

HIGH RISK

(8.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

VoltAgent does not consistently verify that the authenticated caller owns a conversation referenced by memory API requests. An authenticated user may therefore read, modify, or delete another user's conversations and messages when caller-controlled identifiers are accepted without ownership checks.

Affected context

The issue occurs in VoltAgent memory API handlers when conversation or message identifiers supplied by an authenticated client are used without reliably checking ownership or authorization scope. Deployments are at risk when users can reach these endpoints and identifiers are predictable, discoverable, or otherwise obtainable.

Exploit preconditions

  • Attack surface: VoltAgent memory API endpoints
  • Required access: A valid authenticated user account
  • Trigger point: A request that supplies a conversation or message identifier
  • Why exploitation is possible: The handler may use caller-controlled identifiers without confirming that the referenced resource belongs to the requesting user

Why this happens

The underlying bug is an object-level authorization failure, commonly known as insecure direct object reference or broken object-level authorization. The memory handlers trust a resource identifier from the request but do not consistently bind the lookup and subsequent operation to the authenticated user's ownership or permitted access scope. This maps to CWE-639: Authorization Bypass Through User-Controlled Key, because a user-controlled key can select another user's protected resource.

Potential impact

  • Attackers may read private conversations and messages
  • Attackers could alter conversation history or stored messages
  • Attackers may delete other users' conversation data
  • Confidential information could be exposed
  • Conversation integrity and application trust could be undermined

General mitigation guidance

Mitigation generally focuses on enforcing authorization at every object access and operation rather than relying on identifier secrecy.

Common defensive patterns include:

  • Deriving the effective user or tenant scope from the authenticated session
  • Applying ownership or role checks within every read, update, and delete handler
  • Using scoped data-access methods that require an authorization context
  • Avoiding direct exposure of predictable internal identifiers where practical
  • Returning consistent responses that do not reveal whether another user's resource exists
  • Applying least privilege and tenant isolation to storage and service accounts

These controls reduce reliance on caller-supplied identifiers and help preserve confidentiality and integrity.

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis rules identifying database lookups driven by request identifiers without nearby authorization checks
  • Code review of every memory API operation for authentication, ownership, tenant, and role enforcement
  • Tests that attempt cross-user reads, updates, and deletes using valid accounts
  • Runtime logging and alerting for repeated access to resources outside the caller's scope
  • API policies requiring authorization context in resource-access data-access methods

Automated security testing and code review tools can help identify missing object-level authorization, but coverage should include business-logic tests and negative authorization cases.

Sources

SourceLink
github.comgithub.com/VoltAgent/voltagent
github.comgithub.com/VoltAgent/voltagent/blob/44b4c8e4998ce56095b2f0e4eaf1a988f5e6d0de/packages/server-core/src/handlers/memory.handlers.ts
github.comgithub.com/VoltAgent/voltagent/issues/1371
vulncheck.comvulncheck.com/advisories/voltagent-memory-api-handlers-missing-ownership-checks

Frequently asked

questions

Yes, where the memory API is reachable by authenticated clients and the deployment does not add an effective authorization layer. Exploitation occurs through normal API requests rather than requiring host-level access.

The attacker generally needs a valid authenticated account and an identifier for a conversation or message they do not own. The required identifier may be exposed through application behavior, logs, or other data-access paths.

Enforce object-level authorization on every operation using the authenticated user's identity, tenant, and applicable roles. Resource queries should be scoped by that authorization context before reads or mutations occur.

Add cross-user negative tests, centralize authorization-aware data access, review all identifier-based endpoints, and monitor for access outside expected ownership boundaries.

Find out what's already
exploitable in your codebase.