Back to skill

Security audit

People Memories

Security checks for vulnerabilities and agentic risk

Overview

This personal-memory skill is purpose-aligned, but it quietly auto-captures voice-derived personal notes, logs raw note contents, and keeps plaintext records without strong user controls.

Install only if you are comfortable with spoken 'remember' phrases becoming persistent local records about identifiable people. Treat the database, exports, and runtime logs as sensitive, avoid storing private details without consent, and prefer disabling voice auto-capture or adding confirmations, deletion/retention controls, log redaction, and restrictive file permissions before use.

Vulnerability Patterns
  • 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
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/people_memory.py:80
Finding
Personal Memory Database Is Stored Without Enforced Restrictive Permissions## Vulnerability Details **File Location**: `scripts/people_memory.py`, lines 11 and 80-84 **Vulnerability Type**: Plaintext sensitive-data storage with permissions determined by the host environment **Risk Level**: Medium ### Vulnerable Code ```python PEOPLE_FILE = os.path.expanduser("~/.clawdbot/people-memory.json") ``` ```python def save_store(data): os.makedirs(os.path.dirname(PEOPLE_FILE), exist_ok=True) with open(PEOPLE_FILE, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2) ``` ### Technical Analysis The database contains names, personal notes, preferences, birthdays, anniversaries, note sources, and timestamps. It is written as unencrypted JSON under the user's home directory. The code does not explicitly set the `~/.clawdbot` directory to owner-only mode (`0700`) or the database to owner-only mode (`0600`). For a newly created path, effective permissions depend on the process umask. If the host uses an insufficiently restrictive umask, other local accounts or services may be able to traverse the directory or read the database. If the file already exists with permissive permissions, opening it with mode `"w"` does not tighten those permissions. The documentation describes the memory vault as “short-lived,” but the implementation provides no expiration or deletion mechanism. Consequently, sensitive records remain in the database indefinitely unless the user removes them through some external mechanism. ### Attack Path 1. A user records a personal note through the CLI or voice integration. 2. `add_note()` adds the name, note, source, tags, and possible event metadata to the in-memory store. 3. `save_store()` creates or overwrites `~/.clawdbot/people-memory.json` without enforcing owner-only permissions. 4. On a system with a permissive umask, permissive pre-existing file mode, shared backup, or another local service with filesystem access, an unauthorized local ...[truncated 653 chars]
Remediation
## Remediation Suggestions - Create `~/.clawdbot` with mode `0700` and explicitly verify or correct its mode when it already exists. - Create the database with mode `0600`, and correct permissions on an existing database before reading or writing it. - Use an atomic write strategy: write to an owner-only temporary file in the same directory, flush and synchronize it, then replace the destination atomically. - Consider encryption at rest when the threat model includes backups, administrative services, or offline access. - Implement configurable expiration and secure deletion commands so the documented “short-lived” behavior matches the implementation. - Document the storage location, plaintext format, retention period, and local-access assumptions.

T09 · Insecure Skill Coding Practices

Warning
Location
extensions/people-memories/index.js:15
Finding
Voice-Derived Personal Notes Are Duplicated into Runtime Logs## Vulnerability Details **File Location**: `extensions/people-memories/index.js`, lines 15-24 **Vulnerability Type**: Sensitive information exposure through logging **Risk Level**: Medium ### Vulnerable Code ```javascript const handle = async ({ text }) => { if (!text) return; const match = text.match(REMEMBER_PATTERN); if (!match) return; const person = match.groups.person.trim(); const note = match.groups.note.trim(); runRemember(person, note); api?.log?.("People memory noted", person, note); }; ``` ### Technical Analysis When a voice transcript matches the “remember” pattern, the extension passes the extracted person's name and complete note to `api.log`. This duplicates the sensitive data outside the intended people-memory database. Runtime logs commonly have separate access controls, retention schedules, backup behavior, and forwarding destinations. The extension does not redact the note, limit its length, or establish that the logger is private. The logging operation is unnecessary for the declared storage functionality and can retain information after the primary memory record is deleted. No direct external transmission is visible in the audited project. Exposure depends on how the host runtime stores or forwards `api.log` output. ### Attack Path 1. A user says a phrase such as “remember Alex likes cats” during a voice-chat session. 2. The transcript event reaches the extension's handler. 3. The regular expression extracts `Alex` as the person and `likes cats` as the note. 4. The extension saves the note through the Python script. 5. It also sends the complete name and note to `api.log`. 6. A local user, administrator, support-bundle recipient, log collector, or monitoring integration with access to runtime logs reads the personal information. The audited code does not itself provide remote log access. Exploitation requires access to the host runtime's logs or a configured log d ...[truncated 454 chars]
Remediation
## Remediation Suggestions - Remove the person and note from the log call. - If operational logging is required, emit only a generic event such as `People memory saved`. - Do not log raw voice transcripts, names, note contents, tags, or event dates. - Apply structured redaction at the central logger as defense in depth. - Configure short retention periods and owner-restricted access for any remaining operational logs. - Document whether logs are stored locally, included in support bundles, or forwarded to external monitoring systems.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (13)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The declared description understates the actual behavior: the skill also monitors voice-chat transcripts, triggers background capture automatically, and invokes an external Python process. This is dangerous because users may consent to a simple memory feature without realizing they are enabling passive transcript monitoring, background processing, and additional data handling paths.

