Back to skill

Security audit

xbird

Security checks for vulnerabilities and agentic risk

Overview

This skill is a coherent Twitter/X MCP integration, but it asks users to run mutable third-party code with live X session cookies and an optional wallet private key, which deserves Review before installation.

Install only if you are comfortable giving this MCP process control over a live X session and, for paid use, wallet signing capability. Prefer a dedicated low-value wallet, avoid storing secrets in shared plaintext configs, revoke the X session if exposed, pin and review the npm package before use, and require manual confirmation for posts, follows, profile changes, media uploads, and paid calls.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T08 · Insecure Dependencies

Error
Location
SKILL.md:12
Finding
Unpinned Third-Party Package Is Downloaded and Executed Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 12–14 **Vulnerability Type**: Unpinned and unverified third-party dependency execution **Risk Level**: High ### Vulnerable Code ```bash claude mcp add xbird -- npx @checkra1n/xbird ``` ### Technical Analysis The setup command instructs users to execute `@checkra1n/xbird` through `npx` without specifying a package version or integrity hash. Depending on the local npm cache and `npx` behavior, the command can retrieve and execute the package version currently published in the npm registry. Consequently, the code executed during installation is not immutable and may differ from the version originally reviewed. The project provides no lockfile, package checksum, vendored source, source-code verification procedure, or publisher-authenticity validation. The package scope also does not establish an official relationship with X. This is a supply-chain weakness rather than evidence that the current package is malicious. However, compromise of the npm publisher, package, registry resolution process, or a future release could place attacker-controlled code directly inside the MCP process. ### Attack Path 1. An attacker compromises the npm publisher account, publishing pipeline, or package distribution channel for `@checkra1n/xbird`. 2. The attacker publishes a modified release containing malicious installation or runtime code. 3. A user follows the documented setup command without a pinned version. 4. `npx` downloads and executes the attacker-controlled release under the user's local account. 5. The package inherits access available to the MCP process, potentially including X session credentials, wallet credentials, files readable by the user, and network access. 6. The malicious package can export credentials, perform unauthorized X operations, initiate unauthorized payment activity, or execute additional commands with the user's privileges. ### Impact Assessment Successful exploitation prov ...[truncated 725 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the dependency to a specific, audited version rather than allowing `npx` to resolve the latest release: ```bash claude mcp add xbird -- npx @checkra1n/xbird@<audited-version> ``` 2. Verify the pinned package using an integrity hash and a committed lockfile. 3. Publish or link to reproducible source code and document how the distributed npm artifact corresponds to that source. 4. Verify the package publisher and signing provenance before installation. 5. Disable lifecycle scripts where practical and review all installation and runtime scripts before execution. 6. Run the MCP server in a sandbox or isolated operating-system account with restricted filesystem and network access. 7. Establish a controlled update process in which new versions are reviewed before deployment rather than automatically consumed. 8. Restrict the MCP process to only the credentials and filesystem resources necessary for its operation. ]]>

other

Error
Location
SKILL.md:16
Finding
Reusable X Session Credentials and a Wallet Private Key Are Exposed to a Third-Party MCP Process<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 16–20 **Vulnerability Type**: Sensitive credential exposure and excessive credential scope **Risk Level**: High ### Vulnerable Code ```text Required environment variables (set in `~/.claude/settings.json` or shell): - `XBIRD_AUTH_TOKEN` — from x.com cookies (DevTools → Application → Cookies → `auth_token`) - `XBIRD_CT0` — from x.com cookies (DevTools → Application → Cookies → `ct0`) - `XBIRD_PRIVATE_KEY` — wallet private key for x402 payments (optional, needed for paid tier) ``` ### Technical Analysis The instructions require users to extract reusable authentication material directly from X browser cookies and make it available to the third-party MCP server. They also permit a raw cryptocurrency wallet private key to be supplied to the same process. An X `auth_token` represents an authenticated browser session, while `ct0` is associated with CSRF protection. Supplying both values allows the MCP implementation to perform authenticated operations through that session. The documented tool set includes reading private account-related data, posting content, modifying engagement, following or unfollowing accounts, uploading media, and changing profile information. The wallet private key has even broader consequences because possession of an unrestricted private key generally enables signing operations without an independent authorization boundary. Environment variables reduce accidental inclusion in source code but do not protect secrets from the process receiving them. Storing the values in `~/.claude/settings.json` may additionally expose them as plaintext at rest, depending on the host configuration and permissions. No actual credential exfiltration is present in `SKILL.md`. The security issue is that high-impact, reusable secrets are entrusted to an unpinned third-party process without documented isolation, scope restrictions, transaction limits, or secure secret storage. ### Attack Pa ...[truncated 1735 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace browser-cookie authentication with an official, revocable OAuth flow using narrowly scoped access tokens. 2. Request only the permissions required for the selected operation; separate read-only and write-capable credentials. 3. Do not provide a general-purpose wallet private key to the MCP process. 4. Use a delegated payment signer, session key, smart-contract wallet, or payment service with explicit per-call and cumulative spending limits. 5. If a wallet remains necessary, use a dedicated low-value wallet with no unrelated assets or token approvals. 6. Store credentials in an operating-system credential manager or secrets service rather than plaintext configuration files. 7. Prevent secrets from appearing in logs, command-line arguments, crash reports, tool output, or diagnostic telemetry. 8. Run the MCP server in an isolated process or container with a minimal environment, restricted filesystem access, and controlled outbound network access. 9. Document credential revocation procedures, including invalidating the X session and migrating assets immediately if the wallet key may have been exposed. 10. Require explicit user confirmation for public posts, profile modifications, follow operations, and payment-signing actions. 11. Apply strict filesystem permissions to any configuration containing secrets and avoid sharing those files through backups or synchronization services without encryption. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • 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)

Agent Config Directory Access

High
Category
Agent Snooping
Content
claude mcp add xbird -- npx @checkra1n/xbird
```

Required environment variables (set in `~/.claude/settings.json` or shell):
- `XBIRD_AUTH_TOKEN` — from x.com cookies (DevTools → Application → Cookies → `auth_token`)
- `XBIRD_CT0` — from x.com cookies (DevTools → Application → Cookies → `ct0`)
- `XBIRD_PRIVATE_KEY` — wallet private key for x402 payments (optional, needed for paid tier)
Confidence
97% confidence
Finding
The skill explicitly directs users to place authentication cookies and a wallet private key in the agent configuration directory, a high-value target commonly accessible to local tools, plugins, or compromised code running in the same environment. Given this skill also recommends executing a remotely fetched MCP server, compromise of that environment could expose Twitter session credentials and payment keys, enabling account takeover and financial abuse.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The trigger list is very broad and includes generic social-media terms, increasing the chance the skill is invoked in contexts the user did not intend. Because this skill includes account-reading and account-modifying actions, accidental invocation could lead to unintended access, posting, or social actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill instructs users to run an unpinned package directly via npx, which fetches and executes whatever version is current at invocation time. If the package is compromised, updated maliciously, or subject to dependency hijacking, the agent environment could execute attacker-controlled code with access to local credentials and configuration.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The documentation tells users to provide live session cookies and optionally a wallet private key, but does not include strong warnings about the sensitivity of those secrets or the consequences of account-modifying actions. In this context, missing safety guidance materially increases the risk of credential mishandling, unauthorized account use, and financial loss through metered calls.

Static analysis

No suspicious patterns detected.