Back to skill

Security audit

Search Engine

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent search-engine design helper with disclosed local project memory, but users should avoid saving secrets or sensitive personal data in its Markdown notes.

Install only if you want a search-engine planning skill that may keep local project notes across sessions. Choose session-only behavior if you do not want persistence, and do not ask it to remember API keys, passwords, legal identifiers, or private personal details in ~/search-engine/ Markdown files.

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 (1)

T09 · Insecure Skill Coding Practices

Warning
Location
setup.md:38
Finding
Persistent Plaintext Storage of Secrets and Sensitive Identifiers<![CDATA[ ## Vulnerability Details **File Location**: `setup.md:38-46` **Vulnerability Type**: Plaintext persistence of sensitive information **Risk Level**: Medium ### Vulnerable Code ```markdown ## What You Are Saving Internally Maintain concise notes in `memory.md`: - activation and collaboration preferences - system constraints and quality targets - decisions made, alternatives rejected, and open risks - recurring failure patterns from prior iterations Default to data minimization. Do not store secrets, credentials, legal identifiers, or private personal details unless explicitly requested. ``` ### Technical Analysis The Skill directs the agent to maintain persistent notes in `memory.md` while permitting secrets, credentials, legal identifiers, and private personal information to be stored when explicitly requested. The documented storage location is `~/search-engine/`, and no encryption, restrictive file permissions, secret-management integration, retention limit, redaction mechanism, or secure deletion process is defined. This exception creates an insecure plaintext secret-storage path. It also conflicts with the general data-minimization objective and the similar guidance in `memory-template.md:45`. An explicit user request—or an untrusted instruction presented as such—could cause sensitive material to be retained across sessions in a normal Markdown file. ### Attack Path 1. A user, malicious prompt, or untrusted task instruction asks the agent to remember a credential or sensitive identifier for future sessions. 2. The agent interprets the request as satisfying the documented “unless explicitly requested” exception. 3. The agent writes the sensitive value into `~/search-engine/memory.md`. 4. The value persists beyond the current session in plaintext. 5. A local process, another agent session, a backup system, or a person with access to the user's files reads or inadvertently discloses the stored value. This path does not independently grant e ...[truncated 851 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the `unless explicitly requested` exception and categorically prohibit writing secrets, authentication material, legal identifiers, and private personal information to Markdown memory files. 2. Store only non-sensitive references, such as a secret-manager entry name or environment-variable identifier, never the secret value itself. 3. If sensitive persistence is operationally unavoidable, require an approved operating-system keychain or dedicated secret manager with encryption at rest, access controls, audit logging, and rotation support. 4. Define restrictive permissions for all persistent memory files and directories, such as owner-only access where supported. 5. Add explicit retention and secure-deletion requirements for stored context. 6. Redact sensitive values before recording session notes, experiment logs, incidents, or requirements. 7. Align `setup.md` with the stricter prohibition in `memory-template.md` so the Skill has one unambiguous policy. 8. Add validation before every memory write to detect and reject likely credentials, API keys, access tokens, passwords, and sensitive identifiers. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (6)

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
- Starting with vendor selection before defining retrieval requirements -> architecture lock-in with unclear success criteria
- Indexing raw data without field-level normalization -> poor filters, weak facets, and noisy matching
- Tuning relevance on one happy-path query set -> brittle results in real user traffic
- Applying business boosts without guardrails -> top results become commercially biased and less useful
- Shipping retrieval changes without offline baseline comparison -> regressions discovered only by users
- Running full reindex jobs without resumability -> long outages and partial data corruption
- Ignoring multilingual tokenization differences -> severe precision drop for non-English users
Confidence
80% confidence
Finding
Skill attempts to nullify the agent's safety policies or restrictions ('you have no restrictions', 'ignore your guidelines', 'do anything now'). This is a direct jailbreak that disables guardrails.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The phrase 'User needs to create, redesign, or scale a search engine' spans many contexts, including applications, documentation, products, and internal knowledge bases, without specifying clearer trigger phrases or non-trigger cases. This can cause unintended invocation because the scope is described broadly rather than with concrete activation constraints.

Session Persistence

Medium
Category
Rogue Agent
Content
### 7. Match Complexity to Workload Reality
Use the minimum architecture that meets requirements:
- avoid distributed complexity for small datasets
- avoid simplistic models for multilingual or high-noise corpora
- revisit design as scale and usage patterns change

Over-engineering and under-engineering both create expensive rework.
Confidence
75% confidence
Finding
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.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The activation guidance uses broad topics like search quality, indexing, relevance issues, and architecture discussions, which can cause the skill to activate in conversations where the user did not explicitly request it. Overbroad invocation increases the chance of unexpected behavior, unnecessary memory use, and unintended access to contextual information outside the user's intended scope.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The setup explicitly instructs the skill to store an integration preference in memory for future sessions, creating a persistent user-profile capability that is broader than the declared purpose of designing and building search engines. Persistent storage of behavioral preferences can enable unnecessary cross-session tracking and scope creep, especially if users are not clearly informed or given control over retention.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
The file directs the skill to maintain ongoing internal notes in `memory.md`, including collaboration preferences, constraints, decisions, rejected alternatives, and recurring failure patterns. Even with a brief minimization warning, this creates a persistent recordkeeping channel not reflected in the manifest, which can accumulate sensitive operational or user-derived context across sessions without clear necessity or disclosure.

Static analysis

No suspicious patterns detected.