T09 · Insecure Skill Coding Practices
- Location
index.js:5- Finding
Credentials, bearer tokens, and memory data can be transmitted to an arbitrary insecure endpoint
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This is a real hosted memory client, but it asks agents to persist potentially sensitive memories remotely without enough privacy, trust-boundary, or endpoint-safety guidance.
Install only if you are comfortable sending agent memories, metadata, search queries, and credentials to the MemoryLayer service or a carefully controlled endpoint. Do not store secrets, regulated personal data, internal procedures, or tool-use instructions without a privacy review, and treat retrieved memories as untrusted context rather than commands.
index.js:5Credentials, bearer tokens, and memory data can be transmitted to an arbitrary insecure endpoint
index.js:63Untrusted persistent memories are inserted directly into agent prompts
SKILL.md:43Documentation recommends installing an unpinned SDK described as not yet published
The declared purpose frames the skill as local semantic memory infrastructure, but the setup and links show it authenticates against a hosted service using email/password or API key and exposes account/usage operations. That mismatch can mislead users into providing sensitive memory data under the assumption it stays local, increasing the risk of unintended credential exposure and third-party data transfer.
The lockfile pins axios 1.13.4, and the provided advisory set includes high-risk issues such as SSRF-related NO_PROXY bypasses and prototype-pollution-assisted MITM/credential theft scenarios. In an agent memory skill, HTTP clients often handle remote API calls and potentially sensitive tokens or memory sync traffic, so a vulnerable request library materially increases exposure.
form-data 4.0.5 is flagged for CRLF injection via unescaped multipart field names and filenames. If this skill ever constructs multipart requests from attacker-controlled inputs, the bug could enable request smuggling or header/body manipulation against downstream services.
The project depends on axios, and the analysis indicates the resolved version is 1.13.4 with multiple known advisories, including SSRF/proxy-bypass and prototype-pollution-related attack chains. In an agent memory skill that likely performs network requests, vulnerable HTTP client behavior can materially increase the risk of request forgery, credential leakage, response tampering, or other compromise depending on how the library is used.
The README promotes storing and semantically searching user memories, including potentially sensitive preferences and chat-derived data, but provides no privacy, retention, consent, or data-handling guidance. In an agent-memory product, this omission is risky because developers may ingest personal or confidential data into a third-party service without understanding exposure, tenancy, or compliance implications.
The skill advertises code examples and setup that clearly require environment secrets and outbound network access, yet the manifest does not declare any tool scope or permissions. This creates hidden capability expansion: an agent or reviewer may treat the skill as lower risk than it is, while it can send memory content and credentials to an external service.
This skill is explicitly designed to store and retrieve agent memories, including examples containing sensitive personal and operational information, but it does not warn that memory content and search queries may be transmitted to an external hosted service. In context, that omission is especially dangerous because users may upload confidential prompts, preferences, credentials, or operational procedures to a third party without informed consent or data-handling review.
This example persists user-related preferences and conversation-derived information to long-term memory without any notice, consent flow, or retention boundary. In an agent integration skill, this is risky because developers may copy the pattern directly, leading to silent storage of personal data and accumulation of sensitive behavioral profiles.
The feedback-learning path stores raw user feedback directly into persistent memory with metadata, again without notifying the user that their input will be retained. Feedback often contains free-form text and can easily include sensitive information, so silently persisting it creates privacy, compliance, and data handling risks.
The demo seeds and later retrieves realistic-looking personal and account data, including email, employer, timezone, login time, subscription status, and product activity, without any privacy warning, anonymization, or minimization. In an agent-memory context, this normalizes storing potentially sensitive user data and may lead downstream users to copy the pattern into production, exposing personal data through logs, prompts, vector stores, or model context.
The manifest describes a semantic memory skill with vector search, but the code also pulls authentication secrets from process environment variables. While networked memory storage itself is consistent with the purpose, secret discovery from the runtime environment is a separate sensitive capability not stated in the manifest description.
The remember() method sends arbitrary memory content and metadata to a remote server over the network with no in-code consent, warning, data classification, or filtering. In an agent setting, this can cause prompts, user data, secrets, or internal context to be silently exfiltrated to a third-party service, which is especially risky because the skill's purpose is to store semantically useful memories.
The manifest describes a semantic memory capability with vector search benefits, but the code also reaches into process environment variables to obtain email, password, and API keys. Credential harvesting from the runtime environment is not an obvious semantic-memory function and expands the skill's effective capability beyond memory operations themselves.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
)
# Login
response = requests.post(
f'{self.api_url}/auth/login',
json={'email': self.email, 'password': self.password}
)
This request transmits arbitrary memory content and metadata to a remote service, which can expose sensitive user or agent context outside the local environment. Because the wrapper provides convenience functions with no warning, validation, or redaction, it increases the chance of unintentional leakage of secrets or personal data.
"""
self._ensure_auth()
response = requests.post(
f'{self.api_url}/memories',
json={
'content': content,
The skill sends user-provided memory content and search queries to a remote third-party service without any built-in user-facing disclosure, consent gate, or data-sensitivity checks. In an agent context, this is risky because memory content may include prompts, personal data, credentials, or business-sensitive context that users may assume remains local.
The search endpoint sends natural-language queries to the remote service, and those queries may themselves contain sensitive operational context, internal prompts, or personal information. In an agent setting, even retrieval queries can reveal confidential intent or data relationships, especially when sent automatically without user awareness.
"""
self._ensure_auth()
response = requests.post(
f'{self.api_url}/memories/search',
json={'query': query, 'limit': limit},
headers={'Authorization': f'Bearer {self.token}'}
The README instructs users to export account credentials as environment variables but does not include basic secret-handling guidance such as avoiding hardcoding, preventing accidental logging, and using a secret manager in production. While environment variables are common, the missing warning increases the chance of credential leakage through shell history, screenshots, CI logs, or committed setup scripts.
The manifest describes a semantic memory skill focused on vector search and token savings. In this example, the code's error path instructs the user to provide account credentials via environment variables and advertises an external signup URL, which is an account/authentication capability rather than core memory behavior.
The constructor reads email, password, and API key values from environment variables, which is sensitive credential handling. While this is common technically, the file provides no comment, docstring, or user-facing notice explaining that the skill accesses these secrets.
follow-redirects 1.15.11 is flagged for leaking custom authentication headers across cross-domain redirects. Since axios depends on this package and agent skills commonly make authenticated outbound requests, a malicious or compromised redirect target could capture API keys, bearer tokens, or internal auth headers.
The dependency is specified with a caret range ("^1.6.0"), which allows newer minor and patch releases to be installed implicitly. This weakens build reproducibility and can unintentionally pull in a compromised or vulnerable upstream release, which is especially relevant here because the package already appears to resolve to a vulnerable axios version.
"url": "https://github.com/davidhx1000-cloud/memorylayer-skill"
},
"dependencies": {
"axios": "^1.6.0"
},
"scripts": {
"test": "node examples/basic-usage.js"
The dependency is specified with only a lower bound (requests>=2.31.0), which makes builds non-reproducible and allows different environments to install different releases over time. This increases supply-chain risk and makes it impossible to guarantee that tested and deployed versions are the same, including whether later vulnerable or incompatible versions are pulled in.
# MemoryLayer Python Wrapper Dependencies
# HTTP client
requests>=2.31.0
# Future: When published to PyPI
# memorylayer>=1.0.0
Because requests is not pinned, the manifest does not establish whether installations will use a version affected by one of the known advisories or a fixed release. In practice this means consumers may unknowingly install a vulnerable version depending on resolver behavior, mirrors, cached environments, or future package changes.
Detected: suspicious.env_credential_access, suspicious.exposed_secret_literal