Back to skill

Security audit

Parking Finder

Security checks for vulnerabilities and agentic risk

Overview

This parking-search skill is purpose-aligned and disclosed, but users should understand it sends searches, optional coordinates, and an API key to Camino's remote service.

Install only from a source and version you trust, avoid running the broad companion-suite install unless you want all related skills, and treat parking searches or exact coordinates as data shared with Camino's API under your CAMINO_API_KEY.

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:11
Finding
Unpinned Remote Installation Dependencies<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 11-26 **Vulnerability Type**: Supply-chain exposure through mutable, unpinned dependencies **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-parking-finder ``` **Via clawhub:** ```bash npx clawhub@latest install camino-parking-finder # or: pnpm dlx clawhub@latest install camino-parking-finder # or: bunx clawhub@latest install camino-parking-finder ``` ### Technical Analysis The documented installation commands execute package-runner tools and retrieve code from mutable external sources. The GitHub repository is referenced without a reviewed commit SHA or signed release tag, while the ClawHub commands explicitly request `@latest`. Consequently, the code installed by these commands can change after this version of the Skill has been audited. Compromise of the upstream repository, package publisher account, package registry, or installation tooling could cause future users to retrieve and execute attacker-controlled content. This finding concerns supply-chain integrity. The reviewed project itself does not contain evidence that the current upstream packages are malicious. ### Attack Path 1. An attacker compromises the upstream GitHub repository, ClawHub/npm publisher account, or another relevant distribution component. 2. The attacker modifies the default repository branch or publishes a malicious version under the mutable `latest` tag. 3. A user follows one of the documented installation commands. 4. `npx`, `pnpm dlx`, or `bunx` retrieves the changed package or installer rather than the version reviewed during this audit. 5. Attacker-controlled installation code executes with the permissions of the user running the command. ### Impact Assessment Successful exploitation could provide arbitrary c ...[truncated 552 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin package-runner dependencies to exact, reviewed versions rather than using `@latest`. 2. Pin the GitHub repository dependency to a specific audited commit SHA or immutable signed release. 3. Publish and verify integrity hashes or signed release artifacts where supported. 4. Use a lockfile for package-based installation tooling and commit it to the repository. 5. Avoid recommending elevated privileges for installation. 6. Document the exact versions and commit identifiers that were security-reviewed. 7. Add a controlled update process that reviews dependency changes before advancing pinned versions. For example, replace mutable references with exact versions or immutable revisions: ```bash npx clawhub@<reviewed-version> install camino-parking-finder npx skills@<reviewed-version> add \ https://github.com/barneyjm/camino-skills#<reviewed-commit-sha> \ --skill camino-parking-finder ``` ]]>

T09 · Insecure Skill Coding Practices

Note
Location
scripts/parking-finder.sh:42
Finding
Unvalidated and Unencoded URL Query Parameters<![CDATA[ ## Vulnerability Details **File Location**: `scripts/parking-finder.sh`, lines 42-52 **Vulnerability Type**: URL query-parameter injection and missing input-boundary validation **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 // "1000"') 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" ``` ### Technical Analysis Although the `query` parameter is URI-encoded elsewhere in the script, `lat`, `lon`, `radius`, and `limit` are inserted directly into the query string. The script validates only that the overall input is syntactically valid JSON; it does not ensure that these fields are JSON numbers, fall within documented ranges, or exclude URL metacharacters. An input value containing `&` or `=` can introduce additional query parameters or create duplicate parameters. For example: ```json { "lat": 40.7505, "lon": -73.9934, "radius": "1000&limit=100&unexpected=value", "limit": 15 } ``` This produces a URL containing injected parameters before the script's normal `limit` and `rank` parameters. The ultimate behavior depends on how the remote API resolves duplicate or unsupported parameters. The final URL is passed to `curl` as a quoted shell argument, so this flaw does not provide shell command injection. Its scope is request manipulation against the Camino API. ### Attack Path 1. An attacker or untrusted caller supplies syntactically valid JSON to the script. 2. A nominally numeric field contains URL query delimiters, such as `&limit=100`. 3. `jq -r` extracts the value without type or range enforcement. 4. The script concatenates the value directly ...[truncated 801 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require the coordinate, radius, and limit fields to have JSON numeric types. 2. Enforce explicit bounds, including: - Latitude: `-90` through `90` - Longitude: `-180` through `180` - Limit: `1` through `100` - Radius: a documented positive maximum appropriate for the API 3. Reject non-finite, string, array, object, boolean, and null values where numbers are expected. 4. URL-encode every parameter rather than concatenating raw values. 5. Prefer `curl --get --data-urlencode` so parameter construction is delegated to `curl`. 6. Return a clear validation error before making an authenticated request. A safer request pattern is: ```bash curl_args=( --silent --show-error --fail-with-body --get -H "X-API-Key: $CAMINO_API_KEY" -H "X-Client: claude-code-skill" --data-urlencode "query=$query" --data-urlencode "radius=$radius" --data-urlencode "limit=$limit" --data-urlencode "rank=true" ) [ -n "$lat" ] && curl_args+=(--data-urlencode "lat=$lat") [ -n "$lon" ] && curl_args+=(--data-urlencode "lon=$lon") curl "${curl_args[@]}" "https://api.getcamino.ai/query" ``` This encoding hardening should be combined with strict type and range validation; encoding alone does not enforce valid geographic or resource-limit values. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (8)

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
93% confidence
Finding
The skill clearly instructs users to run shell commands and use a shell script, but it does not declare any explicit tool scope such as allowed shell tools or permissions. This weakens least-privilege controls and makes it harder for a host agent to constrain execution safely, increasing the risk of unintended command execution if the skill is expanded or modified.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
Using `npx skills add` against a remote GitHub repository without pinning a specific commit, tag, or package version creates a supply-chain risk. A future repository change, compromise, or malicious update could cause users to install different code than expected.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
This installation command again references a remote repository through `npx skills add` without version pinning. Because the fetched content can change over time, users may unknowingly install modified or malicious skill definitions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
86% confidence
Finding
Invoking `npx clawhub@latest install` pulls the latest available package version at execution time, which is not reproducible and exposes users to upstream package compromise or breaking changes. This is a classic package supply-chain exposure because trust is placed in whatever version is current at install time.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
curl -H "X-API-Key: $CAMINO_API_KEY" \
  "https://api.getcamino.ai/query?query=parking+garages+lots&lat=40.7505&lon=-73.9934&radius=1000&rank=true"
```

## Parameters
Confidence
50% 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

Medium
Confidence
95% confidence
Finding
The script transmits user-provided search queries and optional precise location data (lat/lon) to a third-party remote API, but the execution path provides no user-facing disclosure or consent prompt at the time of transmission. In a skill context, this can expose sensitive destination or whereabouts information unexpectedly, especially if callers assume processing is local.

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
91% confidence
Finding
This script performs an external network request to api.getcamino.ai containing the assembled query string, which may include user search terms and optional latitude/longitude values. While the transmission appears intentional and over HTTPS, it is still a real data-exposure boundary and becomes risky if users are not clearly informed that potentially sensitive location data leaves the local environment.

Static analysis

No suspicious patterns detected.