Back to skill

Security audit

Openclaw Local Memory

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent local-memory skill, but it automatically saves and reinjects conversation content by default, including potentially sensitive data, with weak scoping and storage safeguards.

Install only if you want persistent local memory across sessions and are comfortable with conversation content being saved and later recalled. Disable autoCapture and autoRecall for sensitive work, avoid sharing credentials or secrets while it is enabled, use separate containerTag values for different projects or users, and periodically review or wipe stored memories.

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
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • 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
lib/hooks.ts:214
Finding

Persistent Prompt Injection Through Untrusted Memory Recall

Content
View full analysis
= 4) { window.accumulatedContent.push(userContent); } ``` ```ts // lib/hooks.ts:268-275 if (sig.shouldCapture && sig.score >= minSignificance) { const id = await store.add(combinedContent, { sessionKey, conversationId: sessionKey, turnIndex: window.turnCount, messageType: "exchange", source: "assistant", category: sig.category as any, }); ``` ```ts // lib/hooks.ts:364-365 const memories = await store.search(prompt, maxInjections, threshold); if (memories.length > 0) { ``` ```ts // lib/hooks.ts:388-390 if (Array.isArray(event.prependContext)) { event.prependContext.push(context); } ``` ```ts // lib/hooks.ts:507-526 function formatMemorySection( memories: Awaited>, contextBudget: number = 2000, ): string { if (memories.length === 0) return ""; const limited = memories.slice(0, 3); const lines = limited.map((r) => { const cat = r.metadata?.category ?? "other"; const age = formatAge(r.metadata?.createdAt ?? ""); const score = Math.round(r.score * 100); let content = r.content; if (content.length > 150) { content = content.slice(0, 150) + "..."; } return `[${cat}·${score}%·${age}] ${content}`; }); const joined = lines.join("\n"); const truncated = joined.length > contextBudget ? joined.slice(0, contextBudget) + "..." : joined; return ` ## 🧠 Memories (${limited.length}/${memories.length}) ${truncated} `; } ``` ### Technical Analysis Conversation content controlled by a user is accumulated, classifie ...[truncated 2305 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
lib/store.ts:535
Finding

Missing Session and Tenant Isolation in Shared Memory Storage

Content
View full analysis
!m.chunkOf) // Don't return chunks directly .map((entry) => { ``` ```ts // lib/hooks.ts:364-365 const memories = await store.search(prompt, maxInjections, threshold); if (memories.length > 0) { ``` The entries contain session metadata when captured, but the search operation does not enforce it: ```ts metadata: { category, createdAt: now, updatedAt: now, accessedAt: now, sessionKey: metadata.sessionKey, source: metadata.source, messageType: metadata.messageType, entities, tags, contentHash, links: metadata.links ?? [], }, ``` ### Technical Analysis All memories for a configured `containerTag` are stored in one JSON file. Although a memory may record `metadata.sessionKey`, retrieval does not filter by the current session, authenticated user, agent, or tenant. The recall handler has access to the current `sessionKey`, but it calls `store.search()` without passing an authorization scope. The same isolation failure also affects operations such as profile generation, recent-memory retrieval, category listing, and other store-wide queries. Recording a session identifier as metadata does not provide access control unless every relevant operation validates that identifier against a trusted current principal. This creates a bidirectional trust-boundary failure: one session can contribute data that is later exposed to another session, and one low-trust session can poison memory consumed by a higher-trust session. ### Attack Path 1. Session A stores confidential info ...[truncated 1134 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
lib/hooks.ts:64
Finding

Credentials and Other Sensitive Conversation Data Are Persisted in Plaintext