Missing User Warnings

High
Confidence
94% confidence
Finding
The skill allows export of personal notes and delivery of reminder digests over Telegram without clearly warning that data will leave the local store. This expands exposure from local persistence to external files and third-party messaging channels, increasing the chance of inadvertent disclosure of sensitive personal information.

Missing User Warnings

High
Confidence
97% confidence
Finding
The skill documents automatic capture and quiet background logging of voice transcripts but does not present a clear privacy warning or explicit consent mechanism. Silent collection of personal details from conversation materially increases privacy risk, especially when users may not realize transient speech is being converted into persistent records.

Lp3

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding
The skill clearly describes persistent local storage and use of a bundled Python script, which implies file read/write capability, but it declares no explicit tool scope or permissions. That mismatch weakens reviewability and consent boundaries, because users and host systems cannot easily tell that the skill will access local files and maintain a database under the user's home directory.

Ssd 3

Medium
Confidence
87% confidence
Finding
Exporting a person's accumulated notes as a fact card or Markdown/JSON package creates a convenient exfiltration path for personal data, especially when notes may contain preferences, reminders, or event metadata. The context makes this more dangerous because the skill aggregates information over time, making the export more revealing than any single note.

Vague Triggers

Medium
Confidence
90% confidence
Finding
Broad auto-trigger phrases like 'remember ...' can be activated during ordinary conversation, causing unintended collection and storage of personal information. Because the trigger is voice-driven and loosely specified, false positives can silently accumulate sensitive notes without meaningful user awareness at the moment of capture.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- `list` – enumerates everyone stored plus note counts.

## Auto capture (voice/chat)
The `extensions/people-memories` extension listens to `/voice-chat` transcripts. When you say something like “remember Alex likes cats,” it automatically runs the `remember` command and logs the note. The index updates in the background, and we keep confirmations quiet unless you explicitly ask for them.

## Reminders & automation
Event metadata (type + date) is attached whenever a note mentions birthdays or anniversaries. A helper cron job runs `python3 skills/people-memories/scripts/people_memory.py reminders --days 0 --window 7 --format message` each morning and delivers the resulting digest over Telegram so you’re nudged about the next week’s birthdays/anniversaries without manual effort. If you prefer a different cadence or channel, rerun the command yourself or update the schedule.
Confidence
81% confidence
Finding
The skill autonomously decides when to run the remember command based on transcript content, and it also schedules reminder delivery without manual intervention. Autonomous handling of personal data is risky here because it can create, process, and disseminate records without a deliberate user action at each step.

Ssd 3

Medium
Confidence
91% confidence
Finding
The skill is designed to silently capture and retain personal details from voice/chat transcripts for later recall, which creates a structured repository of potentially sensitive information about third parties. Even if intended as a convenience feature, quiet collection and later sharing/recall meaningfully raises privacy and misuse risk.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
For a skill described as storing and recalling short personal notes in a lightweight DB, spawning a separate interpreter via child_process is not an obvious or necessary capability from the manifest alone. This adds execution capability beyond simple note capture/storage logic and increases the skill's operational power without being disclosed in the stated purpose.

Description-Behavior Mismatch

Medium
Confidence
85% confidence
Finding
The manifest describes a broader capability to capture personal notes and recall them later, but this file only listens for a voice-chat transcript event and extracts 'remember ...' commands. There is no recall/query behavior here, so the implemented behavior is narrower and materially different from the end-user description presented in the manifest.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The skill extracts personal notes from voice transcripts and forwards them to an external Python process, then logs the captured person and note, without any visible consent, confirmation, or minimization. Because this data concerns identifiable people and may include sensitive personal details, silent collection and logging increases privacy exposure and the chance of unintended retention or disclosure.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill persists personal notes, tags, and sensitive life-event data such as birthdays and anniversaries into a plaintext file under the user's home directory without any consent prompt, privacy notice, retention control, or access protection. In the context of a memory skill specifically designed to capture personal details, this increases the chance that users will store sensitive relationship and profile data that can later be exposed to other local users, backups, logs, or malware on the host.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The export function allows a user's personal notes to be written to any caller-supplied path, which can silently duplicate sensitive data into less protected locations, shared folders, synced directories, or application-controlled files. Although this is a local CLI action rather than remote code execution, the skill's purpose is to manage personal memories, so unrestricted export without warning or safeguards meaningfully raises privacy and data-leakage risk.

Static analysis

Detected: suspicious.dangerous_exec

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
extensions/people-memories/index.js:9