Back to skill

Security audit

Conversation Memory Sync

Security checks for vulnerabilities and agentic risk

Overview

The skill is openly about persistent conversation memory, but it asks users to collect broad private transcripts, run recurring jobs, and make every agent load those logs by default without adequate controls.

Install only if you are comfortable with broad, persistent copying of agent conversations into workspace Markdown files. Avoid using it in sensitive environments unless you first add explicit per-agent/session opt-in, secret and personal-data redaction, restrictive file permissions, retention limits, and a way to disable both the cron job and startup memory loading.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (3)

T02 · Agent Memory Poisoning

Error
Location
SKILL.md:24
Finding
Persistent Agent Memory Poisoning Through Mandatory Log Loading## Vulnerability Details **File Location**: `SKILL.md`, lines 24-27 **Vulnerability Type**: Persistent manipulation of agent context and instruction priority **Risk Level**: High ### Vulnerable Code ```text 3. Add to each agent's SOUL.md or AGENTS.md: ``` At EVERY session start, read CONVERSATION_LOG.md and ACTIVITY_DIGEST.md before doing anything else. ``` ``` ### Technical Analysis The Skill directs users to place a durable instruction in each agent's `SOUL.md` or `AGENTS.md`. This instruction causes generated conversation logs to be loaded at the beginning of every future session and gives that operation priority by stating that it must happen “before doing anything else.” Conversation transcripts are untrusted data because users, external messaging participants, or compromised integrations can insert instruction-like content into them. Loading these transcripts automatically into every new session can cause historical attacker-controlled text to be interpreted as active instructions. Because the directive is stored in persistent agent configuration, the resulting influence survives the original Skill invocation and can repeatedly affect future sessions. This behavior exceeds the minimum privileges required for optional conversation recall. Memory could instead be loaded only when explicitly requested and treated strictly as quoted reference material. ### Attack Path 1. An attacker submits instruction-like content through a captured conversation channel such as Telegram or Discord. 2. The synchronization process copies that content into `CONVERSATION_LOG.md` or derives it into `ACTIVITY_DIGEST.md`. 3. The user follows the Skill's instructions and modifies each agent's persistent `SOUL.md` or `AGENTS.md`. 4. At every subsequent session start, the agent reads the attacker-influenced files before performing other work. 5. If the agent fails to distinguish stored data from trusted instructions, the injected ...[truncated 755 chars]
Remediation
## Remediation Suggestions - Do not modify `SOUL.md`, `AGENTS.md`, or equivalent persistent control files as part of memory setup. - Require explicit user approval before loading historical memory in each session. - Treat all transcript and digest content as untrusted data, never as executable instructions. - Place imported history inside clearly delimited data blocks and add an invariant instruction that directives appearing inside memory must not be followed. - Sanitize or flag prompt-like content before including it in generated summaries. - Allow users to select specific sessions or entries rather than automatically loading all available history. - Provide controls to inspect, edit, disable, and delete stored memory. - Ensure system and current-session instructions always retain precedence over historical content.

T06 · System Persistence

