Back to skill

Security audit

Memepickup Wingman

Security checks for vulnerabilities and agentic risk

Overview

The skill is coherent for a dating-assistant service, but it deserves Review because it sends private dating content to a remote API and can automate real dating-app account actions.

Install only if you are comfortable sharing dating messages, screenshots, profile images, and preferences with MemePickup/OpenAI-backed processing. Avoid auto-swipe unless you accept account-ban and unintended-action risk, and prefer a secrets manager or OpenClaw config over pasting API keys into chat or shell startup files.

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

T08 · Insecure Dependencies

Warning
Location
README.md:33
Finding
Execution of an Unpinned Mutable Package Through npx## Vulnerability Details **File Location**: `README.md:33`; `references/OPENCLAW-SETUP.md:7-8, 53-54, 62-63` **Vulnerability Type**: Supply-chain risk caused by unpinned executable dependencies **Risk Level**: Medium ### Vulnerable Code `README.md:33`: ```bash npx clawhub@latest install memepickup/memepickup-wingman ``` `references/OPENCLAW-SETUP.md:7-8`: ```bash npx clawhub@latest install memepickup/memepickup-wingman ``` `references/OPENCLAW-SETUP.md:53-54`: ```bash # Update to latest version npx clawhub@latest update memepickup-wingman ``` `references/OPENCLAW-SETUP.md:62-63`: ```bash # Uninstall npx clawhub@latest uninstall memepickup-wingman ``` ### Technical Analysis The documentation directs users to execute `clawhub@latest` through `npx`. When the package is not already available locally, `npx` may download and execute its package entry point and lifecycle behavior from the package registry. The `latest` tag is mutable and does not identify the specific version that was reviewed during this audit. Consequently, the effective code executed by these commands can change after publication of the Skill. The audited repository provides no version lock, integrity hash, signature verification, or other mechanism that binds installation to a known package artifact. This is not evidence that the current `clawhub` package is malicious. It is an unsafe dependency-execution pattern that creates a supply-chain attack opportunity if the package, registry account, release process, or distribution channel is compromised. ### Attack Path 1. An attacker compromises the `clawhub` publisher account, package release process, or registry distribution path. 2. The attacker publishes a malicious release and assigns it to the mutable `latest` tag. 3. A user follows the documented installation, update, or uninstall command. 4. `npx` resolves `clawhub@latest`, downloads the attacker-controlled package, and ...[truncated 896 chars]
Remediation
## Remediation Suggestions 1. Replace `@latest` with an exact, reviewed version, for example `clawhub@X.Y.Z`. 2. Publish the expected package name, publisher identity, version, and integrity digest in the installation documentation. 3. Use package-locking or an equivalent integrity-verification mechanism where the installation workflow permits it. 4. Prefer a signed installer or verified release artifact over dynamically executing a mutable registry tag. 5. Document a controlled update process that reviews release notes and verifies signatures or hashes before execution. 6. Apply the same version pinning to install, update, and uninstall commands. 7. Run package-management commands from a minimally privileged account and avoid exposing unrelated secrets in the command environment.

T09 · Insecure Skill Coding Practices

Warning
Location
references/MANUS-SETUP.md:31
Finding
API Key Exposure Through Chat, Plaintext Shell Profiles, and Terminal Output## Vulnerability Details **File Location**: `references/MANUS-SETUP.md:31-36, 48-52`; `references/OPENCLAW-SETUP.md:40-48, 99-101` **Vulnerability Type**: Insecure credential handling and plaintext secret persistence **Risk Level**: Medium ### Vulnerable Code `references/MANUS-SETUP.md:31-36`: ```markdown ### Via Chat Tell Manus your API key directly: > "My MemePickup API key is mp_your_key_here" Manus will export it in the sandbox environment. ``` `references/MANUS-SETUP.md:48-52`: ```markdown To persist across sandbox sessions, add the export to `~/.bashrc` in the sandbox: ```bash echo 'export MEMEPICKUP_API_KEY="mp_your_api_key_here"' >> ~/.bashrc ``` ``` `references/OPENCLAW-SETUP.md:40-48`: ```markdown ### API Key via Environment Variable Alternatively, export the key directly: ```bash export MEMEPICKUP_API_KEY="mp_your_api_key_here" ``` Add this to your shell profile (`~/.zshrc`, `~/.bashrc`) to persist across sessions. ``` `references/OPENCLAW-SETUP.md:99-101`: ```markdown **"MEMEPICKUP_API_KEY not set" error:** - Check `~/.openclaw/openclaw.json` for the `apiKey` field - Or verify `echo $MEMEPICKUP_API_KEY` returns your key ``` ### Technical Analysis The setup guide recommends transmitting the API key in a chat message. Depending on the platform's retention and logging behavior, that key may remain in conversation history, synchronization records, backups, moderation systems, or diagnostic logs. The documentation also recommends persisting the key as plaintext in `.bashrc` or `.zshrc`. Shell startup files are not dedicated secret stores and may be included in backups, copied during troubleshooting, read by other processes operating as the same user, or exposed through accidental repository commits and support bundles. The `echo $MEMEPICKUP_API_KEY` troubleshooting command prints the complete credential to the terminal. This can expose it through terminal scrollba ...[truncated 2128 chars]
Remediation
## Remediation Suggestions 1. Do not ask users to send API keys through chat. 2. Use the secret-management facility provided by OpenClaw, Manus, or the execution platform. 3. If file-based storage is unavoidable, use a dedicated secrets file outside the project directory with restrictive permissions such as mode `0600`. 4. Avoid storing secrets directly in `.bashrc`, `.zshrc`, command history, or source-controlled configuration. 5. Replace `echo $MEMEPICKUP_API_KEY` with a non-disclosing check, such as testing whether the variable is set or displaying only a short masked suffix. 6. Ensure diagnostic logs redact `MEMEPICKUP_API_KEY` and the `x-api-key` request header. 7. Document how users can revoke and rotate keys after suspected exposure. 8. Recommend short-lived or scoped credentials if the MemePickup API supports them. 9. Warn users who previously followed the chat-based setup instructions to delete retained messages where possible and rotate the exposed key.
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
Findings (33)

