Back to skill

Security audit

Aap

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent messaging guide, but it needs review because its examples send task content and bearer credentials to configurable external providers without strong safeguards.

Install only if you are comfortable using Molten or another trusted AAP provider for agent messaging. Treat all message payloads, recipient addresses, and public-feed posts as externally disclosed; avoid secrets, personal data, proprietary code, legal documents, and regulated information unless you have approved that provider and recipient. Keep `AAP_API_KEY` scoped to its issuing provider, do not reuse it across providers, and consider avoiding the optional SDK unless you can pin and verify the package.

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

T09 · Insecure Skill Coding Practices

Error
Location
skill.md:101
Finding
Bearer credential disclosure through a runtime-configurable provider<![CDATA[ ## Vulnerability Details **File Location**: `skill.md:52-54, 101-103` **Vulnerability Type**: Credential exposure to an unvalidated network destination **Risk Level**: High ### Vulnerable Code ```bash export AAP_ADDRESS="ai:your-name~main#www.molten.it.com" export AAP_API_KEY="your-api-key" export AAP_PROVIDER="www.molten.it.com" ``` ```bash curl "https://${AAP_PROVIDER}/api/v1/inbox?limit=10" \ -H "Authorization: Bearer ${AAP_API_KEY}" ``` ### Technical Analysis The documented inbox command interpolates `AAP_PROVIDER` directly into the destination URL while transmitting `AAP_API_KEY` as a bearer credential. The Skill does not require validation of the provider against a trusted allowlist, verify that the credential was issued for that provider, or explicitly prohibit forwarding authorization headers across redirects. Using HTTPS protects transport confidentiality but does not establish that the selected host is trustworthy. If an attacker, untrusted configuration source, or prior process can influence `AAP_PROVIDER`, the command sends the bearer token to an attacker-controlled HTTPS endpoint. Network communication and authentication are necessary for the declared messaging functionality. However, allowing a runtime-controlled host to receive a sensitive credential without origin binding exceeds the minimum privilege necessary. ### Attack Path 1. The victim obtains or configures a valid AAP API key. 2. An attacker influences the `AAP_PROVIDER` environment variable, or the victim copies an untrusted provider value into it. 3. The victim or agent executes the documented inbox retrieval command. 4. `curl` connects to the attacker-controlled provider and includes `Authorization: Bearer ${AAP_API_KEY}`. 5. The attacker records the bearer token. 6. Where accepted by the legitimate service, the attacker uses the token to retrieve or otherwise access the victim's inbox. ### Impact Assessment Successful exploitation can disclose the AAP bearer cr ...[truncated 437 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Parse and validate the provider hostname against an explicit allowlist of trusted AAP providers. - Bind each API key to the exact origin that issued it and refuse to send it to any other origin. - Reject URLs containing unexpected schemes, ports, user information, paths, or subdomain tricks. - Require HTTPS and perform normal certificate verification. - Disable redirects for authenticated requests, or strip the authorization header and revalidate the destination before following any redirect. - Separate provider configuration from untrusted message content and external agent responses. - Display the final authenticated destination and require explicit user approval when a new provider is selected. - Store the key in a dedicated secret store where available rather than broadly exposing it through inherited process environments. ]]>

T08 · Insecure Dependencies

Warning
Location
skill.md:157
Finding
Unpinned third-party SDK installation creates a supply-chain risk<![CDATA[ ## Vulnerability Details **File Location**: `skill.md:157-159` **Vulnerability Type**: Unpinned dependency installation from the active Python package index **Risk Level**: Medium ### Vulnerable Code ```bash pip install aap-sdk ``` ### Technical Analysis The installation command requests `aap-sdk` without a fixed version, integrity hash, locked dependency set, or explicit authoritative package source. As a result, the installed code depends on mutable package-index state at the time the command is executed. Python packages and their transitive dependencies can execute code during installation or later when imported. A compromised maintainer account, malicious package release, package-index compromise, or dependency substitution could therefore introduce code that was not present during this Skill audit. The SDK is explicitly optional, so accepting mutable third-party executable code is not required for the Skill's basic `curl`-based messaging functionality. ### Attack Path 1. An attacker compromises the package, its maintainer account, the configured package index, or a transitive dependency. 2. The attacker publishes a malicious version that satisfies the unrestricted package request. 3. A user or agent follows the Skill instructions and runs `pip install aap-sdk`. 4. `pip` resolves and installs the malicious or compromised release. 5. Malicious code executes during installation or when the SDK is imported by the supplied Python example. 6. The code gains the privileges of the user running Python and can access data available to that process. ### Impact Assessment Exploitation could result in arbitrary code execution with the privileges of the user who installs or imports the dependency. Depending on the environment, exposed assets may include project files, environment variables such as `AAP_API_KEY`, network credentials accessible to the process, and the ability to make outbound requests. The audited file does not prove that the current ...[truncated 107 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin the SDK and all transitive dependencies to specifically reviewed versions. - Use a lock file and require cryptographic hashes, such as installation with `--require-hashes`. - Document and enforce the authoritative package repository. - Verify that the published package identity corresponds to the linked source repository. - Install the package in an isolated virtual environment with minimum filesystem and network privileges. - Maintain a reviewed internal package mirror where practical. - Add automated dependency vulnerability, provenance, and integrity checks. - Preserve the dependency-free `curl` workflow so users do not need to install the optional SDK. ]]>

other

Warning
Location
skill.md:111
Finding
External collaboration examples may disclose sensitive task content without safeguards<![CDATA[ ## Vulnerability Details **File Location**: `skill.md:111-151` **Vulnerability Type**: External disclosure of task data **Risk Level**: Medium ### Vulnerable Code ```bash curl -X POST "https://${AAP_PROVIDER}/api/v1/inbox/reviewer_main" \ -H "Content-Type: application/json" \ -d '{ "envelope": { "from_addr": "'${AAP_ADDRESS}'", "to_addr": "ai:reviewer~main#www.molten.it.com", "message_type": "private" }, "payload": { "content": "Please review this code: def hello(): print(\"world\")" } }' ``` ```bash curl -X POST "https://${AAP_PROVIDER}/api/v1/inbox/lawyer_main" \ -H "Content-Type: application/json" \ -d '{ "envelope": { "from_addr": "'${AAP_ADDRESS}'", "to_addr": "ai:lawyer~main#www.molten.it.com", "message_type": "private" }, "payload": { "content": "What is the maximum contract penalty?" } }' ``` ```bash curl -X POST "https://${AAP_PROVIDER}/api/v1/inbox/feed_public" \ -H "Content-Type: application/json" \ -d '{ "envelope": { "from_addr": "'${AAP_ADDRESS}'", "to_addr": "ai:feed~public#${AAP_PROVIDER}", "message_type": "public" }, "payload": { "content": "Task: Translate this document. DM me if interested." } }' ``` ### Technical Analysis The examples encourage agents to transmit source code, legal questions, and document-related task information to external agents or a public feed. This network transmission is consistent with the Skill's declared communication purpose and is not concealed exfiltration. Nevertheless, the instructions do not require data classification, redaction, recipient verification, provider approval, or user consent before task context is disclosed. The `private` message designation does not establish end-to-end confidentiality or prevent the provider and recipient from retaining the content. The public-feed example creates a broader disclosure risk because its intended audience is p ...[truncated 1032 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Require explicit user approval before sending task content to any external agent or public feed. - Show the exact destination, visibility level, and content that will be transmitted. - Default to private communication and require separate confirmation for public messages. - Add clear warnings not to transmit credentials, personal data, confidential documents, proprietary code, or regulated information. - Minimize and redact payloads before transmission; send only the information required for the collaboration task. - Authenticate recipients and validate provider domains before sending content. - Document provider-side encryption, retention, logging, deletion, and privacy policies. - Where sensitive collaboration is required, use an approved provider and end-to-end encryption. ]]>
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 (3)

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill explicitly promotes discovering and sending messages to external providers, but it does not clearly warn users that message contents, recipient addresses, and related metadata will leave the local system and be transmitted to third-party infrastructure. In an agent context, this can lead to unintentional disclosure of sensitive prompts, task data, or internal identifiers during normal use.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The examples instruct users to register, export, and use API keys in shell commands without warning about credential handling risks such as shell history leakage, terminal logging, shared session exposure, or use in untrusted environments. Because the API key grants inbox access, poor handling could allow unauthorized access to private messages or agent identity misuse.

External Transmission

Medium
Category
Data Exfiltration
Content
Register on Molten to get your AAP address:

```bash
curl -X POST https://www.molten.it.com/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{
    "owner": "your-name",
Confidence
89% confidence
Finding
The registration example sends data to an external service, establishing a workflow centered on outbound network transmission to a third-party provider. While the transmitted sample fields are not highly sensitive by themselves, this external dependency can normalize sending agent-related data off-system and may expose identifying or operational metadata without sufficient user awareness.

Static analysis

No suspicious patterns detected.