Back to skill

Security audit

Social Post

Security checks for vulnerabilities and agentic risk

Overview

This skill can post publicly and spend from a Farcaster wallet, but it delegates secrets to mutable external code and has weak confirmation and secret-handling boundaries.

Install only after reviewing the scripts and limiting blast radius: use dedicated low-privilege social accounts, keep minimal funds in the Farcaster wallet, avoid sensitive images or token-bearing URLs, and do not run real posting commands from automation unless you have explicitly approved the content and target platforms. The package should be revised to avoid anti-spam bypass positioning, parse secrets safely instead of sourcing .env, fail closed without confirmation in non-interactive runs, and remove or integrity-pin external executable dependencies before broad use.

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

T08 · Insecure Dependencies

Error
Location
lib/farcaster.sh:4
Finding
Mutable External Programs Receive Social-Media Credentials and Wallet Private Keys<![CDATA[ ## Vulnerability Details **File Location**: `lib/twitter.sh:4, 31-35, 73`; `lib/farcaster.sh:4, 23-51, 110-146` **Vulnerability Type**: Untrusted external dependency execution with inherited secrets **Risk Level**: Critical ### Vulnerable Code ```bash # lib/twitter.sh TWITTER_POST_SCRIPT="/home/phan_harry/.openclaw/workspace/scripts/twitter-post.sh" twitter_post_text() { local text="$1" local reply_to_id="$2" get_twitter_credentials if [ ! -f "$TWITTER_POST_SCRIPT" ]; then echo "Error: Twitter post script not found at $TWITTER_POST_SCRIPT" >&2 return 1 fi # ... "$TWITTER_POST_SCRIPT" "$text" } ``` ```bash # lib/farcaster.sh FARCASTER_REPO="/home/phan_harry/.openclaw/workspace/skills/farcaster-agent/repo" cd "$FARCASTER_REPO" && \ PRIVATE_KEY="$private_key" \ SIGNER_PRIVATE_KEY="$signer_key" \ FID="$fid" \ npm run cast "$text" 2>&1 | grep -E "(Cast hash|URL|Error)" | tail -2 ``` The image and reply paths similarly execute Node.js code from the external Farcaster repository while exposing the private keys through environment variables: ```bash cd "$FARCASTER_REPO" && PRIVATE_KEY="$private_key" \ SIGNER_PRIVATE_KEY="$signer_key" \ FID="$fid" \ IMAGE_URL="$image_url" \ PARENT_HASH="${parent_hash:-}" node -e " const { Wallet, JsonRpcProvider } = require('ethers'); const { makeCastAdd, NobleEd25519Signer, FarcasterNetwork, Message } = require('@farcaster/hub-nodejs'); const { submitMessage } = require('./src/x402'); // ... " "$text" ``` ### Technical Analysis The Skill relies on executable components outside the audited project: - `/home/phan_harry/.openclaw/workspace/scripts/twitter-post.sh` - `/home/phan_harry/.openclaw/workspace/skills/farcaster-agent/repo` These external components are not bundled, version-pinned, integrity-checked, or otherwise authenticated by this project. The X posting script inherits the exported OAuth credentials from the calling shell. The Farcaster dependency explicitly receives the custody wa ...[truncated 1373 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Bundle all security-sensitive posting logic within the reviewed Skill package. 2. Pin Node.js and Python dependencies with lockfiles and verified hashes. 3. Verify the ownership, permissions, canonical path, and cryptographic digest of any unavoidable external executable before invocation. 4. Do not pass custody private keys to mutable external programs. Isolate signing in a narrowly scoped, reviewed component. 5. Use a dedicated wallet with minimal funds and permissions for Farcaster payments. 6. Avoid exporting credentials globally. Pass only the exact required values to a trusted child process. 7. Replace the external Twitter posting script with the bundled OAuth implementation, or include and audit that script. 8. Document every external executable dependency in the Skill metadata and fail closed if its integrity cannot be established. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
lib/twitter.sh:7
Finding
Credential Files Are Executed as Shell Code<![CDATA[ ## Vulnerability Details **File Location**: `lib/twitter.sh:7-8`; `scripts/reply.sh:270-274` **Vulnerability Type**: Arbitrary command execution through unsafe environment-file loading **Risk Level**: High ### Vulnerable Code ```bash # lib/twitter.sh get_twitter_credentials() { source /home/phan_harry/.openclaw/.env if [ "$TWITTER_ACCOUNT" = "oxdasx" ]; then export X_CONSUMER_KEY="$OXDASX_API_KEY" export X_CONSUMER_SECRET="$OXDASX_API_KEY_SECRET" export X_ACCESS_TOKEN="$OXDASX_ACCESS_TOKEN" export X_ACCESS_TOKEN_SECRET="$OXDASX_ACCESS_TOKEN_SECRET" export X_USERNAME="0xdasx" else export X_CONSUMER_KEY="${X_CONSUMER_KEY}" export X_CONSUMER_SECRET="${X_CONSUMER_SECRET}" export X_ACCESS_TOKEN="${X_ACCESS_TOKEN}" export X_ACCESS_TOKEN_SECRET="${X_ACCESS_TOKEN_SECRET}" export X_USERNAME="${X_USERNAME:-mr_crtee}" fi } ``` ```bash # scripts/reply.sh # Post reply with media using inline Python script source /home/phan_harry/.openclaw/.env result=$(python3 - "$TEXT" "$TWITTER_ID" "$media_id" <<'EOF' # ... EOF ) ``` ### Technical Analysis Bash `source` does not treat the target as a passive configuration file. It parses and executes the complete file in the current shell. Consequently, command substitutions, function definitions, redirections, shell commands, and variable-expansion side effects placed in `.env` execute before posting. For example, a line such as the following would execute rather than merely define configuration: ```bash X_CONSUMER_KEY="$(malicious-command)" ``` The documented recommendation to set mode `600` reduces exposure but does not make shell evaluation safe. The file could still be modified by the user, a compromised process running under the same account, an unsafe setup tool, or one of the external dependencies used by the Skill. ### Attack Path 1. An attacker or compromised same-user process obtains write access to `~/.openclaw/.env`. 2. The attacker appends shell syntax or c ...[truncated 762 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Never use `source`, `.`, or `eval` to load credential data. 2. Parse only explicitly allowed keys such as: - `X_CONSUMER_KEY` - `X_CONSUMER_SECRET` - `X_ACCESS_TOKEN` - `X_ACCESS_TOKEN_SECRET` 3. Reject malformed lines, unknown variable names, command substitutions, shell metacharacters, duplicate keys, and multiline values. 4. Prefer a structured format such as JSON read with `jq`, or obtain credentials from the host's secret-management interface. 5. Require the credential file to be owned by the current user and reject group- or world-writable permissions. 6. Keep credentials scoped to the smallest possible subprocess instead of exporting them throughout the shell. 7. Remove the duplicate `source` operation in `scripts/reply.sh` and call one safe credential-loading routine. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/post.sh:235
Finding
Non-Interactive Runs Bypass the Documented Confirmation Safeguard<![CDATA[ ## Vulnerability Details **File Location**: `scripts/post.sh:235-249`; `scripts/reply.sh:229-243` **Vulnerability Type**: Fail-open authorization and transaction confirmation **Risk Level**: High ### Vulnerable Code ```bash # scripts/post.sh # Confirmation prompt (skip if running non-interactively or with --yes flag) if [ "$AUTO_CONFIRM" = false ] && [ -t 0 ]; then echo -n "Proceed with posting? (y/n): " read -r CONFIRM if [[ ! "$CONFIRM" =~ ^[Yy]$ ]]; then echo "Cancelled." exit 0 fi echo "" elif [ "$AUTO_CONFIRM" = true ]; then echo "Auto-confirmed (--yes flag). Proceeding..." echo "" fi # Execution continues here even when stdin is not a TTY and --yes was omitted. export TWITTER_ACCOUNT echo "=== Posting ===" ``` The same condition appears in `scripts/reply.sh`: ```bash if [ "$AUTO_CONFIRM" = false ] && [ -t 0 ]; then echo -n "Proceed with reply? (y/n): " read -r CONFIRM if [[ ! "$CONFIRM" =~ ^[Yy]$ ]]; then echo "Cancelled." exit 0 fi echo "" elif [ "$AUTO_CONFIRM" = true ]; then echo "Auto-confirmed (--yes flag). Proceeding..." echo "" fi export TWITTER_ACCOUNT echo "=== Posting Replies ===" ``` ### Technical Analysis The confirmation logic has three relevant states: 1. Interactive input and no `--yes`: prompt for approval. 2. `--yes`: proceed explicitly. 3. Non-interactive input and no `--yes`: neither branch executes, but posting still proceeds. The third state is a fail-open condition. Agent executions, CI jobs, redirected input, cron-like runners, and API-launched shell processes commonly lack a TTY. Therefore, the context where explicit confirmation is most important is the context where it is silently omitted. This contradicts the documentation that presents `--yes` as the mechanism for automated workflows and confirmation as the normal default. ### Attack Path 1. An Agent or automation system invokes `scripts/post.sh` or `scripts/reply.sh` without `--dry-run` and without `--yes`. 2. ...[truncated 794 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Fail closed when no TTY is present and `--yes` was not explicitly supplied: ```bash if [ "$AUTO_CONFIRM" = true ]; then : elif [ ! -t 0 ]; then echo "Error: Non-interactive posting requires --yes or --dry-run" >&2 exit 1 else read -r -p "Proceed with posting? (y/n): " CONFIRM [[ "$CONFIRM" =~ ^[Yy]$ ]] || exit 0 fi ``` 2. Apply the same correction to both posting and reply scripts. 3. Require explicit platform flags for real paid operations instead of defaulting a post to both platforms. 4. Display the expected number of thread posts and estimated Farcaster cost before approval. 5. Consider requiring a second explicit option for wallet-funded actions. 6. Add automated tests covering interactive, non-interactive, `--yes`, and `--dry-run` execution states. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
lib/links.sh:5
Finding
URL Shortening Discloses Complete URLs over Plaintext HTTP<![CDATA[ ## Vulnerability Details **File Location**: `lib/links.sh:5-16` **Vulnerability Type**: Cleartext transmission of potentially sensitive URL data **Risk Level**: Medium ### Vulnerable Code ```bash # Shorten a single URL using TinyURL (no API key needed) shorten_url() { local url="$1" # Use TinyURL API (free, no auth) local short_url=$(curl -s "http://tinyurl.com/api-create.php?url=$(echo "$url" | jq -sRr @uri)") if [[ "$short_url" =~ ^https?://tinyurl.com/ ]]; then echo "$short_url" return 0 else # Fallback: return original URL echo "$url" return 1 fi } ``` ### Technical Analysis The function places the complete original URL into a query parameter and transmits it to TinyURL using unencrypted HTTP. URLs can contain sensitive information, including: - Password-reset or invitation tokens. - Signed object-storage parameters. - Session identifiers. - Private document paths. - Internal hostnames and query values. Although URL shortening is optional, selecting `--shorten-links` forwards every URL matched in the text. Plaintext HTTP provides neither confidentiality nor server authentication. A network-positioned attacker can observe the original URL or alter the service response. The response check permits either HTTP or HTTPS TinyURL links and does not enforce secure redirects or certificate-protected transport. ### Attack Path 1. A user prepares a post containing a sensitive or token-bearing URL. 2. The user enables `--shorten-links`. 3. The Skill sends the complete URL to TinyURL over plaintext HTTP. 4. A network observer captures the original URL, or an active attacker modifies the returned short link. 5. The altered short link is inserted into the public post or reply. ### Impact Assessment Potential consequences include: - Disclosure of secret query strings and access tokens. - Exposure of internal URLs or private resource identifiers. - Account or document access if captured URLs act as bearer credentials. - ...[truncated 275 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the endpoint with an authenticated HTTPS endpoint. 2. Configure curl to fail securely: ```bash curl --fail --show-error --silent \ --location \ --proto '=https' \ --tlsv1.2 \ "https://tinyurl.com/api-create.php?url=${encoded_url}" ``` 3. Accept only an HTTPS response from the expected host. 4. Add connection and total timeouts to avoid hanging Agent runs. 5. Warn users that URLs are sent to a third-party shortening provider. 6. Detect and reject URLs containing common secret-bearing parameters unless the user explicitly overrides the warning. 7. Prefer leaving links unchanged when secure shortening is unavailable. ]]>

other

Warning
Location
lib/farcaster.sh:55
Finding
Farcaster Images Are Automatically Sent to an Undisclosed Fallback Hosting Provider<![CDATA[ ## Vulnerability Details **File Location**: `lib/farcaster.sh:55-80` **Vulnerability Type**: Undisclosed third-party file disclosure **Risk Level**: Medium ### Vulnerable Code ```bash # Upload image to imgur (anonymous) upload_to_imgur() { local image_path="$1" if [ ! -f "$image_path" ]; then echo "Error: Image not found at $image_path" >&2 return 1 fi # Try catbox.moe (no API key needed, reliable) local response=$(curl -s -F "reqtype=fileupload" \ -F "fileToUpload=@$image_path" \ https://catbox.moe/user/api.php) if [[ "$response" =~ ^https://files.catbox.moe/ ]]; then echo "$response" return 0 fi # Fallback: try uguu.se response=$(curl -s -F "files[]=@$image_path" \ https://uguu.se/upload.php | jq -r '.files[0].url' 2>/dev/null) if [[ "$response" =~ ^https:// ]]; then echo "$response" return 0 fi echo "Error: Failed to upload image" >&2 return 1 } ``` ### Technical Analysis For Farcaster image posts, the Skill uploads the selected local file to Catbox. If that request does not produce an expected URL, it automatically sends the same file to Uguu. The README identifies Catbox as the Farcaster image host, while the Skill documentation elsewhere claims that images are uploaded to Imgur. Neither description clearly discloses the automatic Uguu fallback before the file is transferred. The function name and comment also refer to Imgur even though the code does not use Imgur. The implementation performs no file-type allowlisting, size validation, metadata removal, or provider-specific confirmation. Images may contain geolocation, device, creator, timestamp, or other embedded metadata. ### Attack Path 1. A user selects an image for a Farcaster post or reply. 2. The Skill attempts to upload it to Catbox. 3. Catbox fails, returns an unexpected response, or becomes temporarily unavailable. 4. Without additional confirmation, the Skill uploads the image to Uguu. 5. The resulting public UR ...[truncated 717 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Accurately document every image-hosting provider used by the code. 2. Remove the automatic fallback or require explicit user approval before transferring the file to a different provider. 3. Rename `upload_to_imgur` and correct misleading comments to reflect actual behavior. 4. Allow users to select or disable third-party image hosting. 5. Enforce an allowlist of supported image MIME types and reasonable file-size limits. 6. Strip EXIF and other metadata before upload, with the sanitized result shown in the preview. 7. Use secure curl options including `--fail`, timeouts, HTTPS-only protocol restrictions, and certificate verification. 8. Provide clear retention and deletion information for each hosting service. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (89)

Natural-Language Policy Violations

High
Confidence
98% confidence
Finding
The changelog explicitly documents a feature whose purpose is to evade Twitter/X duplicate-content enforcement by automatically altering text and guaranteeing visible variation. This is dangerous because it operationalizes anti-spam bypass behavior across multiple accounts, enabling scaled policy evasion and abusive posting workflows rather than legitimate platform-compliant automation.

Credential Access

High
Category
Privilege Escalation
Content
2. Set permissions to "Read and Write"
3. Generate Consumer Key/Secret and Access Token/Secret

**Step 3: Add to .env file**
Location: `/home/phan_harry/.openclaw/.env`
```bash
X_CONSUMER_KEY=your_consumer_key
Confidence
82% confidence
Finding
The README directs users to place long-lived X API credentials in a plaintext `.env` file under a predictable path. While common, this pattern increases exposure risk from local compromise, accidental inclusion in backups, logs, or other tools that read dotenv files.

Credential Access

High
Category
Privilege Escalation
Content
**Step 2: Verify Credentials File**

Location: `/home/phan_harry/.openclaw/farcaster-credentials.json`
```json
{
  "fid": "2684290",
Confidence
98% confidence
Finding
The README includes a credentials JSON example containing highly sensitive fields such as `custodyPrivateKey` and `signerPrivateKey`, normalizing storage and handling of raw private keys in a plaintext local file. In the context of a posting skill tied to a funded Farcaster custody wallet, compromise of this file can directly lead to account takeover and financial loss.

Credential Access

High
Category
Privilege Escalation
Content
**1. Check credentials exist:**
```bash
# Check X/Twitter credentials
grep "^X_CONSUMER_KEY" ~/.openclaw/.env

# Check Farcaster credentials
ls -la ~/.openclaw/farcaster-credentials.json
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
1. Check `.env` file exists: `ls -la ~/.openclaw/.env`
2. Verify credentials are set:
   ```bash
   grep "^X_" ~/.openclaw/.env
   ```
3. Ensure no extra spaces or quotes around values
4. Check file permissions: `chmod 600 ~/.openclaw/.env`
Confidence
77% confidence
Finding
The troubleshooting guidance encourages interacting directly with a plaintext `.env` file containing posting credentials. In an agent ecosystem, repeated patterns of direct secret-file inspection increase the chance those values are surfaced in terminal history, screenshots, logs, or copied into prompts.

Credential Access

High
Category
Privilege Escalation
Content
1. Check file exists: `ls -la ~/.openclaw/farcaster-credentials.json`
2. Verify JSON is valid:
   ```bash
   jq . ~/.openclaw/farcaster-credentials.json
   ```
3. Ensure all required fields present:
   - `fid`, `custodyAddress`, `custodyPrivateKey`
Confidence
95% confidence
Finding
The troubleshooting section explicitly instructs users to verify that sensitive fields including `custodyPrivateKey` and `signerPrivateKey` are present, reinforcing reliance on plaintext secret storage. Given this skill posts on behalf of users and spends from a funded Farcaster wallet, exposure of these values could enable unauthorized posting and wallet misuse.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The documentation frames the skill as social posting, but the analyzed behavior reportedly includes blockchain wallet balance checks and reading custody credentials from disk. That broadens the trust boundary from social posting into financial/account infrastructure, which materially increases risk if users are not clearly informed.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The documentation frames the skill as social posting, but the analyzed behavior reportedly includes blockchain wallet balance checks and reading custody credentials from disk. That broadens the trust boundary from social posting into financial/account infrastructure, which materially increases risk if users are not clearly informed.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The documentation frames the skill as social posting, but the analyzed behavior reportedly includes blockchain wallet balance checks and reading custody credentials from disk. That broadens the trust boundary from social posting into financial/account infrastructure, which materially increases risk if users are not clearly informed.

Credential Access

High
Category
Privilege Escalation
Content
4. **Generate Keys**
   - Consumer Key & Secret: In "Keys and tokens" tab
   - Access Token & Secret: Click "Generate" under "Authentication Tokens"
   - Save all 4 credentials securely

4. **Add to .env file**
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
4. **Generate Keys**
   - Consumer Key & Secret: In "Keys and tokens" tab
   - Access Token & Secret: Click "Generate" under "Authentication Tokens"
   - Save all 4 credentials securely

4. **Add to .env file**
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- Access Token & Secret: Click "Generate" under "Authentication Tokens"
   - Save all 4 credentials securely

4. **Add to .env file**
   ```bash
   echo "X_CONSUMER_KEY=xxx" >> ~/.openclaw/.env
   echo "X_CONSUMER_SECRET=xxx" >> ~/.openclaw/.env
Confidence
90% confidence
Finding
The documentation tells users to append X API secrets into a plaintext ~/.openclaw/.env file. Plaintext, long-lived tokens in generic environment files are commonly overexposed to backups, shell history, logs, and other local processes.

Credential Access

High
Category
Privilege Escalation
Content
4. **Add to .env file**
   ```bash
   echo "X_CONSUMER_KEY=xxx" >> ~/.openclaw/.env
   echo "X_CONSUMER_SECRET=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
Confidence
90% confidence
Finding
This line continues the practice of storing sensitive API secrets in plaintext environment files. If those files are read by other tools or accidentally committed or shared, the linked social account can be abused for unauthorized posting.

Credential Access

High
Category
Privilege Escalation
Content
4. **Add to .env file**
   ```bash
   echo "X_CONSUMER_KEY=xxx" >> ~/.openclaw/.env
   echo "X_CONSUMER_SECRET=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
   ```
Confidence
90% confidence
Finding
Persisting access tokens in plaintext on disk creates an account-compromise risk if the host or workspace is exposed. Because this skill performs outbound posting, stolen tokens have immediate abuse value.

Credential Access

High
Category
Privilege Escalation
Content
```bash
   echo "X_CONSUMER_KEY=xxx" >> ~/.openclaw/.env
   echo "X_CONSUMER_SECRET=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
   ```
Confidence
90% confidence
Finding
Storing access token secrets in a generic .env file exposes high-impact credentials beyond the minimum necessary trust boundary. Attackers obtaining the file can impersonate the user on X through the API.

Credential Access

High
Category
Privilege Escalation
Content
echo "X_CONSUMER_KEY=xxx" >> ~/.openclaw/.env
   echo "X_CONSUMER_SECRET=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
   echo "X_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
   ```

**Test your credentials:**
Confidence
88% confidence
Finding
The setup pattern as a whole promotes repeated plaintext secret handling in the shell and filesystem. This raises the chance of secret leakage through shell history, copy/paste mistakes, and weak local protections.

Credential Access

High
Category
Privilege Escalation
Content
```bash
# Add credentials with custom prefix (e.g., MYACCOUNT_)
echo "MYACCOUNT_API_KEY=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_API_KEY_SECRET=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
Confidence
89% confidence
Finding
Multi-account support multiplies the number of stored secrets and therefore the attack surface. A compromise of one shared env file could expose multiple social identities at once.

Credential Access

High
Category
Privilege Escalation
Content
```bash
# Add credentials with custom prefix (e.g., MYACCOUNT_)
echo "MYACCOUNT_API_KEY=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_API_KEY_SECRET=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
```
Confidence
89% confidence
Finding
Adding another API secret to the same plaintext env store further expands exposure. The more credentials consolidated in one place, the more severe a single local disclosure becomes.

Credential Access

High
Category
Privilege Escalation
Content
# Add credentials with custom prefix (e.g., MYACCOUNT_)
echo "MYACCOUNT_API_KEY=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_API_KEY_SECRET=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
```
Confidence
89% confidence
Finding
Persisting additional access tokens for secondary accounts in plaintext increases impersonation risk across multiple accounts. This is especially sensitive for an automation skill capable of posting at scale.

Credential Access

High
Category
Privilege Escalation
Content
echo "MYACCOUNT_API_KEY=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_API_KEY_SECRET=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN=xxx" >> ~/.openclaw/.env
echo "MYACCOUNT_ACCESS_TOKEN_SECRET=xxx" >> ~/.openclaw/.env
```

**Usage:**
Confidence
89% confidence
Finding
Storing multiple account token secrets in one env file creates concentrated credential risk. If exposed, an attacker can potentially control several accounts through the same skill.

Credential Access

High
Category
Privilege Escalation
Content
### Farcaster Setup

**Required credentials** (stored in `/home/phan_harry/.openclaw/farcaster-credentials.json`):
```json
{
  "fid": "your_farcaster_id",
Confidence
95% confidence
Finding
The skill requires access to a local Farcaster credentials file containing private keys, significantly expanding the blast radius of compromise. Any misuse, path confusion, logging bug, or exfiltration could expose signer and custody keys, leading to account takeover and potential fund loss.

Credential Access

High
Category
Privilege Escalation
Content
4. **Verify setup**
   ```bash
   # Check credentials exist
   ls -la ~/.openclaw/farcaster-credentials.json
   
   # Check wallet balance
   scripts/check-balance.sh
Confidence
87% confidence
Finding
The documentation encourages direct inspection of the credential file path, reinforcing that the skill depends on sensitive local files. This increases the chance of accidental disclosure through terminals, logs, screenshots, or copied troubleshooting output.

Credential Access

High
Category
Privilege Escalation
Content
## Requirements

- Twitter credentials in `.env` (X_CONSUMER_KEY, X_CONSUMER_SECRET, X_ACCESS_TOKEN, X_ACCESS_TOKEN_SECRET)
- Farcaster credentials in `/home/phan_harry/.openclaw/farcaster-credentials.json`
- **USDC on Base chain** (custody wallet): 0.001 USDC per Farcaster cast
- For images: `curl`, `jq`
Confidence
94% confidence
Finding
Requiring a fixed local credential file for Farcaster and env-stored X secrets means the skill has broad access to high-value credentials. In a networked posting skill, this creates a direct route from local secret access to external actions under those identities.

Credential Access

High
Category
Privilege Escalation
Content
scripts/check-balance.sh

# Manual check
jq -r '.custodyAddress' ~/.openclaw/farcaster-credentials.json
# View on basescan.org
```
Confidence
89% confidence
Finding
The manual check examples read fields from the Farcaster credential file directly, normalizing shell access to sensitive secret-bearing storage. Even if only a public address is extracted, this pattern increases the risk of accidental exposure or scripting mistakes against the same file.

Credential Access

High
Category
Privilege Escalation
Content
# Farcaster posting library

FARCASTER_REPO="/home/phan_harry/.openclaw/workspace/skills/farcaster-agent/repo"
FARCASTER_CREDS="/home/phan_harry/.openclaw/farcaster-credentials.json"

# Post text-only to Farcaster
farcaster_post_text() {
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Static analysis

No suspicious patterns detected.