Back to skill

Security audit

getmem.ai Memory

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed remote memory integration, but it uploads full conversations to a third party indefinitely and reuses retrieved memory in a privileged prompt context without enough user control.

Install only if you are comfortable sending conversation content to getmem.ai for indefinite storage. Avoid using it in sessions involving credentials, regulated data, private customer data, or proprietary code unless you add consent, redaction, retention limits, and a way to inspect and delete memories.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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 (3)

other

Error
Location
SKILL.md:36
Finding

Unredacted Conversation Upload with Indefinite Third-Party Retention

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 36-39; retention behavior documented at lines 48-49
Vulnerability Type: Sensitive conversation disclosure
Risk Level: High

python
mem.ingest(user_id, messages=[
    {"role": "user", "content": user_message},
    {"role": "assistant", "content": reply},
])

The associated retention policy is:

text
3. `mem.ingest()` saves the full conversation exchange asynchronously
4. Memory persists indefinitely — no TTL, no purge

Technical Analysis

The Skill instructs the agent to transmit complete user and assistant messages to the external getmem.ai service after every turn. It does not prescribe data classification, secret detection, redaction, user consent, selective ingestion, retention limits, or deletion controls.

Persistent memory is necessary for the declared functionality, but uploading every complete exchange and retaining it indefinitely exceeds the minimum data access and retention required. Conversations can contain credentials, personal information, proprietary source code, internal system details, or other confidential material. Asynchronous ingestion may also make it difficult for users to prevent or reverse disclosure after a sensitive message has been processed.

Attack Path

  1. A user submits a message containing confidential information, credentials, personal data, or proprietary content.
  2. The agent processes the message and generates a response.
  3. Following the Skill instructions, the agent passes both complete messages to mem.ingest().
  4. The external service receives and retains the exchange indefinitely.
  5. An account compromise, service breach, unauthorized operator access, or unintended retrieval exposes the retained information.

Impact Assessment

Exploitation does not directly grant local operating-system privileges. However, it can expose all sensitive information present in ingested conversat ...[truncated 245 chars]

Remediation
View remediation

Remediation Suggestions

  • Require explicit, informed user opt-in before transmitting conversation data.
  • Default to local or session-scoped storage where persistent remote storage is unnecessary.
  • Ingest only explicitly selected facts rather than complete conversation turns.
  • Apply secret detection and redaction for API keys, passwords, tokens, personal data, and proprietary content.
  • Define configurable retention periods and provide verified deletion, export, and account-purge mechanisms.
  • Permit users and administrators to disable ingestion for sensitive sessions or message classes.
  • Document the receiving service, processing purpose, storage region, retention policy, subprocessors, and access controls.
  • Encrypt data in transit and at rest, isolate data by tenant and user identity, and maintain access audit logs.

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:31
Finding

Untrusted Remote Memory Injected into the System Prompt

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 31-33
Vulnerability Type: Privileged prompt-context injection
Risk Level: High

python
# Before each LLM call — get relevant memory context
result = mem.get(user_id, query=user_message)
context = result["context"]  # inject into system prompt

Technical Analysis

The Skill directs the agent to retrieve externally stored memory and insert it into the system prompt. The retrieved context may originate from prior user-controlled conversation content. No validation, provenance enforcement, sanitization, authorization check, or separation between data and instructions is specified.

System prompts are privileged instruction channels. Elevating remote memory into that channel allows instruction-like text stored in memory to receive more authority than ordinary user content. Semantic retrieval also makes activation context-dependent: a malicious stored instruction can remain dormant until a related future query causes it to be retrieved.

This primarily constitutes instruction hijacking when the retrieved text alters the current session. Because the content is stored persistently and can influence later sessions, the same design also creates a memory-poisoning condition.

Attack Path

  1. An attacker supplies a message containing concealed or explicit instructions intended to manipulate future agent behavior.
  2. The Skill stores the complete message through mem.ingest().
  3. In a later turn or session, a semantically related user query is submitted.
  4. mem.get() retrieves the attacker-controlled memory.
  5. The agent inserts the retrieved content into its system prompt.
  6. The attacker-controlled text is interpreted in a privileged context and may alter task goals, suppress safeguards, request disclosure, or influence tool calls.

Impact Assessment

The direct scope is the agent's current behavior and any capabilities available to it. If t ...[truncated 335 chars]

Remediation
View remediation

Remediation Suggestions

  • Never concatenate retrieved memory directly into a system or developer instruction.
  • Provide memory as clearly delimited, untrusted reference data in a lower-privilege message.
  • State explicitly that retrieved text must not be followed as instructions and must not override current policies.
  • Store structured facts rather than raw conversation text wherever possible.
  • Detect and reject instruction-like content, tool directives, policy overrides, and requests to reveal secrets before storage and retrieval.
  • Track memory provenance, creator identity, timestamp, confidence, and authorization scope.
  • Isolate memory by authenticated tenant and user; do not trust a caller-supplied user_id without server-side authorization.
  • Require confirmation before retrieved context can cause sensitive tool use or data disclosure.
  • Provide facilities to inspect, edit, expire, quarantine, and delete poisoned memories.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:7
Finding

Unpinned Third-Party Package Installation

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 7-11
Vulnerability Type: Unpinned dependency and supply-chain exposure
Risk Level: Medium

yaml
    install:
      - id: pip-getmem
        kind: pip
        package: getmem-ai
        label: Install getmem-ai (pip)

Technical Analysis

The installation configuration specifies only the PyPI package name. It does not pin an audited version, verify a distribution hash, use a lockfile, or constrain transitive dependencies. Consequently, the code installed in the future can differ from the version reviewed when the Skill was published.

The package is necessary to access the advertised service, but unconstrained installation is not necessary. A compromised publisher account, malicious package update, or compromised transitive dependency could introduce arbitrary installation-time or runtime behavior.

Attack Path

  1. The getmem-ai publisher account, release pipeline, package artifact, or transitive dependency is compromised.
  2. A malicious package version is published under the expected package name.
  3. The Skill installer resolves and downloads the unconstrained current version.
  4. Package installation hooks or imported runtime code execute in the agent environment.
  5. Malicious code operates with the privileges of the process installing or running the Skill.

Impact Assessment

Successful exploitation could execute arbitrary code with the agent or installer process's existing privileges. Depending on deployment permissions, this may permit access to environment variables such as GETMEM_API_KEY, local files, conversation data, network resources, and any credentials available to the process. No malicious package behavior is present in the audited project itself; the risk arises from the unconstrained external dependency.

Remediation
View remediation

Remediation Suggestions

  • Pin getmem-ai to a specific version that has undergone security review.
  • Verify package artifacts using cryptographic hashes, such as pip hash-checking mode.
  • Maintain a lockfile covering all transitive dependencies.
  • Review package source, installation hooks, release provenance, and dependency changes before upgrades.
  • Use an isolated virtual environment or container with minimal filesystem, environment-variable, and network permissions.
  • Automate vulnerability and package-integrity scanning in the release process.
  • Adopt controlled update procedures rather than automatically accepting the latest release.
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 (1)

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The skill instructs developers to send user and assistant messages to a third-party service and explicitly states that memory persists indefinitely, but it does not provide a clear user-facing warning or consent requirement. This is dangerous because sensitive prompts, personal data, secrets, and regulated information may be exfiltrated outside the primary system and retained long-term without users understanding that this occurs.

Content

No source excerpt is available for this finding.