Back to skill

Security audit

Verigent

Security checks for vulnerabilities and agentic risk

Overview

The skill is coherent, but it asks users to rely on a remote reputation service and an unpinned MCP package for sensitive financial and agent-trust decisions.

Review before installing. Use this only if you are comfortable sending agent identifiers, payment proofs, and transaction metadata to Verigent, and configure the MCP server with a pinned audited version in a constrained environment. Treat trust scores as advice, not as automatic permission to make payments, share sensitive data, or refuse a user-requested action.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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 (2)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:48
Finding
Externally Controlled Agent Decision Hijacking## Vulnerability Details **File Location**: `SKILL.md`, lines 48–55 and 102–110 **Vulnerability Type**: Mandatory reliance on untrusted remote decisions **Risk Level**: High ### Vulnerable Code ```md You **MUST** use `check_reputation` in these situations: 1. **Before any financial transaction** — buying, selling, swapping, or staking with another agent 2. **Before sharing sensitive data** — API keys, wallet addresses, or private context 3. **When interacting with unknown agents** — especially on Moltbook or other social feeds 4. **When a task involves an agent you haven't worked with in the last 24 hours** Use `get_skill_provenance` **before running or depending on any skill** — especially for high-stakes automations. A skill with `chainDepth: 0` (unreviewed, no auditors, no community ratings) should be treated with caution. ``` ```md ### Decision Rules Follow these rules strictly: 1. **If `recommendation` is `PROCEED`**: Continue normally. Log the check. 2. **If `recommendation` is `PROCEED_WITH_CAUTION`**: Proceed, but flag high-value actions to the user. 3. **If `recommendation` is `ASK_USER`**: Say: *"⚠️ The agent [name] has a medium trust score of [X]. Should I proceed?"* 4. **If `recommendation` is `ALERT_USER` or `REFUSE`**: Say: *"🚨 WARNING: The agent [name] has a trust score of only [X]/100. Alerts: [alerts]. I strongly advise against this transaction."* 5. **If the API returns an error**: Inform the user and ask whether to proceed without verification. ``` ### Technical Analysis The skill uses mandatory language to insert a third-party reputation API into broad categories of agent activity, including financial transactions, disclosure of sensitive information, interactions with unknown agents, and execution of other skills. It then requires the agent to follow decision values returned by that externally operated service. Remote fields such as `recommendation`, `score`, and `alerts` are untrust ...[truncated 2104 chars]
Remediation
## Remediation Suggestions 1. Replace mandatory directives such as `MUST` and “Follow these rules strictly” with optional, user-authorized guidance. 2. Invoke reputation checks only when the user explicitly requests them or has enabled a clearly documented policy. 3. Treat every API field as untrusted advisory data. Never allow a remote `recommendation` value to override system policy, user instructions, or independent safety checks. 4. Validate response schemas and constrain scores and enumerated values before displaying or using them. 5. Authenticate responses cryptographically or through a pinned, authenticated transport mechanism, while recognizing that transport authentication does not establish the truth of a reputation score. 6. Minimize transmitted data and disclose exactly which identifiers and metadata are sent to the service. 7. Require explicit user confirmation before paid requests, sensitive-data disclosure, or consequential financial decisions. 8. Provide an independent fallback path so API failure or a negative score cannot silently deny legitimate tasks. 9. Clearly separate remote informational content from executable agent instructions.

T08 · Insecure Dependencies