Tainted flow: 'req' from os.environ.get (line 57, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Content
req = urllib.request.Request(endpoint, data=data, headers=headers, method=method)

    try:
        with urllib.request.urlopen(req) as resp:
            sys.stdout.buffer.write(resp.read())
            sys.stdout.buffer.flush()
    except urllib.error.HTTPError as e:
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Context Leakage

High
Category
Data Exfiltration
Content
|----------|-----------|---------|
| `rork-memepickup-app-3.vercel.app/api/v1/lines/generate` | intensity value | Generate pickup line |
| `rork-memepickup-app-3.vercel.app/api/v1/replies/generate` | conversation messages | Generate reply suggestions |
| `rork-memepickup-app-3.vercel.app/api/v1/replies/from-screenshot` | base64 screenshot image | Extract conversation + generate replies |
| `rork-memepickup-app-3.vercel.app/api/v1/profiles/analyze` | base64 profile screenshot + platform | Score profile against preferences |
| `rork-memepickup-app-3.vercel.app/api/v1/preferences` | preference settings | Store/retrieve swipe preferences |
| `rork-memepickup-app-3.vercel.app/api/v1/credits` | (none) | Check remaining credits |
Confidence
98% confidence
Finding
The skill explicitly sends highly sensitive third-party content—conversation messages, screenshots, profile images, and preferences—to remote endpoints. Even if the document claims data is discarded, this is still context leakage because private user and non-user data leaves the local environment and could be retained, logged, breached, or processed beyond user expectations.

Missing User Warnings

High
Confidence
98% confidence
Finding
The example explicitly sends the other person's private message content to an external API via `scripts/api.sh replies` without any visible privacy notice, consent flow, minimization, or warning to the user. In a dating/DM assistant context, messages can contain sensitive personal, sexual, relational, or identifying information, so silent transmission to a third party creates a meaningful privacy and compliance risk.

Missing User Warnings

High
Confidence
97% confidence
Finding
The guide tells users to provide an API key directly in chat, which exposes credentials to chat retention systems, logs, transcripts, screenshots, and potentially broader agent access than necessary. This is a straightforward secret-handling weakness that can lead to credential leakage and unauthorized API use.

YARA rule 'backdoor_persistence': Backdoor persistence with malicious payloads (shell commands, SSH key injection, hidden root users) [malware]

High
Category
YARA Match
Content
up

### Via Chat

Tell Manus your API key directly:
> "My MemePickup API key is mp_your_key_here"

Manus will export it in the sandbox environment.

### Via Sandbox Terminal

Open the Manus sandbox terminal and run:

```bash
export MEMEPICKUP_API_KEY="mp_your_api_key_here"
```

### Persistent Configuration

To persist across sandbox sessions, add the export to `~/.bashrc` in the sandbox:

```bash
echo 'export MEMEPICKUP_API_KEY="mp_your_api_key_here"' >> ~/.bashrc
```

## Script Execution

Manus runs scripts in an Ubuntu sandbox VM. Both `scripts/api.sh` (Bash) and `scripts/api.py` (Python) are available:

```bash
# Bash version
echo '{"intensity": 0.5}' | scripts/api.sh lines

# Python version (no pip install needed — stdlib only)
echo '{"intensity": 0.5}' | python3 scripts/api.py lines
```

Use whichever Manus prefers for the task. Both produce identical output.

## Browser Automation (Auto-Swipe)

Manus performs auto-swipe using browser automation on web versions of dating apps:
Confidence
75% confidence
Finding
YARA rule matched a known malware signature (reverse shell, backdoor, ransomware, C2 framework, or info stealer).

Missing User Warnings

High
Confidence
98% confidence
Finding
The documentation states that Manus will screenshot dating-app profiles and send them to an API, but gives no warning that this may transmit sensitive personal data such as photos, names, bios, and inferred relationship preferences. Because the skill operates on real dating profiles, the privacy risk is elevated and users may unknowingly disclose third-party personal data to an external service.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The trigger phrase `Give me a pickup line` is broad and closely resembles ordinary user speech, so it may activate the skill in contexts where the user is simply chatting rather than intentionally invoking this specific integration. In a skill that can also connect to external APIs and potentially influence downstream behavior, ambiguous activation increases the risk of unintended use and data sharing.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The example `Help me reply to this [screenshot]` is a highly generic request that could match many ordinary assistant tasks, making accidental activation plausible. Because screenshots may contain sensitive personal conversations, ambiguous routing to this skill could send private content to the MemePickup API unexpectedly.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The example `Analyze this Hinge profile [screenshot]` is also broad and overlaps with common assistant requests, but here the danger is higher because profile screenshots contain third-party personal data. Ambiguous activation may cause private images and inferred dating preferences to be sent to external services without sufficiently explicit user intent.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The skill is presented primarily as a dating advice and analysis tool, but the README also documents automated swiping, liking, following, and similar actions on third-party platforms. That expands the capability from advisory assistance into real account actions, increasing the chance of unintended automation, account misuse, platform policy violations, and user harm if invoked without clear, narrow consent boundaries.

Context-Inappropriate Capability

Medium
Confidence
92% confidence
Finding
Browser automation and native screen interaction are powerful capabilities that exceed what is necessary for generating pickup lines, replies, or coaching. In this context, those controls could let the skill manipulate dating-app sessions and perform account actions on the user's behalf, making accidental or overly broad execution materially more dangerous than a purely advisory skill.

Lp3

Medium
Category
MCP Least Privilege
Confidence
94% confidence
Finding
The skill declares broad capabilities in practice (environment access, network calls, shell execution) but does not explicitly scope or constrain allowed tools. That increases the chance the agent can invoke more functionality than users or reviewers expect, especially given it transmits screenshots, conversations, and preferences to external services.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The instruction 'she has 24 hours' imposes a specific gender assumption in the skill's natural-language behavior. This is a policy-relevant language choice because the skill does not offer neutral wording or let the user opt into gender-specific framing.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The phrase 'She's asking the user out' hard-codes a gendered assumption into the coaching logic. Because the skill does not document that it is limited to a specific audience or provide a language-choice mechanism, this is a natural-language policy violation.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The example indicates the system proactively monitors conversation state and can send unsolicited coaching, but the skill content does not prominently warn users about that behavior before use. In a personal dating-assistant context, failure to disclose autonomous monitoring and intervention can undermine user consent and create privacy and trust issues, especially when the system infers relationship signals from message patterns.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The nudge system is described as triggering on broad heuristics like silence duration, reply length, and inferred interest, which can cause unsolicited interventions without a clear user request or narrowly scoped consent boundary. In a dating-coaching context, that increases the risk of intrusive monitoring, misfires, and manipulative or unwanted advice being surfaced at sensitive moments.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The example explicitly shows a user sending a dating profile screenshot and the skill forwarding it to an external API for analysis, but it provides no warning that personal data and images of another person are being transmitted off-platform. In a dating-assistant context, screenshots can contain sensitive personal information, photos, handles, and platform-specific metadata, so normalizing this flow without disclosure increases privacy and consent risk.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The example explicitly states that dating preferences are saved to a cloud service and synced across devices, but the user-facing flow does not provide any warning, consent prompt, or privacy notice before transmitting sensitive personal preference data. In the context of a dating assistant, these preferences can reveal intimate lifestyle, attraction, and dealbreaker information, so silent cloud storage increases privacy and compliance risk if users are unaware of where their data is going.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The example invocation "Sarah just texted me, help me reply" uses the broad phrase "help me reply," which is common everyday language and does not clearly constrain when this skill should activate versus ordinary assistant use. The file provides no negative examples or explicit trigger boundaries to narrow activation scope.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The workflow describes forwarding dating-app messages to Manus and then calling an external API, but it does not warn users that message contents are transmitted through Manus and an API pipeline. This lack of disclosure creates a privacy and consent risk because users may share third-party messages and personal data without understanding where that data goes or how it is processed.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The example says Manus 'recognized it as a dating conversation (activation trigger)' without defining boundaries, consent checks, or exclusions. In a messaging-integrated agent, broad trigger logic can cause unintended processing of private conversations and sensitive relationship content, especially when users forward messages that may contain personal data.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The document describes automating third-party dating platform actions such as reviewing profiles and executing swipe/like/comment decisions based on API output. This exceeds passive dating assistance and turns the skill into an automation tool that can act on user accounts, increasing abuse, account takeover-adjacent risk, and Terms-of-Service violations; the dating context makes it more dangerous because it operates on real user identities and communications on external services.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The workflow sends screenshots of dating profiles to an external API for analysis, but this reference does not present a clear user-facing privacy notice or consent flow for transmitting third-party profile data. Dating profile screenshots can contain sensitive personal information, images, usernames, and inferred preferences, so silent export to an external service creates meaningful privacy, compliance, and data-handling risk.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The setup guide documents browser automation that screenshots profiles, analyzes them, and performs auto-swipe actions, which materially expands the skill from advisory text generation into direct interaction with third-party dating platforms. That hidden capability increases risk because users and reviewers may not expect automated account actions or profile data processing from the manifest description alone.

Static analysis

No suspicious patterns detected.