Back to skill

Security audit

Aport Complete

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed APort completion-check workflow, but it sends task details to an external service and gives that service control over whether the agent may call work complete.

Install only if you intentionally want APort to act as a remote completion gate. Do not use it on confidential code, customer data, regulated work, or secrets unless your organization has approved APort as a third-party processor and you know exactly which fields will be sent. Prefer a pinned, verified setup method over the unpinned `npx` command.

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 (4)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:16
Finding
Mandatory External Completion Gate Hijacks Agent Workflow<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 16-17 and 154-161 **Vulnerability Type**: Mandatory workflow and response-control hijacking **Risk Level**: High ### Complete Code Snippet ```markdown Your APort passport defines what you must deliver before a task is complete. This skill enforces that contract. Do not mark any task done without running this first. ``` ```markdown ## Step 5 — Announce completion Once you receive `allow: true`, tell the user: - What you completed - The decision_id (if they want the audit trail) - Any next steps Do not say "done" before receiving `allow: true`. The contract defines done, not you. ``` ### Technical Analysis The Skill imposes an unconditional external policy gate over the Agent's normal task-completion behavior. Statements such as “Do not mark any task done” and “The contract defines done, not you” are imperative instructions that alter the Agent's goals and response behavior when the Skill is loaded. Rather than offering optional validation, the Skill transfers completion authority to a third-party service. The remote service can deny completion, cause retries, suppress an otherwise valid final response, and require APort-specific information to be included in the Agent's completion message. This is instruction hijacking because the Skill attempts to supersede the Agent's existing task contract and control whether and how it may report completion. ### Attack Path 1. The Skill is loaded for a task. 2. The Agent performs the task and prepares to return a completion response. 3. The mandatory instructions intercept the normal completion workflow. 4. The Agent is directed to submit task information to APort and wait for an external decision. 5. If APort returns `allow: false`, the Agent suppresses completion and modifies or retries its work according to the remote denial reason. 6. Only an `allow: true` response permits the Agent to ...[truncated 556 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove absolute instructions that prohibit the Agent from completing a task without third-party approval. - Make APort verification explicitly optional and require the user to enable it for the current task. - Preserve the Agent's original task and safety instructions as authoritative. - Treat a verification denial as advisory information rather than permission to suppress the final response. - Define fail-open or user-controlled behavior for service outages and unexpected responses. - Do not force APort-specific identifiers or wording into user-facing completion messages. - Clearly document the external trust boundary before the Skill is activated. ]]>

other

