T01 · Skill Instruction Hijacking
- Location
SKILL.md:10- Finding
Automatic Persistent Context Injection and Memory Poisoning
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is a disclosed local memory integration, but it automatically persists session/project context and can install a recurring snapshot job that collects local metadata without enough user control.
Install only if you intentionally want an always-on MuninnDB memory layer and are comfortable with automatic cross-session persistence. Avoid enabling the cron snapshot unless you understand that it will repeatedly store hostname, working directory, and recent Hermes session metadata; use a narrowly scoped token, review vault contents regularly, and confirm how to pause/remove the scheduled job.
SKILL.md:10Automatic Persistent Context Injection and Memory Poisoning
references/setup-companion.md:85Recurring Cron Job Creates Cross-Session Persistence
scripts/muninndb-memory-snapshot.sh:16Recurring Collection of Credentials, Host Context, and Agent Session Metadata
The declared purpose says this is an automatic MuninnDB memory layer via MCP, but the body adds materially broader behaviors: periodic cron execution, secret reading from disk, session/host/workdir collection, external CLI invocation, and direct REST writes. This mismatch is dangerous because users and policy systems may authorize the skill under a much narrower trust model than what it actually instructs the agent to do.
The skill directs automatic storage of user preferences, decisions, project context, fixes, and summaries without an explicit privacy notice, retention policy, or consent flow. This can lead to unauthorized persistence of sensitive or confidential information across sessions.
The periodic snapshot section describes collection of system and session metadata but does not clearly warn users that host, session, and working-directory context will be captured regularly. Hidden or under-disclosed metadata collection is particularly risky because it may reveal internal project names, machine identity, or operational details.
The skill relies on shell-capable behavior via cron management, local file reads, and curl examples, yet it declares no explicit tool scope or permissions boundary. This creates an authorization gap where a consumer may expect a simple MCP-memory skill, while the instructions actually require broader execution and filesystem/network capabilities.
The instruction to 'always load' and act automatically has no scoping limits, exclusions, or sensitivity boundaries. Overly broad automatic activation can cause the skill to run in contexts where memory persistence or recall is inappropriate, including sensitive or unrelated conversations.
The skill description and instructions are written to enforce a specific locale/language context without offering a user choice. Under the policy, forcing a language without opt-in is a natural-language policy concern unless the locale restriction is explicitly justified.
The skill instructs automatic cross-session persistence of recalled and remembered information without user consent or sensitivity guardrails. In context, this is more dangerous because the skill is framed as always-on, increasing the chance that confidential or personal content gets stored by default.
The proactive storage guidance normalizes default retention of user preferences, decisions, project context, and summaries. That creates a broad data collection posture that can accumulate sensitive context over time and later expose it through recall or compromise of the memory store.
The cron job introduces ongoing background collection of working directory, recent sessions, hostname, and timestamps, which exceeds a normal conversational memory workflow. Persistent periodic collection increases privacy risk and creates a surveillance-like behavior that can continue without fresh per-session user awareness.
The periodic snapshot design instructs ongoing collection of recent sessions and host/environment context, which materially increases the amount of persistent telemetry beyond what is needed for conversational memory. Continuous accumulation of environment metadata makes later disclosure or misuse more damaging.
The REST fallback expands the skill from MCP-only memory access to direct secret retrieval from disk and raw HTTP operations. That broadens the attack surface and bypasses the narrower control plane users may assume when approving an MCP-integrated skill.
The skill includes direct HTTP POST transmission of stored content to a local service using a bearer token loaded from disk. Even though the destination is localhost, this is still an external transmission path relative to the agent and can leak sensitive user/project data into another service without adequate consent, auditing, or scoping.
MUNINN_TOKEN=$(cat ~/.muninn/openclaw.key)
# Speichern
curl -s -X POST "$MUNINN_URL/api/engrams" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $MUNINN_TOKEN" \
-d '{"concept":"kurzer-titel","content":"vollstaendiger text","vault":"hermes"}'
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.
| MuninnDB REST | `http://127.0.0.1:8475` |
| MuninnDB MCP | `http://127.0.0.1:8750/mcp` |
| Vault | `hermes` |
| API-Key | `~/.muninn/openclaw.key` (chmod 600) |
| MCP-Server-Name | `muninndb` |
| Tools | 39 (`mcp_muninndb_muninn_*`) |
| Hermes Memory Provider | `built-in` (Honcho deaktiviert) |
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.
# Key speichern
echo 'mk_<dein-key>' > ~/.muninn/openclaw.key
chmod 600 ~/.muninn/openclaw.key
# Test: Engramm schreiben
curl -s -X POST http://127.0.0.1:8475/api/engrams \
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
chmod 600 ~/.muninn/openclaw.key
# Test: Engramm schreiben
curl -s -X POST http://127.0.0.1:8475/api/engrams \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $(cat ~/.muninn/openclaw.key)" \
-d '{"concept":"test","content":"Integration funktioniert","vault":"hermes"}'
The setup guide adds a cron-based snapshot feature that goes beyond the stated purpose of automatic MCP-backed memory loading. It instructs periodic collection of host and recent session context and stores it in MuninnDB, which creates an unexpected data collection channel and persistence behavior users may not anticipate.
The cron instructions automate collection of the current working directory and recent Hermes sessions, then upload that context to MuninnDB without any privacy notice, consent step, or warning about possible sensitive contents. Even though the endpoint is localhost, this still persists potentially sensitive local context into another service and expands exposure if that service is later queried or compromised.
The cron snapshot script explicitly gathers recent session data and working-directory context and writes it into persistent memory. That behavior can capture sensitive prompts, project names, filesystem locations, or operational metadata and retain them beyond the active session.
This POST sends automatically collected snapshot content, including host and session context, into MuninnDB on a recurring basis. While the destination is localhost, the dangerous part is the persistent transfer of potentially sensitive context into another system without clear consent or minimization.
Letzte Sessions: $RECENT_SESSIONS"
# Speichern
curl -s -X POST "$MUNINN_URL/api/engrams" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $MUNINN_TOKEN" \
-d "$(jq -n --arg c "cron-snapshot-$HOSTNAME" --arg x "$SUMMARY" \
The cron job establishes persistent, recurring execution that continuously captures and stores context every 30 minutes. Persistence increases risk because collection continues beyond the immediate setup session, making accidental long-term retention of sensitive metadata more likely.
cronjob action=create \
name="MuninnDB Memory Snapshot" \
schedule="every 30m" \
script=muninndb-memory-snapshot.sh \
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.
# Vault: hermes
# Silent bei Erfolg, Error-Output bei Fehlschlag
# ==========================================
# Installiert via: cronjob action=create \
# name="MuninnDB Memory Snapshot" \
# schedule="every 30m" \
# script=muninndb-memory-snapshot.sh \
The script reads a bearer token from ~/.muninn/openclaw.key and uses it for authenticated requests without any user-facing indication. Silent use of local credentials in an automatically scheduled task increases the risk of undisclosed privilege use and can normalize hidden authenticated data flows.
The script periodically captures host context, current working directory, and recent Hermes session metadata, then persists that data into MuninnDB. That exceeds the narrowly described 'auto-load memory layer' purpose and creates a stealthy data collection channel that can reveal sensitive project names, filesystem paths, and user activity patterns.
Collecting pwd output and recent session listings is privacy-sensitive because those values may contain repository names, customer identifiers, task history, or other operational context unrelated to the advertised function. In a background cron job, this occurs automatically and silently, increasing the risk of unnoticed retention of sensitive metadata.
The script silently transmits local working-directory and session metadata to an HTTP API without notifying the user at runtime. Even though the destination is localhost, this is still external transmission to another service boundary and may expose sensitive data to any process with access to that service or its storage.