Back to skill

Security audit

Suno Music

Security checks for vulnerabilities and agentic risk

Overview

This Suno music skill mostly matches its stated purpose, but it includes an unsafe generic download helper and unpinned third-party setup that should be reviewed before installation.

Install only if you are comfortable running an unpinned third-party Suno API server with your Suno cookie and supervising each generation. Before using this skill, restrict or remove the generic download command, avoid caller-supplied output paths, pin the upstream repository to a reviewed commit, and require explicit confirmation before consuming Suno credits or creating library entries.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/suno.sh:133
Finding
Unrestricted URL Download and Arbitrary File Overwrite## Vulnerability Details **File Location**: `scripts/suno.sh`, lines 133-153 **Vulnerability Type**: Unvalidated URL retrieval and unrestricted output path **Risk Level**: High ### Vulnerable Code ```bash cmd_download() { local url="" out="" while [[ $# -gt 0 ]]; do case "$1" in --url) url="$2"; shift 2 ;; --out) out="$2"; shift 2 ;; *) shift ;; esac done [[ -z "$url" ]] && { echo '{"error": "Missing --url"}'; exit 1; } if [[ -z "$out" ]]; then local filename filename="suno-$(date +%Y%m%d-%H%M%S)-$(openssl rand -hex 4).mp3" out="$DOWNLOAD_DIR/$filename" fi curl -sfL "$url" -o "$out" 2>&1 echo "{\"downloaded\": \"$out\"}" } ``` ### Technical Analysis The `download` command passes the user-controlled `--url` value directly to `curl` and writes the response to the user-controlled `--out` path. Neither value is validated. The URL is not restricted to HTTPS or to approved Suno/CDN hosts. Depending on the protocols supported by the installed `curl` build, an attacker can use schemes such as `file://` or request internal HTTP services. The `-L` option also follows redirects without validating whether the final destination remains on an approved host. The output path is not canonicalized or restricted to `SUNO_DOWNLOAD_DIR`. An absolute path, path traversal sequence, or symlink can therefore target any file writable by the invoking account. `curl -o` will overwrite an existing writable file. Shell command injection is not present in this code because the URL and output path are quoted. The vulnerability instead arises from excessive resource access granted through valid `curl` functionality. ### Attack Path 1. An attacker or untrusted instruction causes the skill to invoke the `download` command with a crafted URL and destination. 2. For local file copying, the attacker supplies a readable local resource, such as `file:///path/t ...[truncated 1386 chars]
Remediation
## Remediation Suggestions 1. Accept only `https://` URLs and reject all other schemes. 2. Allowlist the exact Suno and approved audio-CDN hostnames required by the feature. 3. Resolve and validate destination addresses to block loopback, link-local, private, multicast, and cloud metadata ranges where they are not required. 4. Disable redirects or validate every redirect target against the same scheme, hostname, and address restrictions. 5. Do not accept arbitrary output paths. Accept only a filename and construct the destination beneath `SUNO_DOWNLOAD_DIR`. 6. Canonicalize the destination and verify that it remains inside the approved directory. 7. Reject traversal components, absolute paths, symlinks, non-regular files, and existing files. 8. Create output files atomically with restrictive permissions and fail if the destination already exists. 9. Apply response size and transfer time limits to reduce resource-exhaustion risk. 10. Return JSON using `jq` rather than string interpolation so unusual path characters cannot produce malformed output.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:12
Finding
Unpinned Mutable Third-Party Installation## Vulnerability Details **File Location**: `SKILL.md`, line 12 **Vulnerability Type**: Unpinned third-party source and dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash git clone https://github.com/gcui-art/suno-api && cd suno-api && npm install && npm run build ``` ### Technical Analysis The setup instructions clone the current default branch of an external repository rather than a reviewed and immutable commit. The effective code installed by users can therefore change after this skill version has been audited. The instructions then run `npm install` and `npm run build`. These operations may execute package lifecycle and build scripts under the installing user's account. Without a pinned repository revision, verified artifact, and enforced lockfile-based installation, compromise or unexpected modification of the upstream repository or its dependency graph can introduce executable code that was not part of the audited skill package. This finding concerns supply-chain integrity. The reviewed project does not itself contain evidence that the referenced upstream repository is malicious. ### Attack Path 1. The external repository, its default branch, or a dependency it resolves is compromised or changed after this skill is reviewed. 2. A user follows the documented setup command. 3. `git clone` downloads the new, unaudited repository state. 4. `npm install` resolves dependencies and may run installation lifecycle scripts. 5. `npm run build` executes the build command defined by the downloaded project. 6. Any malicious lifecycle or build code executes with the privileges and environment access of the installing user. ### Impact Assessment Successful exploitation could execute arbitrary code with the privileges of the user performing setup. Depending on that user's permissions and environment, this may expose local files, application credentials, Suno authentication co ...[truncated 269 chars]
Remediation
## Remediation Suggestions 1. Pin the upstream repository to a specific reviewed commit hash or immutable signed release. 2. Publish the expected commit hash and verify it explicitly before installation or execution. 3. Prefer release artifacts with cryptographic checksums or signatures and verify them before use. 4. Require a committed lockfile and use `npm ci` instead of `npm install` to enforce locked dependency versions. 5. Review package lifecycle scripts and use `npm ci --ignore-scripts` where lifecycle execution is unnecessary. 6. Run any required build step in a sandbox or container with minimal filesystem, network, credential, and environment access. 7. Document the exact upstream version tested with this skill and establish a controlled process for reviewing updates.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (7)

Lp3

Medium
Category
MCP Least Privilege
Confidence
93% confidence
Finding
The skill instructs use of shell commands and a local API server but does not declare an explicit tool scope such as allowed shell access. That creates a permissions ambiguity where an agent may execute commands beyond the minimum necessary, increasing the risk of unintended command execution or abuse if the skill is triggered in the wrong context.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The trigger conditions are broad enough to match common creative-writing or music-related requests, which can cause the skill to activate when the user did not intend to generate songs or spend Suno credits. In this skill's context, overbroad activation is more dangerous because execution can invoke shell-backed generation workflows tied to a real account and external service.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The notes mention that generations consume credits and songs appear in the user's Suno library/playlists, but the skill lacks a clear up-front warning and confirmation requirement before taking those actions. This can lead to unauthorized account-impacting operations, unexpected charges or quota depletion, and unwanted persistence of generated content in the user's account.

Description-Behavior Mismatch

Medium
Confidence
93% confidence
Finding
The manifest describes generating songs, lyrics, status checks, credits, and Suno-specific features, but it does not mention acting as a general downloader. The `download` command accepts any user-supplied `--url` and fetches it with `curl`, which is broader behavior than the stated music-generation purpose.

External Transmission

Medium
Category
Data Exfiltration
Content
}

check_server() {
  if ! curl -sf "$BASE" >/dev/null 2>&1; then
    echo '{"error": "Suno API server not running on localhost:3100. Start the suno-api server first (see setup instructions)."}' >&2
    exit 1
  fi
Confidence
70% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Context-Inappropriate Capability

Medium
Confidence
97% confidence
Finding
The script accepts an arbitrary user-supplied URL and fetches it with curl, saving the result locally. In a skill whose stated purpose is generating music via a local Suno API, this broad network/file-write capability is out of scope and can be abused for SSRF-style access to internal resources, retrieval of unexpected content, or writing attacker-chosen data to disk.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The download command writes remote content directly to a local path, including a caller-provided --out value, with no safety gating, path restrictions, or warning about the risks. This increases the chance of misuse, such as overwriting arbitrary writable files or dropping untrusted content onto the host filesystem under the guise of a music-generation skill.