Back to skill

Security audit

New Manager Week Voice Pack

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly a disclosed Beatra voice-generation workflow, but it also grants broad account/tool access and silently self-updates, so users should review it carefully before installing.

Install only if you are comfortable giving this Beatra package a shared bearer credential, broad media/account scopes, access to billable remote tools, first-use registration, and default-on automatic updates. Prefer disabling automatic updates with the documented command and using an account where Beatra spending and remote tool access are acceptable.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/authorize.py:34
Finding
Over-Privileged Authorization and Unrestricted MCP Tool Invocation<![CDATA[ ## Vulnerability Details **File Location**: `scripts/authorize.py:34-36`; `scripts/mcp_client.py:1448-1468`; `scripts/mcp_client.py:1491-1496` **Vulnerability Type**: Excessive OAuth scope and missing tool allowlist **Risk Level**: Medium ### Vulnerable Code From `scripts/authorize.py:34-36`: ```python SCOPE = ( "mcp:tools artifacts:write images:generate videos:generate music:generate " "speech:generate voices:read voices:write wallet:spend tasks:read artifacts:read tasks:cancel" ) ``` From `scripts/mcp_client.py:1448-1468`: ```python def _run_command(command: str, tool_name: str | None = None) -> dict[str, Any]: session = _session_with_registration( state_dir=Path.home() / ".beatra", post_json=_default_post_json, ) if command == "tools": return session.request(2, "tools/list", {}) try: arguments = json.load(os.sys.stdin) except json.JSONDecodeError as exc: raise RuntimeError("Tool arguments on stdin must be one JSON object") from exc if not isinstance(arguments, dict): raise RuntimeError("Tool arguments on stdin must be one JSON object") assert tool_name is not None return session.request( 2, "tools/call", {"name": tool_name, "arguments": arguments}, ) ``` From `scripts/mcp_client.py:1491-1496`: ```python call = subparsers.add_parser("call", help="Call one tool with a JSON object on stdin") call.add_argument("tool_name") ``` ### Technical Analysis The Skill is declared as a speech-generation workflow that optionally uploads a voice sample and creates a cloned voice. Its legitimate requirements include speech generation, voice access, artifact upload, task monitoring, model discovery, and limited wallet operations. The authorization request nevertheless includes unrelated privileges for image, video, and music generation. These permissions exceed the minimum privileges necessary for the declared functionality. The bundled clie ...[truncated 2080 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the broad authorization scope with the minimum permissions required for this Skill. Remove at least: ```text images:generate videos:generate music:generate ``` 2. Review whether `tasks:cancel`, broad `artifacts:read`, and general `wallet:spend` are all necessary. Prefer operation-specific or package-specific scopes where supported. 3. Add a strict local allowlist before forwarding `tools/call`. The allowlist should include only documented operations, for example: ```python ALLOWED_TOOLS = { "beatra.assets.upload", "beatra.installations.register", "beatra.models.list", "beatra.speech.synthesize", "beatra.tasks.get", "beatra.tasks.list", "beatra.tasks.cancel", "beatra.voices.clone", "beatra.voices.list", "beatra.wallet.get", "beatra.wallet.ledger", } if tool_name not in ALLOWED_TOOLS: raise RuntimeError("This tool is not permitted by the New Manager Week Voice Pack") ``` 4. Separate read-only and billable capabilities. Require an explicit authorization or confirmation boundary before enabling wallet spending, cloning, speech generation, or cancellation. 5. Avoid sharing one full-scope credential across unrelated Skills. Use per-Skill or capability-constrained tokens so compromise of one package cannot reach unrelated media operations. 6. Add automated tests asserting that unrelated tools and scopes are rejected locally. ]]>

T03 · Remote Payload Retrieval and Execution

Warning
Location
scripts/mcp_client.py:969
Finding
Silent Self-Update Replaces Executable Skill Files Without Publisher-Signature Verification<![CDATA[ ## Vulnerability Details **File Location**: `scripts/mcp_client.py:969-1019`; supporting update logic at `scripts/mcp_client.py:31-32`, `801-929`, and `1542-1544` **Vulnerability Type**: Mutable remote code retrieval and automatic installation **Risk Level**: Medium ### Vulnerable Code From `scripts/mcp_client.py:31-32`: ```python PACKAGE_DISCOVERY_URL = "https://beatra.ai/skills/new-manager-voice/channels/clawhub/install.json" PACKAGE_CDN_BASE_TEMPLATE = "https://cdn.beatra.ai/agent-packages/new-manager-voice/channels/clawhub/v{version}" ``` From `scripts/mcp_client.py:969-1019`: ```python def maybe_auto_update( *, state_dir: Path | None = None, install_root: Path | None = None, get_bytes: GetBytes = _default_get_bytes, now: float | None = None, ) -> bool: """Best-effort silent update. Never block the requested MCP command.""" resolved_state = state_dir or Path.home() / ".beatra" try: resolved_root = (install_root or _current_install_root()).resolve() update_home = _update_home(resolved_state, resolved_root) observed_at = time.time() if now is None else now nonce = _lock_update(update_home, now=observed_at) if nonce is None: return False try: recover_update(state_dir=resolved_state, install_root=resolved_root) state = _read_update_state(update_home) if state.get("auto_update", True) is False: return False last_checked = state.get("last_checked_at") if ( isinstance(last_checked, (int, float)) and observed_at - float(last_checked) < UPDATE_CHECK_MAX_AGE_SECONDS ): return False state["last_checked_at"] = observed_at _write_private_json(update_home / "state.json", state) checked = check_update(get_bytes=get_bytes) if not checked["update_available"]: return False ...[truncated 4517 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Disable automatic installation by default: ```python return {"schema_version": 1, "auto_update": False} ``` 2. Make ordinary invocations perform, at most, a non-mutating update check. Display an update notification and require explicit user approval before downloading or replacing files. 3. Sign release metadata or manifests with a publisher key whose public verification key is embedded in the audited client. Verify the signature before trusting versions, file lists, hashes, or archive locations. 4. Consider a mature signed-update framework such as TUF, Sigstore with identity and transparency-log verification, or an equivalent system that supports: - Root-of-trust separation - Key rotation and revocation - Expiring metadata - Rollback protection - Threshold signing - Transparency and auditability 5. Ensure the discovery service and payload CDN do not share the only trust root. Hashes delivered by the same compromised release source do not independently authenticate a payload. 6. Require explicit consent whenever an update changes executable files such as: ```text scripts/mcp_client.py scripts/authorize.py scripts/uninstall.py ``` 7. Record the installed release signature, signer identity, and manifest digest in local state so later audits can verify provenance. 8. Retain the existing redirect, archive, ownership, size, transaction, and rollback protections; these are useful defense-in-depth measures but should supplement rather than replace publisher authentication. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (26)

Lp3

Medium
Category
MCP Least Privilege
Confidence
94% confidence
Finding
The skill advertises a narrow voice-pack function but instructs use of capabilities equivalent to file access, shell execution, network calls, and package modification without declaring permissions. This creates an opaque trust boundary: a user may approve a benign-seeming content task while the skill can read local files, upload assets, persist credentials, and execute helper commands.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The documented behavior substantially exceeds the declared purpose by adding OAuth device auth, persistent credential storage, arbitrary MCP-mediated tool access, local file upload, telemetry/registration, uninstall/revocation logic, and automatic updates. That mismatch is dangerous because users and reviewers may authorize the skill for simple audio generation while it introduces broader account, data, and system-level side effects.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
Silent automatic self-updates give the package ongoing code-execution and self-modification capability unrelated to producing voice clips. Even with claims of verification, this expands the attack surface to the update channel and permits behavior changes after initial review or user consent, making compromise or policy drift far more damaging.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The manifest advertises a benign checklist-to-voice skill, but its MCP configuration and changelog reference balance, ledger, and top-up behavior unrelated to the stated purpose. That mismatch is a strong indicator of hidden or overbroad remote capabilities, which can mislead users into authorizing access to financial or account data they would not reasonably expect from a voice-pack tool.

Context-Inappropriate Capability

High
Confidence
95% confidence
Finding
Exposing account- or ledger-oriented remote capabilities to a skill whose declared function is converting checklist items into voice clips violates least privilege and creates an unjustified path to sensitive financial/account operations. Even if some calls are read-only, they still expand the data-access surface and can enable privacy violations, reconnaissance, or abuse if the remote service is compromised or misused.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The OAuth scope string requests far more capability than a skill that converts checklist text into manager onboarding voice clips should need. In particular, unrelated generation scopes and broad artifact/task access violate least privilege, so a compromised or buggy skill could use the granted token for actions outside the user’s expected workflow.

Context-Inappropriate Capability

Critical
Confidence
95% confidence
Finding
voices:read, voices:write, and tasks:cancel go beyond a straightforward checklist-to-clips workflow unless the skill truly manages saved voice inventory or cancels user jobs. Unnecessary modification and cancellation permissions can disrupt user assets or operations if the credential is misused.

Context-Inappropriate Capability

High
Confidence
95% confidence
Finding
voices:read, voices:write, and tasks:cancel go beyond a straightforward checklist-to-clips workflow unless the skill truly manages saved voice inventory or cancels user jobs. Unnecessary modification and cancellation permissions can disrupt user assets or operations if the credential is misused.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
voices:read, voices:write, and tasks:cancel go beyond a straightforward checklist-to-clips workflow unless the skill truly manages saved voice inventory or cancels user jobs. Unnecessary modification and cancellation permissions can disrupt user assets or operations if the credential is misused.

Description-Behavior Mismatch

High
Confidence
95% confidence
Finding
The client implements broad capabilities unrelated to the stated purpose of generating manager onboarding voice clips, including package self-update, telemetry, upload flows, and generic MCP tool invocation. In a skill context, this creates unnecessary attack surface and enables the package to act as a general remote control client rather than a narrowly scoped media workflow tool.

Context-Inappropriate Capability

High
Confidence
96% confidence
Finding
The package contains self-modifying update logic that downloads remote manifests and archives and overwrites installed files. Even with integrity checks, bundling a self-updater inside a narrowly scoped skill is dangerous because compromise of the update channel, signing pipeline, or distribution authority would let the skill replace itself with new code outside the user's expected task flow.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The client records local installation inventory and transmits installation registration telemetry that is not necessary to turn checklists into voice clips. In a skill ecosystem, undisclosed collection of local inventory and device/platform identifiers increases privacy risk and creates hidden data flows that users would not reasonably expect from the advertised function.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
The CLI exposes generic remote tool listing and arbitrary tool invocation by name, allowing this package to operate as a general-purpose MCP client rather than a single-purpose voice-pack tool. That capability expansion is dangerous because any available backend tool reachable by the credential can potentially be exercised through this skill, greatly increasing the blast radius of misuse or compromise.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
This skill is described as producing onboarding voice clips, but the included script performs uninstall-time management of shared device credentials and remote token revocation. Even if framed as cleanup logic, it grants the skill access to shared authentication state unrelated to its stated purpose, creating unnecessary authority and a path to disrupt other installed skills or the user's Beatra access.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
The code reads access tokens from credentials.json and sends them to a remote revocation endpoint, which is highly sensitive behavior for a checklist-to-voice skill. In this context, credential handling is unjustified and dangerous because compromise, misuse, or unexpected execution could revoke the shared device authorization and break other skills or platform access.

Context-Inappropriate Capability

High
Confidence
96% confidence
Finding
The script enumerates and deletes files in ~/.beatra, including shared state such as credentials, host, inventory, and registrations. For a voice-pack skill, deleting shared application state is context-inappropriate and dangerous because it can disconnect the user, corrupt platform state, and affect unrelated installed skills.

Intent-Code Divergence

Medium
Confidence
87% confidence
Finding
The docstring minimizes the script as a package uninstaller, while the implementation also revokes shared device authorization and removes shared local state. This mismatch is dangerous because it obscures sensitive behavior from reviewers and users, reducing the chance that high-risk credential and deletion operations receive appropriate scrutiny.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The skill states that newer versions install automatically without separate confirmation, but this system-modifying behavior is buried deep in the document rather than disclosed up front. Poor disclosure undermines informed consent and increases the chance that users invoke a content-generation skill without realizing it can alter local package files and future runtime behavior.

Missing User Warnings

Medium
Confidence
86% confidence
Finding
The document explicitly states that the client silently checks for and automatically installs updates by default without separate confirmation. Even though it describes integrity checks and rollback protections, silent self-updating that modifies installed files can surprise users, bypass change-control expectations, and increase risk if the trusted update infrastructure is ever compromised or misconfigured.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The document states that the bundled client automatically performs an installation registration call and transmits package and environment metadata on first use, but it does not clearly warn the user or require explicit consent at the point of data transmission. Even if the data is described as non-secret and non-billable, silent outbound telemetry can violate user expectations, privacy requirements, or enterprise policy, especially in regulated or locked-down environments.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The code performs silent automatic self-updates that can replace installed package files without a user-facing prompt during normal command execution. In the context of a voice-pack skill, hidden code modification undermines user trust and makes malicious or accidental functionality drift harder to detect.

Missing User Warnings

Low
Confidence
88% confidence
Finding
Installation telemetry and local skill inventory are recorded opportunistically without clear user-facing disclosure in this client flow. While not directly enabling code execution, this creates covert metadata collection inconsistent with the narrow advertised purpose of producing onboarding audio clips.

Credential Access

High
Category
Privilege Escalation
Content
},
  "mcp": {
    "authentication": "device-bearer",
    "credential_file": "~/.beatra/credentials.json",
    "name": "beatra",
    "transport": "streamable-http",
    "url": "https://mcp.beatra.ai/mcp"
Confidence
91% confidence
Finding
Referencing a local credential file for device-bearer authentication gives this skill a path to leverage stored bearer credentials when connecting to the remote MCP service. In the context of a skill that already appears overprivileged and mismatched to its stated purpose, access to reusable account credentials materially increases the risk of unauthorized data access or remote action under the user's identity.

Credential Access

High
Category
Privilege Escalation
Content
#: these and then removes the directory only if it is empty — the script
#: never recursively deletes a directory it does not fully understand.
_STATE_FILES = (
    "credentials.json",
    "installation.json",
    "host.json",
    "skills.json",
Confidence
93% confidence
Finding
Referencing credentials.json as part of removable shared state indicates this skill can affect stored authentication material. In the context of a voice-clip generation skill, touching credential storage is unnecessary and expands the blast radius from normal media processing into account and platform availability impacts.

Credential Access

High
Category
Privilege Escalation
Content
def _device_token(state_dir: Path) -> str | None:
    path = state_dir / "credentials.json"
    try:
        value = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, ValueError):
Confidence
97% confidence
Finding
The _device_token function reads an access token from shared credentials.json, giving the skill direct access to bearer credentials. In this skill context that is especially risky, because bearer-token access enables sensitive account actions unrelated to voice-pack generation, including revocation and potential abuse if the token is exposed or repurposed.

Static analysis

No suspicious patterns detected.