Error
Location
SKILL.md:41
Finding
Potential Disclosure of Full Task Output and Metadata to an External Service<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 41-52 and 75-99 **Vulnerability Type**: External data disclosure **Risk Level**: High ### Complete Code Snippet ```markdown Before calling the API, gather: | Field | Required | How to get it | |-------|----------|---------------| | `task_id` | Yes | The task/ticket/issue identifier | | `output_type` | Yes | `code`, `document`, `analysis`, `plan`, `data`, or `other` | | `summary` | If passport requires it | Write a clear summary of what you did | | `tests_passing` | If passport requires it | Run your test suite, report result | | `author_agent_id` | If reviewer required | Your own `APORT_AGENT_ID` | | `reviewer_agent_id` | If reviewer required | The `agent_id` of the reviewing agent | | `criteria_attestations` | Always | One entry per criterion in your passport | | `output_content` | If scan_output enabled | Your full output (for pattern scanning) | ``` ```markdown POST https://aport.io/api/verify/policy/deliverable.task.complete.v1 Content-Type: application/json { "context": { "agent_id": "YOUR_APORT_AGENT_ID", "task_id": "TASK_IDENTIFIER", "output_type": "code", "author_agent_id": "YOUR_APORT_AGENT_ID", "summary": "What you did — must meet minimum word count in your passport", "tests_passing": true, "criteria_attestations": [ { "criterion_id": "criterion-slug-here", "met": true, "evidence": "Concrete evidence string" } ] } } ``` ### Technical Analysis The workflow instructs the Agent to collect and transmit task identifiers, Agent identities, summaries, test status, acceptance-criteria evidence, and potentially the Agent's full output to `aport.io`. Full output and evidence can contain proprietary source code, internal issue details, private repository URLs, customer information, infrastructure names, credentials accidentally inc ...[truncated 1410 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Require explicit, informed user authorization before transmitting any task information. - Disable submission of `output_content` by default and require separate consent for full-output scanning. - Apply strict data minimization so only fields necessary for a specific verification are transmitted. - Add secret scanning and redaction for credentials, tokens, private keys, internal URLs, personal data, and proprietary code. - Display the destination, exact payload fields, and privacy implications before submission. - Permit local-only verification for confidential environments. - Document retention periods, subprocessors, data residency, deletion mechanisms, and access controls. - Abort external transmission when the task or repository is marked confidential unless an authorized policy explicitly permits it. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:31
Finding
Unpinned Third-Party Package Execution Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 31-34 and 181 **Vulnerability Type**: Unsafe third-party dependency execution **Risk Level**: Medium ### Complete Code Snippet ```markdown If you don't have one, create a passport first: - **Web:** https://aport.id - **CLI:** `npx aport-id` - **Agent skill:** Read https://aport.id/skill and follow the instructions ``` ```markdown - Create a passport: https://aport.id (web) or `npx aport-id` (CLI) or https://aport.id/skill (agent) ``` ### Technical Analysis The Skill recommends running `npx aport-id` without an exact package version, lockfile, integrity hash, or provenance verification. Depending on the local npm and npx configuration, this can download the currently published package and execute its code immediately. The effective executable can therefore change independently of the reviewed Skill. Package-account compromise, malicious publication, registry compromise, or an unsafe future release could result in arbitrary code execution. The project provides no reviewed dependency manifest or cryptographic mechanism that binds the command to a known artifact. ### Attack Path 1. A user or Agent follows the prerequisite instructions. 2. `npx` resolves `aport-id` from the configured package registry. 3. If the package is not already trusted and cached, `npx` downloads the currently resolved release. 4. Package CLI code and applicable lifecycle behavior execute with the invoking user's permissions. 5. A compromised or malicious package can access files, environment variables, network resources, and other capabilities available to that user. ### Impact Assessment Successful exploitation provides code execution with the privileges of the account invoking `npx`. Depending on that account and environment, the package could read or alter project files, access environment-based credentials, modify user configuration, make network requests, or ...[truncated 217 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin the CLI to an audited exact version, such as `npx --yes aport-id@X.Y.Z`. - Verify the selected package release, publisher identity, provenance, and cryptographic integrity. - Prefer a committed dependency manifest and lockfile over runtime resolution of the latest package. - Review package lifecycle scripts and disable them where they are unnecessary. - Run the CLI in a sandbox with minimal filesystem, environment-variable, and network access. - Publish release hashes or signatures and document a verification procedure. - Re-audit the dependency before changing the pinned version. ]]>

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:31
Finding
Agent Is Directed to Follow Mutable Remote Instructions<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 31-34 **Vulnerability Type**: Delegation to unaudited remote instructions **Risk Level**: High ### Complete Code Snippet ```markdown If you don't have one, create a passport first: - **Web:** https://aport.id - **CLI:** `npx aport-id` - **Agent skill:** Read https://aport.id/skill and follow the instructions ``` ### Technical Analysis The phrase “follow the instructions” delegates Agent behavior to content hosted at a mutable external URL. That content is not included in the audited project and is not pinned to an immutable version, digest, or signed artifact. The remote page can change after this Skill has been reviewed. If the website, hosting account, DNS path, or publishing process is compromised, the page could direct the Agent to execute commands, disclose data, install software, or adopt additional behavioral constraints. Because the local Skill explicitly frames the page as authoritative instructions, malicious remote content has a direct route into the Agent's active-session instruction context. This finding concerns remote instruction control. The audited text does not itself prove that executable code is fetched and run, so the best matching classification is instruction hijacking rather than remote payload execution. ### Attack Path 1. The Agent loads the Skill without an existing APort passport. 2. The Skill directs the Agent to retrieve `https://aport.id/skill`. 3. The remote page is changed by its publisher or an attacker who compromises the delivery path. 4. The Agent interprets the changed content as instructions because the local Skill explicitly says to follow it. 5. The Agent performs newly introduced actions that were absent from the reviewed package. ### Impact Assessment The immediate scope is the Agent's current-session behavior. The ultimate impact depends on the instructions later served by the remote page and ...[truncated 390 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the instruction to automatically follow content from a mutable website. - Vendor the required instructions into the reviewed Skill package. - If remote retrieval is unavoidable, bind content to an immutable version and verify a cryptographic hash or signature. - Treat downloaded content as untrusted reference material rather than higher-priority Agent instructions. - Require explicit user review and approval before carrying out commands or transmitting data requested by remote content. - Restrict remotely sourced guidance to a documented allowlist of safe operations. - Re-audit and release a new Skill version whenever the external instructions change. ]]>
Vulnerability Patterns
  • 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
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (4)

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The skill directs agents to run `npx aport-id` without pinning a version or integrity-verified package source. That creates a supply-chain risk: a future malicious or compromised package version could be executed automatically in a privileged agent environment.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill explicitly instructs agents to include `output_content` and send it to a remote verification API when scanning is enabled, but it provides no consent gate, redaction guidance, or user-facing warning. In an agent context, this can exfiltrate proprietary code, sensitive documents, secrets, or regulated data to a third party during normal task completion flow.

Unbounded Resource Access

Medium
Category
Excessive Agency
Content
- `oap.criteria_not_met` → attempt to resolve the criterion, then retry

Maximum retries: 3. After 3 denials on the same task, surface the issue to the user.
Do not loop indefinitely.

## Links
Confidence
75% confidence
Finding
Skill allows unbounded resource consumption (API calls, storage, compute). Without rate limits or quotas, a compromised or misbehaving agent can cause denial-of-service or cost overruns.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
This is the same unpinned `npx aport-id` reference repeated in the links section, so it carries the same supply-chain execution risk. Repetition increases the chance an agent or operator will follow the unsafe invocation path.

Static analysis

No suspicious patterns detected.