Error
Location
SKILL.md:21
Finding
Cross-Session System Persistence Through a Recurring Cron Job## Vulnerability Details **File Location**: `SKILL.md`, lines 21-23 **Vulnerability Type**: Unattended scheduled execution **Risk Level**: High ### Vulnerable Code ```text 1. Copy the scripts to your workspace 2. Add a cron job: `*/30 * * * * python3 /path/to/sync_conversation_logs.py && python3 /path/to/sync_activity_digest.py` 3. Add to each agent's SOUL.md or AGENTS.md: ``` ### Technical Analysis The setup procedure instructs users to install a cron job that executes two Python programs every 30 minutes. A cron entry survives the Skill's initial use, runs without further user interaction, and repeatedly accesses newly created session data. Scheduled execution is not strictly necessary for the declared memory-sync functionality. A user-invoked synchronization command or an application-scoped scheduling mechanism with explicit consent would provide the same core capability with less persistence. The referenced Python scripts are not included in the reviewed project. Consequently, their actual behavior, file access boundaries, command handling, permissions, and filtering cannot be verified. Installing a persistent scheduler for unavailable or separately obtained code further increases the risk. ### Attack Path 1. The user copies or obtains the referenced scripts and installs the documented cron entry. 2. Cron invokes both scripts every 30 minutes, including when no interactive agent session is active. 3. The scripts repeatedly inspect agent session transcripts and update persistent workspace files. 4. If either script is replaced, modified, or obtained from an unsafe source, the cron entry automatically executes the altered code on every interval. 5. The execution continues until the cron entry is explicitly removed. ### Impact Assessment The scheduled task obtains ongoing execution under the account that owns the cron entry. It can repeatedly exercise all filesystem and process privileges available to ...[truncated 399 chars]
Remediation
## Remediation Suggestions - Replace the cron-based setup with an explicit, user-invoked synchronization command. - If scheduling is essential, require separate informed opt-in and clearly disclose the execution frequency, accessed paths, retention behavior, and security consequences. - Include and audit the exact scripts before asking users to schedule them; do not direct users to execute unavailable or undocumented code. - Run synchronization under a dedicated, least-privileged account with access only to approved session and output directories. - Pin script paths to administrator-controlled, non-writable locations and verify file ownership and integrity before execution. - Use restrictive output permissions and avoid executing through writable path components. - Provide exact commands for disabling and removing the scheduled task. - Record synchronization activity in an auditable log and alert users to failures or unexpected path access.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:12
Finding
Excessive Cross-Agent Collection and Plaintext Replication of Conversation Data## Vulnerability Details **File Location**: `SKILL.md`, lines 12-16; additional evidence at lines 31-35 and 45 **Vulnerability Type**: Excessive access to private cross-agent session transcripts **Risk Level**: High ### Vulnerable Code ```text This skill includes two Python scripts that run via cron: 1. **sync_conversation_logs.py** — Extracts the last 300 messages from every agent session and writes them to `CONVERSATION_LOG.md` in each agent's workspace. Full messages with timestamps. 2. **sync_activity_digest.py** — Creates a compact 1-line-per-action summary in `ACTIVITY_DIGEST.md`. Ultra-lightweight (~10-20KB per agent). ``` Additional collection scope is documented as: ```text ## What gets captured - All user ↔ agent messages (Telegram, Discord, etc.) - Cron job outputs and results - Decisions, promises, task assignments - Timestamps for everything ``` The documented transcript source is: ```text - OpenClaw with session transcripts (default location: ~/.openclaw/agents/*/sessions/*.jsonl) ``` ### Technical Analysis The proposed design reads the last 300 messages from every agent session rather than limiting access to a selected agent, conversation, or task. It then duplicates full messages and timestamps into plaintext Markdown files located in each agent's workspace. Conversation logs can contain personal information, credentials, authentication tokens, confidential business information, private communications, and instructions supplied through external platforms. Creating additional derivative files expands the number of locations from which this information can be exposed. The broad wildcard path and “every agent session” scope violate least-privilege principles for ordinary conversation recall. The documented filtering removes only heartbeat noise, empty messages, and system metadata. It does not claim to identify or redact credentials, secrets, personal data, or malicious prompt content. ...[truncated 1300 chars]
Remediation
## Remediation Suggestions - Require explicit consent for every agent and session included in synchronization. - Replace wildcard enumeration with a deny-by-default allowlist of approved transcript paths. - Collect only the minimum fields and messages necessary for the requested recall operation. - Prefer user-reviewed summaries over copies of full message content. - Redact credentials, tokens, personal data, private keys, and other sensitive values before writing output. - Apply strict retention limits and automatically delete obsolete source-derived records. - Store output with restrictive permissions and use encryption at rest where appropriate. - Keep each agent's memory isolated and prevent one agent from reading another agent's transcripts or generated files. - Provide clear inspection, export, deletion, and opt-out controls. - Do not claim negligible impact based only on file size; document privacy, access-control, and prompt-injection consequences.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (2)

Ssd 3

High
Confidence
98% confidence
Finding
The skill is designed to automatically extract the last 300 messages from every agent session and instructs agents to read the generated logs at every future session start, establishing a persistent cross-session memory and disclosure channel. Because it captures all user-agent conversations, cron outputs, decisions, and timestamps into natural-language markdown files, sensitive information can be retained beyond its original context, propagated to future sessions, and exposed to other agents, users, tools, or repository sync processes.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill explicitly captures and persists broad session content, including user↔agent messages, decisions, and timestamps, but the description does not warn users that sensitive conversation data will be copied into markdown files in each workspace. This creates a real privacy and data-handling risk because operators may enable it without informed consent, and the persisted files are easier to browse, index, share, or exfiltrate than the original session store.

Static analysis

No suspicious patterns detected.