Back to skill

Security audit

Ev Charger

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent EV charger lookup integration, but users should understand it sends search and location data to Camino AI and uses mutable install commands.

Install only if you are comfortable using Camino AI as a third-party service for EV charger searches. Prefer a pinned install source when possible, store the API key with appropriate local permissions, and avoid sending precise home or sensitive trip locations unless you accept that those query details are transmitted to Camino AI.

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:10
Finding
Unpinned Remote Dependencies and Mutable Installation Sources<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 10–23 **Vulnerability Type**: Supply-chain exposure through unpinned remote 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 ev-charger ``` ```bash npx clawhub@latest install ev-charger # or: pnpm dlx clawhub@latest install ev-charger # or: bunx clawhub@latest install ev-charger ``` ### Technical Analysis The documented installation commands resolve and execute content from mutable remote sources. The GitHub installation is not pinned to a reviewed commit or immutable release, while the package-runner commands explicitly request the mutable `latest` version of `clawhub`. Tools such as `npx`, `pnpm dlx`, and `bunx` can download and execute package code during installation. Consequently, the effective installer code may change after this Skill has been reviewed. A compromised registry account, upstream repository, maintainer account, or future malicious release could therefore introduce code that was not part of the audited project. The reviewed Skill does not itself contain a malicious dependency. The risk arises when a user follows the documented installation instructions. ### Attack Path 1. An attacker compromises the `clawhub` package, its publishing account, the referenced GitHub repository, or another relevant upstream distribution channel. 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 installation commands. 4. The package runner or installer retrieves the modified remote content. 5. The malicious package or installer code executes with the privileges of the user running the command. 6. Depending on those privileges, the payload could access user files, environment varia ...[truncated 653 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace `@latest` with an explicitly reviewed package version. 2. Pin GitHub installations to an immutable commit hash rather than the repository's default branch. 3. Where supported, use package lockfiles and verify registry integrity hashes. 4. Publish expected checksums or signatures for released Skill artifacts and document how users can verify them. 5. Review installer lifecycle scripts and transitive dependencies before updating pinned versions. 6. Recommend installation under a non-privileged account and avoid suggesting `sudo` or administrator execution. 7. Use a controlled release process so dependency updates require review before documentation is changed. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/ev-charger.sh:34
Finding
Unvalidated URL Parameters Permit Curl URL Globbing and Query Manipulation<![CDATA[ ## Vulnerability Details **File Location**: `scripts/ev-charger.sh`, lines 34–65 **Vulnerability Type**: Improper input validation and unsafe URL construction **Risk Level**: Medium ### Vulnerable Code ```bash # Build query string from JSON input build_query_string() { # Use provided query or default to "EV charging stations" local query=$(echo "$INPUT" | jq -r '.query // "EV charging stations"') local encoded_query=$(jq -rn --arg v "$query" '$v|@uri') local params="query=${encoded_query}" # Optional parameters with defaults local lat=$(echo "$INPUT" | jq -r '.lat // empty') local lon=$(echo "$INPUT" | jq -r '.lon // empty') local radius=$(echo "$INPUT" | jq -r '.radius // "5000"') local limit=$(echo "$INPUT" | jq -r '.limit // "20"') [ -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) # Make API request 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 . ``` ### Technical Analysis The script validates that its argument is syntactically valid JSON, but it does not validate the types, ranges, or formats of `lat`, `lon`, `radius`, and `limit`. These values are inserted directly into the request URL without percent-encoding. By default, curl supports URL globbing using brace and bracket expressions, including patterns such as `{a,b}` and `[1-100]`. Shell quoting does not disable curl's own URL-globbing parser. An attacker able to control the JSON argument can therefore supply a string containing curl glob syntax and cause a single invocation to expand into multiple authenticated requests. Unencoded delimiter characters such as `&`, `=`, and `#` may also alter the intended query-string structure. ...[truncated 1680 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Enforce the documented JSON schema before building the request: - `lat` must be numeric and between `-90` and `90`. - `lon` must be numeric and between `-180` and `180`. - `radius` must be a positive integer with a documented upper bound. - `limit` must be an integer between `1` and `100`. - `query` must be a string with a reasonable maximum length. 2. Reject arrays, objects, booleans, and numeric fields supplied as strings. 3. Avoid manually concatenating a query string. Use curl's parameter encoding: ```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` even after validation as defense in depth. 5. Add connection and overall request timeouts to prevent indefinite execution. 6. Use `--fail-with-body --show-error` so HTTP and network failures are reported instead of being obscured by the output pipeline. 7. Add tests covering curl glob characters, query delimiters, fragments, incorrect JSON types, boundary values, and excessively large inputs. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (11)

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
The skill instructs users to place an API key into `~/.claude/settings.json`, which is a sensitive agent configuration location. Modifying this directory can affect broader agent behavior and may expose secrets to other skills, logs, backups, or unintended tooling if access controls are weak.

Lp3

Medium
Category
MCP Least Privilege
Confidence
84% confidence
Finding
The skill includes shell-based installation and execution instructions but does not declare any explicit tool scope or allowed-tools boundaries. In an agent setting, this can lead to over-broad shell access being assumed or granted, increasing the chance that the skill is run with more capability than necessary.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Using `npx skills add https://github.com/barneyjm/camino-skills` without pinning a version, tag, or commit means the installed code can change over time. If the upstream package or referenced repo is compromised, users may fetch and execute unexpected code during installation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Installing a specific skill from an unpinned GitHub source still leaves users exposed to supply-chain changes in the repository state. A later malicious or accidental change could alter the skill content or associated scripts without the user realizing it.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
`npx clawhub@latest install ev-charger` explicitly tracks the latest version, which is mutable and could introduce malicious or breaking changes at any time. This is a classic supply-chain risk because execution happens before the user can meaningfully review what changed.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The setup flow asks the user to transmit an email address to a third-party API endpoint to obtain a trial key, but it gives no privacy notice or data-handling explanation. This creates a privacy and compliance risk because users may disclose personally identifiable information without understanding retention, sharing, or consent implications.

External Transmission

Medium
Category
Data Exfiltration
Content
**Instant Trial (no signup required):** Get a temporary API key with 25 calls:

```bash
curl -s -X POST -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}' \
  https://api.getcamino.ai/trial/start
```
Confidence
93% confidence
Finding
This command sends user-provided email data to an external service endpoint. Even though this is part of normal product setup, it is still an external data transmission and should be treated as sensitive because it shares personal information outside the local environment.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
curl -s -X POST -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}' \
  https://api.getcamino.ai/trial/start
```

Returns: `{"api_key": "camino-xxx...", "calls_remaining": 25, ...}`
Confidence
50% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
curl -s -X POST -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}' \
  https://api.getcamino.ai/trial/start
```

Returns: `{"api_key": "camino-xxx...", "calls_remaining": 25, ...}`
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-supplied query and location fields such as lat, lon, and radius to a third-party Camino API, but the script itself provides no user-facing notice that precise destination or route-adjacent location data will leave the local environment. In a skill context, this is a genuine privacy issue because location data can be sensitive, and users or calling agents may not realize the data is being disclosed externally.

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
90% confidence
Finding
The script makes an outbound request to https://api.getcamino.ai/query and includes user-derived parameters in the URL query string, along with an API key in a header. External transmission is expected for this skill's functionality, but it is still a true data exposure boundary because sensitive location/search data is sent to a remote service and may be logged by intermediaries or the provider.