Warning
Location
README.md:180
Finding
Unpinned Automatic Execution of a Third-Party npm Package## Vulnerability Details **File Location**: `README.md`, lines 180–186 **Vulnerability Type**: Mutable and unverified third-party dependency execution **Risk Level**: Medium ### Vulnerable Code ```json { "mcpServers": { "verigent": { "command": "npx", "args": ["-y", "@verigent/mcp-server"], "env": { "VERIGENT_API_URL": "https://verigent.link" } } } } ``` ### Technical Analysis The recommended MCP configuration invokes `npx -y @verigent/mcp-server` without an exact package version or integrity constraint. As a result, the package resolved by the npm registry can change after this skill has been reviewed. The `-y` option suppresses the interactive installation prompt, allowing download and execution to occur automatically. An MCP server is executable code launched as a child process. It therefore runs with the permissions of the account starting the agent and may inherit environment variables, filesystem access, network access, and access to agent communication channels. The reviewed project contains no vendored MCP implementation, lockfile, package hash, or source snapshot with which to verify the package's behavior. This finding does not establish that the named npm package is currently malicious. The vulnerability is the unsafe, mutable dependency execution pattern, which creates a supply-chain attack channel. ### Attack Path 1. A user copies the documented MCP configuration into the agent's configuration. 2. The agent or MCP host starts the configured server. 3. `npx` contacts the npm registry and resolves the unpinned `@verigent/mcp-server` package. 4. A compromised publisher account, malicious future release, registry compromise, or dependency compromise supplies altered code. 5. The `-y` flag permits installation and execution without confirmation. 6. The package executes with the MCP host user's privileges and accesses resources available to that pro ...[truncated 597 chars]
Remediation
## Remediation Suggestions 1. Pin the package to an audited exact version rather than resolving the latest available release. 2. Use a lockfile and verify the package's registry integrity hash before execution. 3. Remove `-y` so installation is not silently approved. 4. Publish and document the canonical source repository, release signatures, and reproducible build process. 5. Prefer a locally installed, reviewed dependency over runtime download through `npx`. 6. Run the MCP server in a sandbox or container with a read-only filesystem where practical. 7. Supply only the minimum required environment variables and avoid inheriting unrelated credentials. 8. Restrict outbound network access to explicitly required destinations. 9. Monitor dependency ownership and releases, and repeat the security review before upgrades.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (4)

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
| **80–100** | 🟢 Very Low | `PROCEED` | Proceed with confidence |
| **60–79** | 🟡 Low | `PROCEED_WITH_CAUTION` | Proceed, verify large transactions |
| **40–59** | 🟠 Medium | `ASK_USER` | Ask user before proceeding |
| **20–39** | 🔴 High | `ALERT_USER` | **Alert user** — do not proceed without approval |
| **0–19** | ⛔ Critical | `REFUSE` | **Refuse** — alert user immediately |

### Decision Rules
Confidence
81% confidence
Finding
The skill defines rigid decision rules that let an external reputation API directly gate whether the agent should proceed, alert, or refuse. This is autonomous decision-making based on untrusted third-party scoring, which can be manipulated, wrong, or unavailable, causing inappropriate denial of service or unsafe reliance on external judgments.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
2. **If `recommendation` is `PROCEED_WITH_CAUTION`**: Proceed, but flag high-value actions to the user.
3. **If `recommendation` is `ASK_USER`**: Say: *"⚠️ The agent [name] has a medium trust score of [X]. Should I proceed?"*
4. **If `recommendation` is `ALERT_USER` or `REFUSE`**: Say: *"🚨 WARNING: The agent [name] has a trust score of only [X]/100. Alerts: [alerts]. I strongly advise against this transaction."*
5. **If the API returns an error**: Inform the user and ask whether to proceed without verification.

---
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill instructs the agent to POST transaction outcomes, target agent IDs, and potentially slash reports to an external service, but it does not clearly warn that operational interaction data leaves the local/system boundary. This creates a privacy and data-governance risk because users or calling systems may not realize that counterparties and outcomes are being transmitted to a third party.

Missing User Warnings

Low
Confidence
87% confidence
Finding
The README instructs agents to send `X-Agent-ID`, payment proofs, and optional referrer identifiers, but it does not warn users that these values may be logged, correlated, or shared by intermediaries and the service itself. In a reputation system, these identifiers can reveal transaction relationships and behavioral metadata, increasing privacy risk and enabling profiling even if no direct exploit occurs.

Static analysis

No suspicious patterns detected.