Description

Mastra through 1.63.0 contains an authentication bypass vulnerability in the memory API thread ownership validation when mapUserToResourceId callback is omitted from configuration. Authenticated attackers can enumerate all threads via GET /api/memory/threads and read conversation history and metadata of other resource owners.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "6.5",
  "pubDate": "2026-08-28T20:20:18.227Z",
  "pubdate": "2026-08-28T20:20:18.227Z",
  "executiveSummary": "Mastra versions up to and including 1.63.0 are susceptible to an authentication bypass vulnerability stemming from insufficient ownership validation within the memory API.\nThe vulnerability arises when the mapUserToResourceId callback is omitted from the application configuration, leading to a failure in enforcing access control boundaries for thread management.\nThis flaw allows an authenticated attacker to bypass authorization logic, enabling the enumeration of all threads and unauthorized access to sensitive conversation histories and associated metadata belonging to other resource owners.\nThe impact is significant, as it results in a total loss of data confidentiality for user interactions stored within the memory module.\nExploitation requires the attacker to hold a valid, albeit low-privileged, session; however, the absence of the configuration callback renders the API globally accessible to any authenticated user within the system scope.\nThe risk implication is high, particularly in multi-tenant or multi-user environments where strict data isolation is a requirement for security and compliance.",
  "technicalDetails": "The root cause of this vulnerability lies in the improper implementation of authorization checks within the memory API component of Mastra, specifically during the handling of thread ownership validation.\nWhen the developer fails to implement the mapUserToResourceId callback in the configuration, the system defaults to an insecure state where it fails to verify if the currently authenticated user is authorized to interact with the requested thread resource.\nThe vulnerability manifests at the /api/memory/threads endpoint. Under normal, secure conditions, the system should map the authenticated user's session identifier to a specific resource owner ID, filtering the API results to only those items owned by or permitted to the user.\nIn the vulnerable configuration, the lack of the mapUserToResourceId callback causes the validation logic to effectively return a pass condition regardless of the target thread's ownership. This lack of logical gating allows an attacker to perform unauthorized GET requests to /api/memory/threads and receive the complete set of threads stored in the memory system.\nThe attack flow begins with the attacker establishing a valid authenticated session within the Mastra ecosystem. Once authenticated, the attacker issues a standard GET request to /api/memory/threads. Because the server-side code fails to validate ownership, the API controller retrieves records from the underlying data store without filtering by User ID. The application then serializes and transmits the entire list of threads, including conversation history, session metadata, and personal data, back to the attacker.\nThis exposure persists because the memory API trust model erroneously relies on the presence of the optional configuration callback to trigger access control checks. When absent, the validation routine is bypassed entirely, granting any user the ability to traverse the entire memory store of the application.\nPost-exploitation, the attacker gains the ability to systematically harvest data from other users, leading to widespread information disclosure. Since the history includes metadata, the attacker can reconstruct user activities, identify unique interaction patterns, and potentially extract sensitive information discussed in private conversation threads across the entire platform.\nAffected versions include all releases up to and including 1.63.0. The vulnerability is network-accessible to any actor capable of initiating HTTP requests to the /api/memory/threads path following a successful authentication handshake."
}