Back to skill

Security audit

Auth0 Token Vault

Security checks for vulnerabilities and agentic risk

Overview

The skill matches its stated Auth0 Token Vault purpose, but it grants broad write-capable access to email, Slack, Calendar, GitHub, and custom APIs with under-scoped raw fetch behavior and an unpinned setup command.

Install only if you are comfortable letting the agent act through your connected accounts. Use narrow OAuth scopes and allowed domains, avoid broad custom connections, do not paste Auth0 secrets or tokens into chat, and manually review any send, delete, post, update, or fetch request, especially non-GET fetch calls. Prefer a pinned and reviewed setup package version before running the npx installer path.

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

T08 · Insecure Dependencies

Warning
Location
SKILL.md:69
Finding
Unpinned Third-Party Package Execution During Auth0 Setup## Vulnerability Details **File Location**: `SKILL.md`, line 69 **Vulnerability Type**: Supply-chain risk from unpinned package execution **Risk Level**: Medium **Vulnerable Code**: ```bash npx configure-auth0-token-vault ``` ### Technical Analysis The manual setup procedure instructs the user to execute `configure-auth0-token-vault` through `npx` without specifying a version or verifying package integrity. Consequently, the code resolved from the package registry at execution time may differ from the version reviewed when this Skill was published. The project contains no lockfile, checksum, vendored source, or other mechanism that constrains or verifies the package executed by this command. Because the setup process handles Auth0 configuration and authentication, a compromised registry account, malicious package release, or compromised transitive dependency could execute arbitrary code in a credential-sensitive context. This finding concerns the unpinned manual setup command, not the documented Auth0 network functionality itself. Authenticated requests and remote connection-status retrieval are consistent with the Skill's declared purpose. No evidence of deliberate token exfiltration was identified in the reviewed files. ### Attack Path 1. An attacker compromises the package, its publisher account, the package registry delivery path, or a transitive dependency. 2. The attacker publishes a malicious version under the expected package name. 3. A user follows the manual setup instructions and runs `npx configure-auth0-token-vault`. 4. `npx` resolves and downloads the mutable package version from the registry. 5. The malicious package executes with the invoking user's local privileges during Auth0 setup. 6. It may read accessible local files, environment variables, Auth0 setup material, or credentials exposed during the configuration flow and transmit them externally. ### Impact Assessment Successful exploitation co ...[truncated 529 chars]
Remediation
## Remediation Suggestions 1. Pin the package to a specifically reviewed version, for example: ```bash npx --yes configure-auth0-token-vault@<reviewed-version> ``` 2. Verify the package publisher, provenance, signature, and registry integrity metadata before recommending execution. 3. Use a lockfile and integrity hashes where the installation workflow permits them. 4. Prefer setup functionality included in an already pinned and audited `auth0-tv` release rather than retrieving a separate executable package at runtime. 5. Publish the package source and reviewed commit or release identifier so users can correlate the executed artifact with audited code. 6. Run setup with minimum user privileges and avoid exposing unrelated secrets through environment variables. 7. Warn users not to record, share, or persist terminal output containing the client secret produced by the separate `auth0 apps show <APP_ID> --reveal-secrets` step.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (8)

Missing User Warnings

Medium
Confidence
85% confidence
Finding
The skill description emphasizes broad authenticated access to Gmail, Slack, Google Calendar, GitHub, and arbitrary API calls, but it does not prominently warn that using the skill can read private data and perform actions on the user's behalf. Because the skill spans multiple high-value services and supports destructive operations and authenticated fetches, missing privacy/integrity warnings can lead to unsafe or poorly informed use.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
The skill instructs users to run `npx configure-auth0-token-vault` without pinning a version or integrity-checked source. That creates a supply-chain risk: a newer or compromised package version could execute unexpected code during an interactive setup flow that has access to Auth0 configuration context and potentially sensitive local environment data.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The manual setup section tells the user to reveal the Auth0 app secret and then use it during login, but it does not explicitly warn against pasting that secret back into the agent or exposing it in shared terminals/logs. In an agent-mediated workflow, omission of that warning increases the chance that highly sensitive credentials are disclosed into chat history, command traces, or other telemetry.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The documented `fetch` passthrough enables arbitrary authenticated HTTPS requests using the user's third-party access token, including state-changing methods and attacker-supplied headers/body. In an agent skill context, this materially expands capability beyond the safer high-level commands and can be abused to exfiltrate data or perform unintended actions against external services, while the documentation does not prominently warn that this is effectively raw delegated API access.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
# Known services
auth0-tv --json fetch github https://api.github.com/user
auth0-tv --json fetch gmail https://gmail.googleapis.com/gmail/v1/users/me/messages -X GET
auth0-tv --json fetch slack https://slack.com/api/conversations.list
auth0-tv --json fetch github https://api.github.com/repos/octocat/Hello-World/issues -X POST -d '{"title":"Bug"}'
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
auth0-tv --json fetch github https://api.github.com/user
auth0-tv --json fetch gmail https://gmail.googleapis.com/gmail/v1/users/me/messages -X GET
auth0-tv --json fetch slack https://slack.com/api/conversations.list
auth0-tv --json fetch github https://api.github.com/repos/octocat/Hello-World/issues -X POST -d '{"title":"Bug"}'
auth0-tv --json fetch github https://api.github.com/user -H "Accept: application/vnd.github.v3+json"
auth0-tv --json fetch slack https://slack.com/api/chat.postMessage -X POST --data-file ./payload.json
Confidence
88% confidence
Finding
This example documents a POST request to Slack's `chat.postMessage` endpoint via raw `fetch`, demonstrating that the passthrough can perform arbitrary state-changing authenticated actions against external services. In an agent setting, exposing generic write-capable HTTP access increases the risk of unauthorized outbound actions or covert data transmission compared with constrained first-class commands.

External Transmission

Medium
Category
Data Exfiltration
Content
auth0-tv --json fetch gmail https://gmail.googleapis.com/gmail/v1/users/me/messages -X GET
auth0-tv --json fetch slack https://slack.com/api/conversations.list
auth0-tv --json fetch github https://api.github.com/repos/octocat/Hello-World/issues -X POST -d '{"title":"Bug"}'
auth0-tv --json fetch github https://api.github.com/user -H "Accept: application/vnd.github.v3+json"
auth0-tv --json fetch slack https://slack.com/api/chat.postMessage -X POST --data-file ./payload.json

# Custom connections (requires --allowed-domains set during connect)
Confidence
90% confidence
Finding
The custom-connection `fetch` example shows authenticated requests to arbitrary enterprise APIs once a connection is configured with allowed domains. Because custom connections can target organization-specific services, this capability can expose sensitive internal data or permit high-impact actions if an agent is induced to use broad scopes or permissive domain allowlists.

External Transmission

Medium
Category
Data Exfiltration
Content
auth0-tv --json fetch slack https://slack.com/api/chat.postMessage -X POST --data-file ./payload.json

# Custom connections (requires --allowed-domains set during connect)
auth0-tv --json fetch my-enterprise-idp https://api.example.com/users/me
```

| Flag                    | Description                    | Default |
Confidence
50% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Static analysis

No suspicious patterns detected.