Back to skill

Security audit

Prism Alerts

Security checks for vulnerabilities and agentic risk

Overview

This skill appears to be a simple Pump.fun alert script, but it overstates its features and uses an unsafe temporary state file.

Review before installing. Use it only as a local, user-level alert helper, do not run it with elevated privileges, and be cautious with the claimed features because the packaged script only prints basic API results and polling alerts. Store any Telegram or Discord tokens outside source control and rotate them if exposed.

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
scripts/alerts.sh:31
Finding
Predictable Temporary File Allows Symlink-Based File Modification## Vulnerability Details **File Location**: `scripts/alerts.sh`, lines 31–32 and 40 **Vulnerability Type**: Predictable temporary file and unsafe symbolic-link handling **Risk Level**: Medium **Vulnerable Code**: ```bash SEEN_FILE="/tmp/prism_seen_tokens.txt" touch "$SEEN_FILE" # ... echo "$TOKEN" >> "$SEEN_FILE" ``` ### Technical Analysis The `watch` command stores token identifiers in the fixed path `/tmp/prism_seen_tokens.txt`. Because `/tmp` is normally writable by all local users, another user can create this path before the script runs. Neither `touch` nor the append redirection verifies that the destination is a regular file owned by the current user. Both operations follow symbolic links. Consequently, an attacker can replace the expected state file with a symbolic link to another file that the user running the Skill is permitted to modify. The content written to the target is derived from contract identifiers returned by the configured PRISM API. This limits direct control over the appended data when the default service is used. However, the script also permits `PRISM_URL` to be overridden, so a caller who controls that configuration and an API endpoint could influence the appended token strings. ### Attack Path 1. A local attacker predicts the fixed state-file path `/tmp/prism_seen_tokens.txt`. 2. Before the victim starts watch mode, the attacker creates a symbolic link at that path pointing to a file writable by the victim: ```bash ln -s /path/to/victim-writable-file /tmp/prism_seen_tokens.txt ``` 3. The victim runs: ```bash ./scripts/alerts.sh watch ``` 4. `touch "$SEEN_FILE"` follows the symbolic link. 5. When an unseen token is returned, `echo "$TOKEN" >> "$SEEN_FILE"` follows the link and appends the token identifier to the attacker's chosen target. 6. If the script is unnecessarily run with elevated privileges, the writable target scope expands to files accessible by ...[truncated 881 chars]
Remediation
## Remediation Suggestions - Replace the predictable path with a securely created file: ```bash SEEN_FILE="$(mktemp "${TMPDIR:-/tmp}/prism_seen_tokens.XXXXXX")" || exit 1 chmod 600 "$SEEN_FILE" trap 'rm -f -- "$SEEN_FILE"' EXIT INT TERM ``` - If state must persist across invocations, use a private per-user state directory such as `${XDG_STATE_HOME:-$HOME/.local/state}/prism-alerts`, create it with mode `0700`, and create the state file with mode `0600`. - Before using a persistent state file, verify that it is a regular file, is owned by the current user, and is not a symbolic link. - Use exact fixed-string matching for token deduplication: ```bash grep -Fqx -- "$TOKEN" "$SEEN_FILE" ``` - Never run this script with elevated privileges; its functionality requires only ordinary user privileges and outbound HTTPS access. - Consider validating contract identifiers before storing them and restricting `PRISM_URL` to trusted HTTPS endpoints when overrides are not operationally necessary.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (3)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The code does relate to Pump.fun/Solana token alerts and does cover new token detection plus graduated token listings, so the overall domain is aligned. However, several declared capabilities are not present in the supplied code. It does not detect or report volume spikes, and its 'watch' mode is a simple polling loop rather than true real-time event-driven alerting. It also only prints to the terminal/stdout; there is no implementation for Discord, Telegram, trading bot, or AI agent integration. Because the description claims a broader alerting feature set and delivery targets than the code actually provides, this is a description-behavior mismatch.

Lp3

Medium
Category
MCP Least Privilege
Confidence
70% confidence
Finding
Without declared permissions the skill's intent is opaque and cannot be validated.

Missing User Warnings

Low
Confidence
83% confidence
Finding
The skill instructs users to supply sensitive credentials such as bot tokens and channel IDs but provides no guidance on secure storage, rotation, or avoiding accidental disclosure. In agent, bot, and automation contexts, this increases the risk of credentials being committed to repositories, exposed in logs, or mishandled in shared environments, which can lead to account takeover or abuse of messaging infrastructure.

Static analysis

No suspicious patterns detected.