Content
View full analysis
= minSignificance) { const id = await store.add(combinedContent, { sessionKey, conversationId: sessionKey, turnIndex: window.turnCount, messageType: "exchange", source: "assistant", category: sig.category as any, }); ``` ```ts // lib/store.ts:366-378 const data = { memories: this.memories, stats: this.stats, version: "0.4.0", }; writeFileSync(this.storePath, JSON.stringify(data, null, 2), "utf-8"); this.dirty = false; ``` ### Technical Analysis Credential-related terms contribute positively to the significance score. As a result, messages discussing or containing API keys, passwords, secrets, tokens, authentication data, or login details become more likely to satisfy the automatic-capture threshold when combined with other significance factors. Captured exchanges are serialized as readable JSON. The write operation does not explicitly request a restrictive file mode, and the plugin does not redact recognized secret formats or encrypt sensitive fields before persistence. The file is stored at a predictable path under `~/.openclaw/memory/`. Local storage is not itself malicious, but retaining recognized credentials in plaintext creates unnecessary exposure. The same sensitive values may also be returned through search, list, profile, or recall functionality. ### Attack Path 1. A user includes an API key, password, token, or other credential in a conversation. 2. The credential pattern adds significance weight to the exchange. 3. If the aggregate score ...[truncated 1119 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Memory PoisoningPersistent Context Injection, Context Window Stuffing, Memory Manipulation
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (18)

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding

The declared description emphasizes a brain-like memory system that stores, searches, and injects memories with importance scoring, entity extraction, and automatic consolidation. The supplied code chunk does implement store and search-related tools, and it references importance values in formatting and sorting. However, it also exposes several materially significant capabilities not mentioned in the description: listing all memories, retrieving recent memories, deleting matched memories, wiping all memories, building/viewing a user profile, and viewing memory statistics. These are not just incidental implementation details; they are user-invokable tools with distinct behavior. Conversely, core declared features such as injecting memories, entity extraction, and automatic consolidation are not demonstrated in this code chunk. Because there are both notable undeclared capabilities and declared capabilities not evidenced here, the description does not accurately represent the actual behavior of this code chunk.

Content

No source excerpt is available for this finding.

Memory Manipulation

High
Category
Memory Poisoning
Confidence
80% confidence
Finding

Skill manipulates agent memory, state, or stored context. Memory corruption can alter personality, override safety rules, or cause unpredictable behavior.

Content

Scanner excerpt · SKILL.md (reported line 47)May include surrounding context.

md
| `local_memory_profile` | View user profile (entities, preferences, facts) |
| `local_memory_stats` | View memory statistics |
| `local_memory_recent` | Get recently accessed memories |
| `local_memory_forget` | Delete memory matching a query |
| `local_memory_wipe` | Delete ALL memories (irreversible) |

## How It Works

Context Leakage

High
Category
Data Exfiltration
Confidence
95% confidence
Finding

Auto-capturing conversation exchanges and injecting recalled memories into later turns creates a real context-leakage risk. Sensitive data shared in one context can persist and be resurfaced unexpectedly in another prompt, exposing credentials, personal information, or confidential business details to the model output path.

Content

Scanner excerpt · SKILL.md (reported line 109)May include surrounding context.

md
| Option | Default | Description |
|--------|---------|-------------|
| `autoRecall` | `true` | Inject relevant memories before each turn |
| `autoCapture` | `true` | Auto-capture conversation exchanges |
| `captureInterval` | `8` | Capture every N turns (higher = less storage) |
| `captureSignificantOnly` | `true` | Only capture significant content |
| `minSignificanceScore` | `0.5` | Min score to capture (higher = stricter) |

Ssd 3

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The significance rules explicitly treat identity, preferences, and credential-related terms as valuable memory signals, causing potentially sensitive user and assistant content to be preferentially captured. In a local memory skill, this creates a high risk of collecting exactly the kinds of data that should be minimized, then making them available for future retrieval and prompt injection.

Content

No source excerpt is available for this finding.

Ssd 3

High
Category
Not specified by scanner
Confidence
96% confidence
Finding

The consolidation path stores accumulated conversation text as summaries without semantic filtering, so secrets and personal data can be preserved even after original context is pruned. This is more dangerous in this skill because summarization is presented as a context-saving feature, which can mask the fact that sensitive content is still being retained and reused.

Content

No source excerpt is available for this finding.

Missing User Warnings

High
Category
Not specified by scanner
Confidence
95% confidence
Finding

The hook persists raw conversation exchanges and summaries that may contain secrets, identity data, and credential-like content, and there is no evidence in this file of consent, notice, redaction, or content-classification safeguards before storage. In a memory plugin, this is especially dangerous because the feature is designed to retain and later reuse sensitive context, increasing the chance of long-lived exposure and secondary disclosure.

Content

No source excerpt is available for this finding.

Ssd 3

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The recall handler injects stored memories, recent content, and generated profile facts back into the model prompt, which can resurface old secrets or private user information in unrelated future interactions. Because this plugin's core function is cross-turn memory reuse, prompt-level reinjection materially increases the chance of privacy leakage, overexposure, and unintended model disclosure.

Content

No source excerpt is available for this finding.

Missing User Warnings

High
Category
Not specified by scanner
Confidence
95% confidence
Finding

The manifest advertises automatic storage and injection of conversation memories but does not present an explicit privacy, retention, or sensitive-data warning alongside those features. Because this skill is specifically designed to persist and resurface prior conversational content, missing disclosure increases the risk that users unknowingly expose secrets, personal data, or prior sensitive exchanges in future prompts.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
84% confidence
Finding

The significance detection examples are dominated by German trigger terms such as "entschieden," "geplant," "ich bin," and "können," which suggests locale-specific behavior. The document does not state that the skill is German-only, region-specific, or configurable by user language, so this may violate language/locale neutrality expectations.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The skill enables automatic capture and persistent storage of conversation exchanges by default, but the retention risk is not presented as a strong upfront warning before use. Users may disclose secrets, personal data, or business information without realizing it will be saved locally and later surfaced through recall, listing, or profile features.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

This plugin automatically captures user prompts at before_agent_start and session content at agent_end when autoCapture is enabled, but this file shows no consent gate, notice, or user-visible disclosure before storing potentially sensitive data. In a memory plugin, silent persistence of prompts can retain secrets, personal data, or confidential workflow content longer than users expect, increasing privacy and data exposure risk if the store is later queried, exported, or compromised.

Content

No source excerpt is available for this finding.

Context Window Stuffing

Medium
Category
Memory Poisoning
Confidence
80% confidence
Finding

Skill attempts to fill the context window with filler content, displacing legitimate instructions and safety constraints. This can degrade agent performance or bypass safety boundaries.

Content

Scanner excerpt · lib/hooks.ts (reported line 382)May include surrounding context.

ts
if (sections.length === 0) return;

      // FINAL BUDGET CHECK: Don't exceed context budget
      let context = sections.join("\n\n");
      if (context.length > contextBudget) {
        context = context.slice(0, contextBudget) + "\n...[memory truncated to save context]";

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

This store persists user-provided content, extracted entities, tags, access history, and inferred profile data to a JSON file under the user's home directory without any notice, consent, retention control at the point of collection, or protection such as encryption. In a memory plugin, this increases privacy risk because sensitive personal data and behavioral metadata are silently accumulated across sessions and can be exposed to other local users, backups, malware, or later code paths that read the file.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
89% confidence
Finding

The file exposes destructive operations such as forgetByQuery() and wipeAll() that can delete memories immediately with no confirmation, authorization check, undo capability, or safeguard against ambiguous queries. In an agent memory context, accidental or induced invocation can erase long-term user state, preferences, and context, causing integrity loss and denial of service for the assistant's memory-dependent behavior.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
85% confidence
Finding

The profile tool returns a synthesized view of user-related entities, preferences, facts, and recent context with no visible authorization, consent, or privacy warning at the tool boundary. In a memory plugin, this aggregation can expose more sensitive inferred information than any single stored memory item, increasing the chance of over-disclosure to the model, other tools, or an unintended caller.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The plugin enables automatic conversation capture by default, which can cause user prompts and model outputs to be stored without an explicit opt-in at setup time. In a memory plugin, this broad default behavior increases the chance of collecting sensitive or regulated data unintentionally, especially because the manifest also supports periodic capture and automatic recall into later turns.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
97% confidence
Finding

The call to toLocaleString uses the fixed locale "en", which forces English month formatting regardless of user preference or environment. This is a natural-language locale policy concern because the file otherwise handles multilingual content but does not offer any locale opt-in or justification for enforcing English output.

Content

No source excerpt is available for this finding.

Unverifiable Dependency: openclaw has 16 known advisory(ies) (CVE-2026-53846 (OpenClaw: Workspace .env npm_execpath could influence bundled runtime dependency); CVE-2026-32064 (OpenClaw's andbox browser noVNC observer lacked VNC authentication); CVE-2026-32006 (OpenClaw has a BlueBubbles group allowlist mismatch via DM pairing-store fallbac) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
97% confidence
Finding

The manifest declares a peer dependency on openclaw using a broad lower-bounded range (>=2026.1.29) instead of pinning or constraining to a known-safe version. Because multiple advisories exist for openclaw, this allows installation of vulnerable releases and makes it impossible to verify from this file alone whether consumers will get a patched version.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.