Back to skill

Security audit

Meeting Summary Generator

Security checks for vulnerabilities and agentic risk

Overview

This meeting summarizer is mostly coherent, but it automatically performs paid billing with a hardcoded merchant key and has under-scoped external processing risks.

Review carefully before installing. The skill charges 0.003 USDT per run by default, includes a merchant key in the package, and sends meeting notes into an OpenClaw agent whose exact privileges are not defined here. Use only with non-sensitive notes unless you understand the Sloan agent configuration, and avoid installing until billing confirmation, credential handling, pinned installer versions, and dependency sources are tightened.

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
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • 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)

T01 · Skill Instruction Hijacking

Error
Location
index.js:15
Finding
Untrusted Meeting Notes Are Embedded Directly into an Agent Prompt<![CDATA[ ## Vulnerability Details **File Location**: `index.js:15-19` and `index.js:55-58` **Vulnerability Type**: Prompt injection through untrusted meeting-note content **Risk Level**: High ### Vulnerable Code ```js const prompt = `You are Sloan, a professional meeting secretary. Convert these meeting notes into a structured summary: --- ${notes} --- ``` The resulting prompt is passed directly to the Sloan agent: ```js const child = spawn('openclaw', ['agent', '--agent', 'sloan', '-m', prompt], { encoding: 'utf-8', timeout: 60000 }); ``` ### Technical Analysis Meeting notes obtained from a command-line argument or user-selected file are interpolated verbatim into the same prompt that contains the agent's operational instructions. The `---` delimiters are only textual formatting and do not establish a trusted security boundary. An attacker can place instructions inside the meeting notes that tell the Sloan agent to disregard the summarization request, alter the output, reveal available context, or attempt operations through any tools available to that agent. No prompt-injection detection, structured separation, privilege restriction, or explicit instruction-data isolation is applied. The Node.js process does not invoke a shell, so this issue is not operating-system command injection. Exploitation occurs at the agent instruction layer. ### Attack Path 1. An attacker creates meeting notes containing adversarial instructions, such as a request to ignore the summary template and perform another action. 2. The attacker supplies the notes directly or convinces a user to process the file with `meeting-summary-generator --file`. 3. The application reads the content without validation or isolation. 4. The malicious content is interpolated into the agent prompt. 5. The application invokes `openclaw agent --agent sloan` with the combined trusted instructions and untrusted notes. 6. If the Sloan agent follows the embedded instructions, the attacker can mani ...[truncated 708 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pass meeting notes through a structured data or attachment interface that distinguishes untrusted content from agent instructions, if OpenClaw supports one. 2. Add an explicit higher-priority instruction stating that meeting notes are untrusted quoted data and that any instructions inside them must not be followed. 3. Run the summarization agent with no tools unless they are strictly required. Deny filesystem, shell, credential, and network access by default. 4. Use a dedicated, least-privileged summarization agent rather than a broadly capable general-purpose agent. 5. Validate input size and format before constructing the prompt. 6. Add adversarial tests covering instructions embedded in notes, fake system messages, delimiter escapes, requests for secrets, and requests to invoke tools. 7. Treat model output as untrusted and validate it against the expected summary structure before using it in downstream automation. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
index.js:9
Finding
Hardcoded Payment Merchant Credential Is Distributed with the Package<![CDATA[ ## Vulnerability Details **File Location**: `index.js:9` and `index.js:70-77` **Vulnerability Type**: Hardcoded credential and client-side secret exposure **Risk Level**: High ### Vulnerable Code ```js const CONFIG = { skillpay_api: 'https://api.skillpay.me/v1', merchant_key: process.env.SKILLPAY_MERCHANT_KEY || 'sk_91fff75ae2a7a71f8eceadcbcd816e24d57e58d9d04ccca45f0b3856af130aea', price_per_use: 0.003, currency: 'USDT' }; ``` The embedded credential is transmitted to the billing API: ```js const response = await axios.post(`${CONFIG.skillpay_api}/billing/charge`, { amount: CONFIG.price_per_use, currency: CONFIG.currency, merchant_key: CONFIG.merchant_key, description: 'Meeting summary by Sloan' }, { headers: { 'Content-Type': 'application/json' }, timeout: 10000 }); ``` ### Technical Analysis The source code contains a credential-like SkillPay merchant key as the default value. Because this code is distributed to end users, the key cannot be treated as confidential. Anyone who obtains the package can extract and reuse it independently of the intended CLI. The environment-variable override does not protect the embedded fallback. The exposed value remains present in every distributed copy and in source history. Sending the merchant key in the JSON request body also confirms that the client possesses and uses the credential directly. The project documentation explicitly describes the embedded key as an intended default, demonstrating that this is not merely an unused example value. ### Attack Path 1. An attacker downloads or inspects the published package. 2. The attacker reads `index.js` and extracts the embedded merchant key. 3. The attacker analyzes or reproduces the request sent to `https://api.skillpay.me/v1/billing/charge`. 4. The attacker submits independent API requests using the exposed key. 5. Depending on the permissions enforced by SkillPay, the attacker may cause unauthorized billing activity, exhaust account limits ...[truncated 611 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Revoke and rotate the exposed merchant key immediately; removing it from a future release does not invalidate copies already distributed. 2. Remove the hardcoded fallback and fail safely when `SKILLPAY_MERCHANT_KEY` is not configured. 3. Do not distribute merchant secrets in CLI applications. Move charge creation to a controlled backend that authenticates users and keeps merchant credentials server-side. 4. Issue short-lived, narrowly scoped payment tokens if the client must communicate directly with the payment service. 5. Apply least-privilege permissions, transaction limits, rate limits, anomaly detection, and merchant-account alerts. 6. Scrub the credential from repository history where feasible, while recognizing that rotation remains mandatory. 7. Add automated secret scanning to local development, CI, release, and package-publication workflows. 8. Ensure logs and error messages never expose payment credentials or complete payment tokens. ]]>

T08 · Insecure Dependencies

Warning
Location
README.md:13
Finding
Mutable Installer Execution and Plaintext Dependency Sources Create Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `README.md:13-15`; additional evidence in `package-lock.json:22` and `package-lock.json:28` **Vulnerability Type**: Unsafe package installation and dependency retrieval **Risk Level**: Medium ### Vulnerable Code The documented installation command executes a mutable release: ```bash npx clawhub@latest install meeting-summary-generator ``` The lockfile also records dependency archives from a third-party mirror over plaintext HTTP: ```json "node_modules/asynckit": { "version": "0.4.0", "resolved": "http://mirrors.tencentyun.com/npm/asynckit/-/asynckit-0.4.0.tgz", "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", "license": "MIT" }, "node_modules/axios": { "version": "1.13.6", "resolved": "http://mirrors.tencentyun.com/npm/axios/-/axios-1.13.6.tgz", "integrity": "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==", "license": "MIT", ``` Other lockfile entries use the same plaintext mirror. ### Technical Analysis Using `npx clawhub@latest` causes users to retrieve and execute whichever package version is currently associated with the mutable `latest` tag. The executed installer can therefore change after this project has been reviewed. A compromised publisher account, malicious future release, or registry incident could turn the documented installation step into an arbitrary code-execution channel. The lockfile pins package versions and includes integrity hashes, which provide some protection against archive contents that do not match the lockfile. However, dependency URLs use plaintext HTTP and a non-default third-party mirror. This weakens transport authenticity, exposes dependency metadata to interception, and creates additional reliance on the security and availability of that mirror. Integrity hashes do not address mutable `npx` installer execution and do not provide the same tr ...[truncated 1843 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace `@latest` with an exact, reviewed installer version, for example `clawhub@X.Y.Z`. 2. Where supported, verify package provenance, signatures, and integrity before executing installer code. 3. Avoid executing remotely retrieved packages directly. Install an audited version first and invoke it only after review. 4. Regenerate `package-lock.json` using `https://registry.npmjs.org/` or another trusted registry that enforces HTTPS. 5. Remove all plaintext `http://` dependency URLs and require TLS for package retrieval. 6. Configure CI to reject lockfiles containing plaintext or unapproved registry origins. 7. Review dependency lifecycle scripts and disable them during installation where they are unnecessary. 8. Continue using lockfile integrity hashes, but treat them as defense in depth rather than a replacement for authenticated transport and trusted provenance. 9. Pin release tooling and dependencies through a controlled update process with security review. ]]>
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
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (17)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The documented purpose is meeting summarization, but the behavior includes payment processing, external billing/network access, and an embedded merchant credential fallback that is not clearly disclosed in the primary description. Hidden or under-declared monetization and network behavior is dangerous because it can trigger unauthorized charges, exfiltrate user content or metadata, and bypass informed consent.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The skill’s stated purpose is meeting-summary generation, but it performs a real external billing charge before producing output. This creates a hidden side effect not justified by the manifest and can lead to unauthorized or unexpected financial transactions whenever a user invokes the skill.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
The code includes a payment-processing capability unrelated to the core summarization function and triggers it automatically unless --test is supplied. In the context of a note summarizer, this is disproportionately dangerous because users would not reasonably expect the tool to initiate financial charges as part of basic text processing.

Known Vulnerable Dependency: axios==1.13.6 — 16 advisory(ies): CVE-2026-44494 (axios Vulnerable to Full Man-in-the-Middle via Prototype Pollution Gadget in `co); CVE-2026-44495 (axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollut); CVE-2025-62718 (Axios has a NO_PROXY Hostname Normalization Bypass that Leads to SSRF) +13 more

High
Category
Supply Chain
Confidence
97% confidence
Finding
The lockfile pins axios 1.13.6, which is flagged with multiple advisories including SSRF-related proxy bypass and prototype-pollution-based attack chains. For a meeting summary skill, network access is common, so dependency flaws in the HTTP client can directly affect requests involving user-supplied URLs, redirects, proxy handling, credentials, or untrusted response processing.

Known Vulnerable Dependency: form-data==4.0.5 — 1 advisory(ies): CVE-2026-12143 (form-data: CRLF injection in form-data via unescaped multipart field names and f)

High
Category
Supply Chain
Confidence
94% confidence
Finding
form-data 4.0.5 is flagged for CRLF injection via unescaped multipart field names and filenames. If the skill ever constructs multipart requests using user-influenced field metadata, an attacker may be able to manipulate request structure or smuggle unintended headers/content to downstream services.

Known Vulnerable Dependency: axios==1.13.6 — 16 advisory(ies): CVE-2026-44494 (axios Vulnerable to Full Man-in-the-Middle via Prototype Pollution Gadget in `co); CVE-2026-44495 (axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollut); CVE-2025-62718 (Axios has a NO_PROXY Hostname Normalization Bypass that Leads to SSRF) +13 more

High
Category
Supply Chain
Confidence
97% confidence
Finding
The package allows resolution to axios 1.13.6 under the declared semver range, and the finding indicates that version carries multiple known advisories, including SSRF-related and request-handling issues. In a skill context, HTTP client vulnerabilities are especially important because agent skills often fetch remote content or interact with external APIs, which can expose credentials, enable request manipulation, or bypass network restrictions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
91% confidence
Finding
The installation command uses `npx clawhub@latest`, which fetches and executes the latest published package version at runtime rather than a pinned, reviewed version. This creates a supply-chain risk: if the upstream package is compromised or a breaking/malicious release is published, users following the README could execute attacker-controlled code during installation.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The README advertises automatic payment handling and an embedded merchant key without a prominent warning or explicit user consent flow. In the context of a CLI skill, this is dangerous because users may trigger billable actions unexpectedly, and the presence of an embedded payment credential suggests hidden financial side effects and poor key-handling practices that could lead to unauthorized charges or abuse.

Lp3

Medium
Category
MCP Least Privilege
Confidence
82% confidence
Finding
The skill advertises environment-variable-based capabilities but does not declare any explicit tool scope or permissions boundaries. In practice, this weakens transparency and reviewability, making it easier for a skill to access sensitive runtime secrets without clear user awareness or policy enforcement.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
This skill processes meeting notes, which often contain confidential business discussions, personal data, or strategic plans, yet the description provides no privacy warning about sending that content to AI services or a local gateway. Users may unknowingly transmit sensitive notes outside their expected trust boundary, creating confidentiality and compliance risks.

External Transmission

Medium
Category
Data Exfiltration
Content
const { spawn } = require('child_process');

const CONFIG = {
  skillpay_api: 'https://api.skillpay.me/v1',
  merchant_key: process.env.SKILLPAY_MERCHANT_KEY || 'sk_91fff75ae2a7a71f8eceadcbcd816e24d57e58d9d04ccca45f0b3856af130aea',
  price_per_use: 0.003,
  currency: 'USDT'
Confidence
99% confidence
Finding
The code contains a hardcoded fallback merchant key for an external payment API, exposing a live-looking credential directly in the skill source. Hardcoded secrets can be extracted by anyone with code access and abused to impersonate the merchant, issue unauthorized charges, or disrupt billing operations.

Context-Inappropriate Capability

Medium
Confidence
82% confidence
Finding
Spawning an external CLI agent gives the skill a broader execution boundary than a simple local summarizer and sends user-controlled content into another executable. While this may be intended to access an AI model, it increases attack surface and trust assumptions because behavior depends on an external binary outside the file’s visible logic.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
Meeting notes are passed to an external agent process without clear notice or consent, and those notes may contain sensitive internal business information, personal data, or confidential action items. In a meeting-summary skill, users are especially likely to provide sensitive content, making undisclosed external disclosure more risky.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The payment flow transmits billing-related data and a merchant credential to an external service with only a pricing message as user-facing context. Users are not clearly informed that invoking the skill triggers networked billing activity, which creates both privacy and financial transparency concerns.

Vague Triggers

Low
Confidence
83% confidence
Finding
This file is a manifest-type JSON file, so vague-trigger review applies. The package and bin name "meeting-summary-generator" describe a broad, common productivity task, but the manifest provides no activation constraints, explicit invocation phrases, or negative examples to clarify when the skill should or should not run.

Known Vulnerable Dependency: follow-redirects==1.15.11 — 1 advisory(ies): CVE-2026-40895 (follow-redirects leaks Custom Authentication Headers to Cross-Domain Redirect Ta)

Low
Category
Supply Chain
Confidence
92% confidence
Finding
follow-redirects 1.15.11 is reported to leak custom authentication headers across cross-domain redirects. In a skill that may call external services to summarize or fetch content, this can expose API keys, bearer tokens, or internal credentials to attacker-controlled endpoints if redirects are followed automatically.

Unpinned Dependencies

Low
Category
Supply Chain
Content
"author": "Matt",
  "license": "MIT",
  "dependencies": {
    "axios": "^1.6.0"
  },
  "openclaw": {
    "skill": true,
Confidence
91% confidence
Finding
The dependency is specified with a caret range (^1.6.0), which permits automatic installation of newer 1.x releases. This reduces build reproducibility and can unexpectedly pull in a later vulnerable version of axios, increasing supply-chain risk for a skill that may be installed and executed in different environments.

Static analysis

Detected: suspicious.dangerous_exec, suspicious.env_credential_access

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
index.js:64

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
index.js:9