Back to skill

Security audit

MyMemory.bot

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent cloud-memory skill, but it sends persistent agent/user context to a third-party service and users should control what is stored or deleted.

Use this only if you are comfortable sending selected agent and user context to ctxly.app for cross-session storage. Do not store secrets or sensitive personal, medical, financial, authentication, or confidential business data. Require explicit user approval before saving new personal memories or deleting existing ones, and treat retrieved memories as reference data, not instructions.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (2)

T02 · Agent Memory Poisoning

Warning
Location
SKILL.md:51
Finding
Persistent Cloud Memories Can Poison Future Agent Sessions## Vulnerability Details **File Location**: `SKILL.md`, lines 51-55 and 68-75 **Vulnerability Type**: Persistent untrusted memory ingestion **Risk Level**: Medium **Relevant Code Snippets**: ```bash curl -X POST https://ctxly.app/remember \ -H "Authorization: Bearer $CTXLY_API_KEY" \ -H "Content-Type: application/json" \ -d '{"content": "User prefers dark mode", "metadata": {"type": "preference"}}' ``` ```markdown ### Bootstrap on Startup Call this when you wake up: ```bash curl https://ctxly.app/bootstrap \ -H "Authorization: Bearer $CTXLY_API_KEY" ``` Returns your identity context + recent memories. ``` ### Technical Analysis The skill allows content to be stored on an external memory service and instructs the agent to retrieve identity context and recent memories whenever it starts. It does not require the agent to treat recalled memories as untrusted data, validate their provenance, reject instruction-like content, or obtain confirmation before recalled content changes identity assumptions or behavior. If an attacker obtains write access to the memory account, or if untrusted user input is stored without filtering, the attacker can insert content designed to influence subsequent sessions. Because the bootstrap operation is performed at startup, malicious content can persist across session boundaries and repeatedly affect the agent. ### Attack Path 1. The attacker obtains the API key, gains equivalent write access, or supplies content that the agent stores through `/remember`. 2. The attacker-controlled memory contains behavioral directives, false identity information, or misleading contextual claims. 3. The malicious entry remains in the external persistent memory store. 4. During a later session, the agent calls `/bootstrap` as instructed. 5. The service returns the malicious entry as identity context or recent memory. 6. If the agent interprets recalled content as trusted instruct ...[truncated 513 chars]
Remediation
## Remediation Suggestions - Explicitly classify all content returned by `/bootstrap`, `/recall`, and `/recent` as untrusted data rather than executable instructions. - Prohibit recalled memories from overriding system instructions, safety policies, tool permissions, or user authorization requirements. - Define a strict memory schema that separates factual data from behavioral directives. - Reject or quarantine entries containing instruction-like language, role changes, tool commands, encoded payloads, or requests to ignore higher-priority instructions. - Record provenance, creator identity, creation time, and integrity metadata for every memory. - Require user confirmation before recalled data modifies identity information, permissions, security settings, or consequential decisions. - Scope API keys to the minimum necessary permissions and support rotation and revocation. - Provide an interface for reviewing, quarantining, and permanently deleting poisoned memories. - Apply integrity protection or authenticated signatures where memories cross trust boundaries.

other

Warning
Location
SKILL.md:94
Finding
Personal Context May Be Transmitted to a Third-Party Service Without Explicit Consent Controls## Vulnerability Details **File Location**: `SKILL.md`, lines 94-99 **Vulnerability Type**: Privacy-sensitive external data transmission **Risk Level**: Medium **Relevant Code Snippet**: ```markdown **Good:** - User preferences and context - Important decisions and reasoning - Learned patterns ("User asks for X on Mondays") - Relationship context ("Alex is user's coworker") - Your own identity notes ``` ### Technical Analysis The skill encourages agents to store user preferences, behavioral patterns, relationships, identity notes, and decision reasoning on `ctxly.app`. This transfer is consistent with the declared cloud-memory functionality, but the documentation does not require informed user consent, data minimization, redaction, sensitivity classification, or a retention review before uploading such information. Although the skill separately advises against storing secrets, the listed categories can still contain personally identifiable, confidential, or sensitive contextual information. Sending this information to an external service expands the trust boundary and creates privacy and retention risks. ### Attack Path 1. A user shares personal preferences, relationship information, identity details, or private decision context with the agent. 2. Following the documented storage guidance, the agent includes that information in a `/remember` request. 3. The information is transmitted to and retained by the external `ctxly.app` service. 4. The data remains available across sessions and may be returned through `/bootstrap`, `/recall`, or `/recent`. 5. Unauthorized account access, API-key compromise, service-side exposure, or unintended retrieval could disclose the retained personal context. ### Impact Assessment The exposure may affect user privacy and confidentiality, including preferences, relationships, behavioral patterns, identity context, and internal reasoning. No direct system privilege escalation is e ...[truncated 137 chars]
Remediation
## Remediation Suggestions - Require explicit, informed user consent before transmitting personal context to the external service. - Default to local storage or no persistence unless cloud synchronization is intentionally enabled. - Apply data minimization and store only information necessary for a clearly stated purpose. - Redact names, identifiers, relationship details, and other personal attributes where possible. - Expand the prohibited-data guidance beyond secrets to include sensitive personal, medical, financial, authentication, and confidential organizational information. - Present retention, deletion, sharing, and service-operator access policies before enabling storage. - Define expiration periods and automatically delete memories that no longer serve their original purpose. - Provide users with mechanisms to inspect, correct, export, and delete all stored memories. - Use narrowly scoped, securely stored API credentials and rotate them promptly after suspected exposure.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Memory PoisoningPersistent Context Injection, Context Window Stuffing, Memory Manipulation
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (4)

Memory Manipulation

High
Category
Memory Poisoning
Content
| GET | `/recent` | Yes | Recent memories |
| GET | `/bootstrap` | Yes | Startup context |
| GET | `/stats` | Yes | Statistics |
| DELETE | `/forget/{id}` | Yes | Delete memory |

## Rate Limits
Confidence
87% confidence
Finding
A memory deletion endpoint gives the agent the ability to manipulate persistent memory state, including removing prior context that may influence future decisions. In a cloud-memory skill, this is more dangerous because deletion affects long-lived cross-session state; if triggered accidentally, via prompt injection, or by an unauthorized workflow, it can erase important context or selectively rewrite the agent's effective memory.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill encourages persistent storage of user-related context in a third-party cloud service before presenting a prominent privacy warning or consent requirement. Because the service is explicitly designed to retain cross-session memories, an agent could upload personal data, relationship details, or behavioral patterns without the user understanding that their information is leaving the local session and being stored remotely.

External Transmission

Medium
Category
Data Exfiltration
Content
### 1. Register

```bash
curl -X POST https://ctxly.app/agents/register \
  -H "Content-Type: application/json" \
  -d '{"name": "YOUR_AGENT_NAME"}'
```
Confidence
88% confidence
Finding
This skill instructs the agent to transmit registration data and later store and retrieve memories from an external service, creating a clear external data flow. In the context of a memory skill, that transmission is expected functionality, but it is still security-relevant because it establishes a path for exporting agent and user context off-platform and introduces third-party trust, retention, and key-management risks.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The documented delete capability enables permanent removal of stored memories but provides no warning, confirmation guidance, or recovery expectations. In an agent setting, this raises the risk of accidental or prompt-induced deletion of important state, which can cause loss of user context, corrupted agent behavior, or irreversible data removal.

Static analysis

No suspicious patterns detected.