Back to skill

Security audit

Fitness Finder

Security checks for vulnerabilities and agentic risk

Overview

This is a straightforward Camino fitness-search skill, with ordinary privacy and supply-chain cautions rather than evidence of hidden or malicious behavior.

Before installing, use a dedicated Camino API key, avoid sending sensitive precise locations unless needed, and prefer a pinned release or reviewed commit instead of mutable latest or default-branch install commands. Installing only camino-fitness-finder is lower scope than installing the full companion suite.

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)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:14
Finding
Mutable and Unpinned Installation Dependencies<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 14–25 **Vulnerability Type**: Supply-chain exposure through mutable package and repository references **Risk Level**: Medium ### Vulnerable Code ```bash # Install all skills from repo npx skills add https://github.com/barneyjm/camino-skills # Or install specific skills npx skills add https://github.com/barneyjm/camino-skills --skill camino-fitness-finder ``` ```bash npx clawhub@latest install camino-fitness-finder # or: pnpm dlx clawhub@latest install camino-fitness-finder # or: bunx clawhub@latest install camino-fitness-finder ``` ### Technical Analysis The documented installation commands execute package-manager tooling and retrieve Skill content from mutable external sources. The `@latest` tag can resolve to a different package release each time it is used, while the GitHub URL does not identify a reviewed commit hash or signed release. Consequently, the code executed or installed by these commands may differ from the files covered by this audit. The recommendation to install all available companion Skills also broadens the dependency and attack surface beyond the audited fitness-finder Skill. This is not evidence that the current upstream packages are malicious. The vulnerability is the absence of immutable version pinning and integrity verification, which prevents users from reliably reproducing the reviewed installation. ### Attack Path 1. An attacker compromises the package publisher account, package registry entry, GitHub repository, or an upstream maintainer account. 2. The attacker publishes a malicious version under the mutable `latest` tag or modifies the repository's default branch. 3. A user follows one of the documented `npx`, `pnpm dlx`, `bunx`, or GitHub installation commands. 4. The package runner retrieves the altered installer or Skill content. 5. Malicious installation logic executes with the privileges of the invoking user or installs code that runs when the ...[truncated 499 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace `@latest` with a reviewed, explicit package version. 2. Pin the GitHub dependency to a full immutable commit hash rather than the default branch. 3. Publish and document package integrity hashes or signed release verification procedures. 4. Prefer lockfiles and package-manager integrity metadata where supported. 5. Recommend installation of only the required Skill by default rather than the entire companion suite. 6. Document the exact versions and commits covered by the security review. 7. Periodically review pinned dependencies and update them through a controlled process that includes code review and integrity validation. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
scripts/fitness-finder.sh:45
Finding
Unvalidated JSON Values Are Concatenated into the Request URL<![CDATA[ ## Vulnerability Details **File Location**: `scripts/fitness-finder.sh`, lines 45–60 **Vulnerability Type**: Improper input validation and unsafe URL construction **Risk Level**: Low ### Vulnerable Code ```bash local lat=$(echo "$INPUT" | jq -r '.lat // empty') local lon=$(echo "$INPUT" | jq -r '.lon // empty') local radius=$(echo "$INPUT" | jq -r '.radius // "1500"') local limit=$(echo "$INPUT" | jq -r '.limit // "15"') [ -n "$lat" ] && params="${params}&lat=${lat}" [ -n "$lon" ] && params="${params}&lon=${lon}" params="${params}&radius=${radius}" params="${params}&limit=${limit}" params="${params}&rank=true" echo "$params" } QUERY_STRING=$(build_query_string) ``` The constructed value is subsequently passed to curl: ```bash "https://api.getcamino.ai/query?${QUERY_STRING}" | jq . ``` ### Technical Analysis The script confirms that the input is syntactically valid JSON, but it does not enforce the documented numeric types or ranges for `lat`, `lon`, `radius`, and `limit`. Unlike `query`, these values are inserted into the URL without URI encoding. An attacker-controlled value containing URL delimiters such as `&`, `=`, or `#` can alter the request's query-string structure. Values containing curl URL-globbing syntax may also cause unexpected URL expansion because `--globoff` is not enabled. The URL remains quoted and the destination scheme and host are fixed. Therefore, this condition does not directly provide shell-command injection or arbitrary-host access. Its primary consequences are parameter pollution, malformed requests, unexpected API behavior, and possible extra API calls or quota consumption. ### Attack Path 1. An attacker or untrusted caller supplies valid JSON in which a nominally numeric field contains a crafted string, for example a value containing an additional query delimiter. 2. `jq -r` extracts the value without verifying that it is a JSON number within the documented range. 3. The script concatenates the raw value into ...[truncated 776 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Validate field types and ranges before constructing the request: - `lat`: JSON number from `-90` through `90`. - `lon`: JSON number from `-180` through `180`. - `radius`: positive integer within an explicitly documented maximum. - `limit`: integer from `1` through `100`. - `query`: string with a reasonable length limit. 2. Reject arrays, objects, booleans, and numeric-field strings instead of relying on `jq -r` coercion. 3. Use curl's parameter handling rather than manual concatenation: ```bash curl --globoff --fail-with-body --silent --show-error \ --connect-timeout 10 --max-time 30 \ --get "https://api.getcamino.ai/query" \ -H "X-API-Key: $CAMINO_API_KEY" \ -H "X-Client: claude-code-skill" \ --data-urlencode "query=$query" \ --data-urlencode "lat=$lat" \ --data-urlencode "lon=$lon" \ --data-urlencode "radius=$radius" \ --data-urlencode "limit=$limit" \ --data-urlencode "rank=true" ``` 4. Add `--globoff` to disable curl URL glob expansion. 5. Add `--fail-with-body`, connection timeouts, and an overall timeout so HTTP and network failures are handled predictably. 6. Avoid sending absent optional fields rather than serializing unchecked values. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (10)

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Add your key to Claude Code:**

Add to your `~/.claude/settings.json`:

```json
{
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Lp3

Medium
Category
MCP Least Privilege
Confidence
87% confidence
Finding
The skill advertises shell-based usage and declares runtime requirements for curl and jq, but it does not define an explicit tool scope such as allowed-tools or permissions. That can cause an agent platform to overgrant shell access or leave execution boundaries ambiguous, increasing the chance of unintended command execution beyond the skill's intended network-query behavior.

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
The installation instruction uses `npx skills add` from a remote GitHub repository without pinning a specific version, tag, or commit. This creates a supply-chain risk because future changes to the package or repo contents could silently alter what gets installed and executed.

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
This second `npx skills add` example also installs from a mutable remote repository state without version pinning. Users following the command may execute changed code later than what was originally reviewed, enabling supply-chain compromise or unexpected behavior.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The `npx clawhub@latest install` instruction explicitly tracks `latest`, which is a mutable target. If the upstream package is compromised or introduces unsafe changes, users will fetch and run it automatically.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
curl -H "X-API-Key: $CAMINO_API_KEY" \
  "https://api.getcamino.ai/query?query=gyms+yoga+studios+fitness+centers&lat=40.7589&lon=-73.9851&radius=1500&rank=true"
```

## Parameters
Confidence
88% confidence
Finding
The skill demonstrates sending requests, including location parameters and an API key header, to `https://api.getcamino.ai/query`, which is an external transmission. This is inherent to the skill's purpose, but it still presents a real data exposure surface because sensitive query and location data leave the local environment and the credential is used against a third-party service.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill sends user-supplied search text and potentially precise latitude/longitude to a third-party API without any explicit disclosure, consent, or minimization. Because location data can be sensitive, this creates a privacy risk even though the transmission is functionally necessary for the skill.

External Transmission

Medium
Category
Data Exfiltration
Content
curl -s -X GET \
    -H "X-API-Key: $CAMINO_API_KEY" \
    -H "X-Client: claude-code-skill" \
    "https://api.getcamino.ai/query?${QUERY_STRING}" | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Missing User Warnings

Low
Confidence
82% confidence
Finding
The skill clearly relies on a remote Camino API and location-based queries, but it does not prominently warn users that location data and API credentials will be transmitted off-box. For a location intelligence skill this data flow is expected, yet the missing explicit privacy warning can still lead to inadvertent sharing of sensitive location information.

Context-Inappropriate Capability

Low
Confidence
81% confidence
Finding
The manifest presents this skill as a fitness-facility search tool, but the code also depends on reading a secret from the process environment. Accessing environment-stored credentials is an additional capability not mentioned in the stated purpose, even though it is used to call the backend service.

Static analysis

No suspicious patterns detected.