/

CVE-2026-54519

Severity:

HIGH RISK

(8.8)

Broken Access Control (CWE-862) in AI Agent Memory

CVE-2026-54519

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-862

Impact:

Unauthorized data disclosure and data loss

Severity:

HIGH RISK

(8.8)

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

AI Agent Automation fails to verify that requested agent and memory records belong to the authenticated user. An authenticated attacker who knows or obtains another user's identifiers may read private agent memory, delete an individual memory, or clear all memory associated with a victim's agent.

Affected context

The issue occurs in memory management endpoints that authenticate the caller but rely on a caller-supplied agent identifier or memory identifier without checking ownership through the related Agent record. Deployments are at risk when identifiers can be discovered or obtained across tenant boundaries and the backend does not enforce object-level authorization before returning or modifying memory data.

Exploit preconditions

  • Attack surface: Authenticated memory-management API endpoints
  • Required access: A valid user account and knowledge or discovery of another user's agent or memory identifier
  • Trigger point: Requests to list memories, delete a memory, or clear an agent's memory
  • Why exploitation is possible: Authentication confirms the caller's identity, but missing ownership checks fail to confirm that the requested resource belongs to that caller

Why this happens

The underlying bug is an object-level authorization failure. The backend authorizes the request at the user or session level, then uses identifiers supplied by the caller to retrieve or modify related records without enforcing the relationship between the resource and the authenticated user. This maps to CWE-862, Missing Authorization, because authenticated access is not followed by an effective permission check for each requested object.

Potential impact

  • An attacker may read conversation history, agent context, task data, embeddings, and metadata
  • Victim-specific agent memory may be disclosed across tenant boundaries
  • An attacker could delete individual memory records
  • An attacker could clear all memory associated with a victim's agent
  • Applications may experience privacy violations, data loss, or disrupted agent behavior

General mitigation guidance

Mitigation generally focuses on enforcing object-level authorization at every

resource access and mutation boundary.

Common defensive patterns include:

  • Deriving the effective tenant or user scope from the authenticated session rather than trusting client-supplied ownership fields
  • Joining resource queries to an authorization-controlled Agent or tenant relation
  • Applying ownership checks consistently to list, read, delete, and bulk-clear operations
  • Returning indistinguishable responses where appropriate to reduce identifier enumeration
  • Using least-privilege service identities and separating administrative access from ordinary user access
  • Treating identifiers as references only, never as proof of authorization

How teams detect issues like this

Organizations commonly detect this class of issue through:

  • Static analysis and code review rules that flag database queries using request-supplied identifiers without user or tenant predicates
  • Review of controller methods for authorization checks before every read, update, delete, and bulk operation
  • Integration tests that attempt cross-tenant access with valid authenticated sessions
  • API policy checks requiring resource ownership or tenant constraints on protected endpoints
  • Monitoring for repeated access attempts involving identifiers outside the caller's normal scope

Automated application-security review tools may help identify missing authorization

paths, but endpoint-level tests and manual review remain important.

Sources

SourceLink
github.comgithub.com/vmDeshpande/ai-agent-automation/commit/96b31c216f6f670e64584f3623c07ac54461e703
github.comgithub.com/vmDeshpande/ai-agent-automation/releases/tag/v0.9.1
github.comgithub.com/vmDeshpande/ai-agent-automation/security/advisories/GHSA-qv97-83w4-ff86

Frequently asked

questions

It can be exploitable through the application's authenticated API surface when

an attacker can submit requests containing identifiers for resources outside

their authorized scope.

Yes, the described behavior requires authentication. The attacker also needs

to know or obtain a victim agent or memory identifier.

Enforce server-side object-level authorization by resolving each requested

resource within the authenticated user's or tenant's permitted scope before

returning or modifying it.

Use centralized authorization policies, avoid trusting client-supplied

ownership information, add cross-tenant negative tests, and review all bulk

operations for equivalent permission checks.

Find out what's already
exploitable in your codebase.