Vulnerability Database

375,699

Total vulnerabilities in the database

PraisonAI has Memory State Leakage and Path Traversal in MultiAgent Context Handling — praisonaiagents

Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

Summary

The MultiAgentLedger and MultiAgentMonitor components in the provided code exhibit vulnerabilities that can lead to context leakage and arbitrary file operations. Specifically:

  1. Memory State Leakage via Agent ID Collision: The MultiAgentLedger uses a dictionary to store ledgers by agent ID without enforcing uniqueness. This allows agents with the same ID to share ledger instances, leading to potential leakage of sensitive context data.
  2. Path Traversal in MultiAgentMonitor: The MultiAgentMonitor constructs file paths by concatenating the base_path and agent ID without sanitization. This allows an attacker to escape the intended directory using path traversal sequences (e.g., ../), potentially leading to arbitrary file read/write.

Details

Vulnerability 1: Memory State Leakage

  • File: examples/context/12_multi_agent_context.py:68
  • Description: The MultiAgentLedger class uses a dictionary (self.ledgers) to store ledger instances keyed by agent ID. The get_agent_ledger method creates a new ledger only if the agent ID is not present. If two agents are registered with the same ID, they will share the same ledger instance. This violates the isolation policy and can lead to leakage of sensitive context data (system prompts, conversation history) between agents.
  • Exploitability: An attacker can register an agent with the same ID as a victim agent to gain access to their ledger. This is particularly dangerous in multi-tenant systems where agents may handle sensitive user data.

Vulnerability 2: Path Traversal

  • File: examples/context/12_multi_agent_context.py:106
  • Description: The MultiAgentMonitor class constructs file paths for agent monitors by directly concatenating the base_path and agent ID. Since the agent ID is not sanitized, an attacker can provide an ID containing path traversal sequences (e.g., ../../malicious). This can result in files being created or read outside the intended directory (base_path).
  • Exploitability: An attacker can create an agent with a malicious ID (e.g., ../../etc/passwd) to write or read arbitrary files on the system, potentially leading to information disclosure or file corruption.

PoC

Memory State Leakage

multi_ledger = MultiAgentLedger() # Victim agent (user1) registers and tracks sensitive data victim_ledger = multi_ledger.get_agent_ledger('user1_agent') victim_ledger.track_system_prompt("Sensitive system prompt") victim_ledger.track_history([{"role": "user", "content": "Secret data"}]) # Attacker registers with the same ID attacker_ledger = multi_ledger.get_agent_ledger('user1_agent') # Attacker now has access to victim's ledger print(attacker_ledger.get_ledger().system_prompt) # Outputs: "Sensitive system prompt" print(attacker_ledger.get_ledger().history) # Outputs: [{'role': 'user', 'content': 'Secret data'}]

Path Traversal

with tempfile.TemporaryDirectory() as tmpdir: multi_monitor = MultiAgentMonitor(base_path=tmpdir) # Create agent with malicious ID malicious_id = '../../malicious' monitor = multi_monitor.get_agent_monitor(malicious_id) # The monitor file is created outside the intended base_path # Example: if tmpdir is '/tmp/safe_dir', the actual path might be '/tmp/malicious' print(monitor.path) # Outputs: '/tmp/malicious' (or equivalent)

Impact

  • Memory State Leakage: This vulnerability can lead to unauthorized access to sensitive agent context, including system prompts and conversation history. In a multi-tenant system, this could result in cross-user data leakage.
  • Path Traversal: An attacker can read or write arbitrary files on the system, potentially leading to information disclosure, denial of service (by overwriting critical files), or remote code execution (if executable files are overwritten).

For Memory State Leakage

  • Enforce unique agent IDs at the application level. If the application expects unique IDs, add a check during agent registration to prevent duplicates.
  • Alternatively, modify the MultiAgentLedger to throw an exception if an existing agent ID is reused (unless explicitly allowed).

For Path Traversal

  • Sanitize agent IDs before using them in file paths. Replace any non-alphanumeric characters (except safe ones like underscores) or remove path traversal sequences.
  • Use os.path.join and os.path.realpath to resolve paths, then check that the resolved path starts with the intended base directory.

Example fix for MultiAgentMonitor:

import os def get_agent_monitor(self, agent_id: str): # Sanitize agent_id to remove path traversal safe_id = os.path.basename(agent_id.replace('../', '').replace('..\\', '')) # Alternatively, use a strict allow-list of characters # Construct path and ensure it's within base_path agent_path = os.path.join(self.base_path, safe_id) real_path = os.path.realpath(agent_path) real_base = os.path.realpath(self.base_path) if not real_path.startswith(real_base): raise ValueError(f"Invalid agent ID: {agent_id}") ...

Additionally, consider using a dedicated function for sanitizing filenames.

  • Published: Apr 8, 2026
  • Updated: Apr 9, 2026
  • GHSA: GHSA-766v-q9x3-g744
  • Severity: Medium
  • Exploit:
  • CISA KEV:

CVSS v3:

  • Severity: Medium
  • Score: 6.5
  • AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N

CWEs:

OWASP TOP 10:

Software From Fixed in
Python icon praisonaiagents - 1.5.115

Frequently Asked Questions

A security vulnerability is a weakness in software, hardware, or configuration that can be exploited to compromise confidentiality, integrity, or availability. Many vulnerabilities are tracked as CVEs (Common Vulnerabilities and Exposures), which provide a standardized identifier so teams can coordinate patching, mitigation, and risk assessment across tools and vendors.

CVSS (Common Vulnerability Scoring System) estimates technical severity, but it doesn't automatically equal business risk. Prioritize using context like internet exposure, affected asset criticality, known exploitation (proof-of-concept or in-the-wild), and whether compensating controls exist. A "Medium" CVSS on an exposed, production system can be more urgent than a "Critical" on an isolated, non-production host.

A vulnerability is the underlying weakness. An exploit is the method or code used to take advantage of it. A zero-day is a vulnerability that is unknown to the vendor or has no publicly available fix when attackers begin using it. In practice, risk increases sharply when exploitation becomes reliable or widespread.

Recurring findings usually come from incomplete Asset Discovery, inconsistent patch management, inherited images, and configuration drift. In modern environments, you also need to watch the software supply chain: dependencies, containers, build pipelines, and third-party services can reintroduce the same weakness even after you patch a single host. Unknown or unmanaged assets (often called Shadow IT) are a common reason the same issues resurface.

Use a simple, repeatable triage model: focus first on externally exposed assets, high-value systems (identity, VPN, email, production), vulnerabilities with known exploits, and issues that enable remote code execution or privilege escalation. Then enforce patch SLAs and track progress using consistent metrics so remediation is steady, not reactive.

SynScan combines attack surface monitoring and continuous security auditing to keep your inventory current, flag high-impact vulnerabilities early, and help you turn raw findings into a practical remediation plan.