Back to skill

Security audit

jinn-node

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly aligned with running a Jinn worker, but it asks for broad credentials, searches private files, installs mutable external code, and sets up persistent profiling jobs.

Review carefully before installing. Use a dedicated low-value wallet, narrowly scoped or disposable GitHub and API credentials, avoid letting the agent search your home directory for .env or OAuth files, do not print wallet mnemonics in agent-visible terminals, and only enable cron profiling or WhatsApp briefs after explicit consent and with a clear removal plan.

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
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
Findings (7)

T03 · Remote Payload Retrieval and Execution

Error
Location
references/setup.md:38
Finding
Remote Poetry Installer Is Downloaded and Executed Without Verification<![CDATA[ ## Vulnerability Details **File Location**: `references/setup.md:38-42` and `SKILL.md:94-97` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: High ### Vulnerable Code ```bash ### Poetry (required) ```bash poetry --version ``` If not installed: ```bash curl -sSL https://install.python-poetry.org | python3 - ``` ``` The same command is also recommended by `SKILL.md`: ```markdown | `poetry not found` | `curl -sSL https://install.python-poetry.org \| python3 -` | ``` ### Technical Analysis The command pipes a response retrieved from an external URL directly into the Python interpreter. There is no version pinning, checksum verification, signature validation, or opportunity to inspect the downloaded content before execution. Although Poetry is a relevant dependency, immediate execution of mutable remote content is not the minimum privilege or safest installation method required for this Skill. The effective payload can change after the Skill has been reviewed. A compromise of the upstream distribution system, hosting account, DNS path, or certificate infrastructure could consequently turn this installation step into arbitrary code execution. The downloaded program executes with the privileges of the user running the agent and can access the same files, credentials, environment variables, wallet configuration, and network resources available to that user. ### Attack Path 1. An attacker compromises the remote installer, its hosting infrastructure, or another component of its delivery chain. 2. The user or agent follows the documented troubleshooting or setup instructions. 3. `curl` downloads the attacker-controlled response. 4. The shell passes the response directly to `python3`. 5. The malicious payload executes without integrity verification. 6. The payload reads credentials or wallet data, modifies local files, establishes persistence, or downloads additional components. ### Impact Assessment Successful exploitati ...[truncated 341 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove all pipe-to-interpreter installation commands. - Prefer installation through a trusted operating-system package manager or another controlled package source. - If the official installer must be used: 1. Download a specific, immutable installer release to a local file. 2. Verify its cryptographic signature or a checksum obtained through an independent trusted channel. 3. Inspect the file before execution. 4. Execute it as an unprivileged user. - Pin the expected Poetry version and document the verified digest. - Apply the same correction to both `references/setup.md` and `SKILL.md`. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/setup.md:64
Finding
Home-Directory Environment Search Can Expose Unrelated Project Secrets<![CDATA[ ## Vulnerability Details **File Location**: `references/setup.md:64-88` **Vulnerability Type**: Excessive filesystem access and sensitive-data disclosure **Risk Level**: High ### Vulnerable Code ```bash ### Search for existing configuration Look for existing `.env` files that may contain relevant values: ```bash find ~ -maxdepth 3 -name ".env" -type f 2>/dev/null | head -5 ``` Search found files for relevant env vars: - `RPC_URL` or `BASE_RPC_URL` - `OPERATE_PASSWORD` - `GITHUB_TOKEN` - `GIT_AUTHOR_NAME` - `GIT_AUTHOR_EMAIL` - `GEMINI_API_KEY` ### Confirm with user **If values found**, present them: > I found these existing configuration values: > - `RPC_URL`: https://... > - `GITHUB_TOKEN`: ghp_... > - `GIT_AUTHOR_NAME`: ... > > Would you like me to use these values? (yes/no) > If any are outdated, please provide the correct values. ``` ### Technical Analysis The instructions tell the agent to enumerate `.env` files throughout the user's home directory instead of limiting access to the current project. Environment files commonly contain production credentials, cloud keys, database passwords, signing secrets, and tokens belonging to unrelated applications. The subsequent instruction to present discovered values can place secrets directly into the conversation. This conflicts with the Skill's later credential-handling guidance and can cause credentials to persist in session logs or be exposed to systems processing conversation content. The search is not necessary for configuring the project. The minimum required access is the project's own `.env` file plus credentials explicitly supplied or selected by the user. ### Attack Path 1. The user has unrelated `.env` files within three directory levels of the home directory. 2. The agent follows the setup guide and enumerates those files. 3. The agent searches them for wallet passwords, GitHub tokens, Gemini keys, and RPC values. 4. Full values are presented in the conversation or copied into the ...[truncated 647 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Restrict configuration discovery to the current project's explicitly identified `.env` file. - Do not recursively search the user's home directory for secrets. - Never print complete tokens, passwords, API keys, or credential-bearing URLs in conversation output. - Report only whether a value exists, using masking such as `ghp_…4f2a` if identification is necessary. - Obtain explicit consent before importing each credential from another location. - Prefer asking the user to set environment variables outside the conversation. - Avoid copying credentials between projects unless their intended scope has been verified. - Add clear guidance that conversation and command output may be logged. ]]>

other

Error
Location
references/launchpad.md:190
Finding
Nightly Processing Creates a Persistent Behavioral Profile from Private Session Logs<![CDATA[ ## Vulnerability Details **File Location**: `references/launchpad.md:190-217` **Vulnerability Type**: Privacy-invasive session surveillance and behavioral profiling **Risk Level**: High ### Vulnerable Code ```markdown ## Preference profile The agent can build a persistent preference profile at `~/.openclaw/jinn-profile.json` to improve recommendations over time. **Structure:** ```json { "version": 1, "lastUpdated": "", "interests": { "categories": {}, "topics": [], "keywords": [] }, "expertise": { "areas": [], "evidenceSessions": 0 }, "ventureActivity": { "liked": [], "commentedOn": [], "created": [], "preferredCategories": [] }, "interactionStyle": { "commentTone": "technical", "engagementLevel": "moderate" }, "sessionStats": { "totalScanned": 0, "lastScanDate": "" } } ``` **Profile building (nightly):** 1. Scan session logs from `~/.openclaw/agents/main/sessions/*.jsonl` (last 24h) 2. Analyze for: topics discussed, technical domains, frustrations, venture-relevant intents 3. Update category affinity scores (0.0-1.0), topics, keywords, expertise 4. Cross-reference with current ventures to generate pending action recommendations 5. Write pending actions to `~/.openclaw/jinn-launchpad-pending.json` ``` ### Technical Analysis The Skill instructs the agent to read private conversation logs and infer interests, expertise, behavioral preferences, and frustrations. These inferences are then persisted in a profile and used to shape future recommendations. Browsing ventures or submitting a user-approved Launchpad action does not require unrestricted access to prior conversations. The behavior therefore exceeds the minimum data access necessary for the declared Launchpad functionality. The document states that profile data must remain local and must not be inserted into public content. That boundary reduces direct network disclosure risk, but it does not address the collectio ...[truncated 1201 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Make session profiling a separate, explicit, informed opt-in feature. - Do not enable profiling as part of ordinary Launchpad participation. - Limit analysis to conversations or excerpts affirmatively selected by the user. - Avoid collecting frustrations, unrelated topics, personal identifiers, or broad behavioral inferences. - Document precisely what is collected, why it is needed, how long it is retained, and which processes can access it. - Encrypt sensitive profile data at rest and apply restrictive filesystem permissions. - Provide commands to inspect, disable, and permanently delete the profile and pending-action files. - Use short retention periods and automatically remove stale observations. - Prefer ephemeral, session-local recommendation context over persistent cross-session profiling. ]]>

T06 · System Persistence

Error
Location
references/launchpad.md:226
Finding
Scheduled Jobs Establish Persistent Cross-Session Monitoring and Messaging<![CDATA[ ## Vulnerability Details **File Location**: `references/launchpad.md:226-243` **Vulnerability Type**: Persistent scheduled execution **Risk Level**: High ### Vulnerable Code ```bash ## Cron setup ```bash # Profile builder at 3am openclaw cron add \ --name "jinn-profile-builder" \ --cron "0 3 * * *" \ --message "Read the launchpad reference in jinn-node/skills/jinn-node/references/launchpad.md. Scan recent sessions and update the preference profile following the 'Profile building' instructions." \ --session isolated # Morning brief at 8am openclaw cron add \ --name "jinn-launchpad-brief" \ --cron "0 8 * * *" \ --message "Read the launchpad reference in jinn-node/skills/jinn-node/references/launchpad.md. Follow the 'Morning brief' instructions to present pending actions." \ --channel whatsapp \ --session isolated # Remove old wishlist crons if they exist openclaw cron remove jinn-wishlist-scanner 2>/dev/null openclaw cron remove jinn-wishlist-notify 2>/dev/null ``` ``` ### Technical Analysis The commands register recurring jobs that survive the initiating Skill run. One job reloads the Skill instructions and scans private sessions nightly; the other sends a daily brief over WhatsApp. The use of isolated sessions does not remove persistence—it creates recurring autonomous execution contexts. Persistent scheduling is not required to browse ventures, draft content, or execute a user-approved action. It expands the Skill from on-demand functionality into ongoing surveillance and outbound messaging. The instructions also remove older scheduled jobs, modifying persistent system state beyond simply adding the new feature. ### Attack Path 1. The agent or user runs the documented cron setup. 2. Persistent jobs are registered in OpenClaw. 3. At 03:00 each day, an isolated agent reloads the Launchpad reference and scans recent sessions. 4. Derived data and pending recommendations are written to persistent files. 5. At 08:00, another isol ...[truncated 590 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Default to on-demand profile generation and recommendation display. - Require separate, explicit confirmation immediately before creating each scheduled job. - Clearly disclose the schedule, accessed data, output channel, persistence duration, and removal procedure. - Provide documented removal commands for both jobs: - `openclaw cron remove jinn-profile-builder` - `openclaw cron remove jinn-launchpad-brief` - Add expiration dates or execution-count limits to scheduled tasks. - Do not remove unrelated or legacy jobs without separate user approval. - Pin recurring tasks to immutable, reviewed instructions rather than dynamically reloading mutable Skill content. - Provide a status command that lists all installed Jinn-related scheduled tasks. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
references/launchpad.md:17
Finding
Privileged Supabase Service-Role Key Is Sent to an Environment-Controlled URL<![CDATA[ ## Vulnerability Details **File Location**: `references/launchpad.md:17-38` **Additional Affected Locations**: `references/launchpad.md:69-81`, `95-112`, `118-130`, and `151-171` **Vulnerability Type**: Insecure credential handling and unrestricted network destination **Risk Level**: Critical ### Vulnerable Code ```bash ## Configuration The agent's wallet address and Supabase credentials must come from the environment — never hardcode them. Read from the jinn-node `.env` file or the operator's configured environment. ```bash # Wallet address — read from the operator's configured identity WALLET_ADDRESS="${WALLET_ADDRESS}" # Supabase — read from environment SUPABASE_URL="${SUPABASE_URL}" KEY="${SUPABASE_SERVICE_ROLE_KEY}" ``` If these are not set, prompt the user to configure them before proceeding. Never embed addresses or keys in skill output. ## Actions All actions require user approval before execution. Always confirm with the user before making writes. Never include the user's wallet address, keys, or other identifying information in conversation output unless the user explicitly asks. ### 1. Browse ventures ```bash curl -s "${SUPABASE_URL}/rest/v1/ventures?select=id,name,slug,description,status,creator_type,blueprint,created_at,likes(count),comments(count)&order=created_at.desc" \ -H "apikey: ${KEY}" \ -H "Authorization: Bearer ${KEY}" ``` ``` The same credential headers are used for venture creation, likes, comments, venture retrieval, and blueprint updates. ### Technical Analysis A Supabase service-role key is typically a highly privileged backend credential capable of bypassing Row Level Security. The Skill uses it directly from an agent-controlled environment and attaches it to requests targeting `${SUPABASE_URL}`. Because the destination is also read from the environment and no hostname allowlist, certificate pinning, redirect restriction, or URL validation is documented, configuration tampering can redirect the credential ...[truncated 1595 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not expose a Supabase service-role key to the Skill, shell, browser, or end-user agent. - Use a user-scoped authentication token or a least-privileged anonymous key protected by correctly configured Row Level Security. - Move privileged operations behind a first-party backend API that authenticates the user and authorizes each operation. - Allowlist the exact expected HTTPS hostname and reject all other destinations. - Reject redirects or ensure credentials are removed before following any redirect. - Validate that the URL has the expected scheme, hostname, and port before every request. - Assign separate narrowly scoped credentials for read and write operations. - Rotate any service-role key that may already have been used in this pattern. - Maintain user confirmation for writes, but do not treat confirmation as a substitute for destination and credential security. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:35
Finding
Unpinned External Repository and Package Installations Execute Unaudited Supply-Chain Code<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:35-46` **Additional Affected Locations**: `SKILL.md:99` and `references/setup.md:44-50,117-120,136-143` **Vulnerability Type**: Unpinned and unaudited external dependencies **Risk Level**: High ### Vulnerable Code ```bash ### 1. Clone the repo ```bash git clone https://github.com/Jinn-Network/jinn-node.git cd jinn-node ``` ### 2. Install dependencies ```bash corepack enable yarn install ``` ``` Additional installation and execution instructions include: ```bash git clone https://github.com/Jinn-Network/jinn-node.git cd jinn-node ``` ```bash yarn install ``` ```bash poetry install ``` ```bash npx @google/gemini-cli auth login ``` ### Technical Analysis The audited artifact contains only Markdown instructions and does not include the `jinn-node` implementation, package manifests, lockfiles, wallet code, or worker code. It directs the agent to clone the current state of an external repository without pinning an immutable commit and then install its dependencies. Package installation can execute lifecycle scripts, build hooks, Poetry plugins, or transitive dependency code. `npx` can also retrieve and execute package content. Because versions and repository revisions are not pinned within the audited artifact, the actual code executed may change after review. This is particularly dangerous because the documented worker environment contains Gemini credentials, a GitHub token, an RPC URL, a wallet encryption password, and funded cryptocurrency wallets. No evidence in the audited files establishes that the fetched implementation handles those assets safely. ### Attack Path 1. An attacker compromises the external GitHub repository, a package maintainer account, or a transitive dependency. 2. Malicious code is added to the repository, an installation lifecycle script, or a newly resolved package version. 3. The user follows the Skill and clones the latest repository state. 4. `yarn install`, ...[truncated 780 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin the external repository to a specific reviewed commit hash rather than cloning the mutable default branch. - Include or verify lockfiles for all Node.js and Python dependencies. - Pin exact dependency versions and verify package integrity hashes. - Audit installation scripts and transitive dependencies before supplying credentials or funding a wallet. - Disable package lifecycle scripts during installation where feasible, then selectively enable only reviewed build steps. - Pin `npx` packages to exact versions or install them from a controlled, verified source. - Run installation and the worker in a sandbox or dedicated operating-system account with restricted filesystem and network access. - Provide credentials only after installation is complete and the fetched implementation has been reviewed. - Use narrowly scoped GitHub and API tokens, and isolate wallet operations from general worker code. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
references/wallet.md:20
Finding
Wallet Key Export and Destructive Fund Operations Depend on Unaudited External Code<![CDATA[ ## Vulnerability Details **File Location**: `references/wallet.md:20-26` and `references/wallet.md:53-66` **Vulnerability Type**: Sensitive key exposure and high-impact wallet operations **Risk Level**: High ### Vulnerable Code ```bash ## Export Keys ```bash yarn wallet:export-keys ``` Displays the BIP-39 mnemonic for the master wallet. **Ask the user to confirm before running** — this shows sensitive key material. ``` ```bash ## Emergency Recovery Terminates the service and withdraws all funds. **Always preview first.** ```bash yarn wallet:recover --to <address> --dry-run yarn wallet:recover --to <address> ``` | Flag | Default | Description | |------|---------|-------------| | `--to` | (required) | Destination address for all funds | | `--dry-run` | off | Preview without executing | | `--skip-terminate` | off | Skip termination (if already unstaked) | **WARNING**: Recovery terminates the service. You must re-run `yarn setup` to re-stake. ``` ### Technical Analysis The Skill documents a command that prints the master wallet's BIP-39 mnemonic and commands that can terminate the service and transfer all funds. Confirmation and dry-run instructions reduce accidental execution, but they do not ensure that sensitive output remains outside agent logs or that the external command implementation transfers assets only to the intended destination. Because the implementation is fetched from an external, unpinned repository and is absent from this audit artifact, the behavior of these commands cannot be verified. Displaying a mnemonic in a terminal controlled by an agent can cause it to be captured in tool output, transcripts, shell logs, or monitoring systems. The emergency recovery command also accepts a destination address. If that address is replaced through instruction confusion, clipboard substitution, or compromised external code, all recoverable funds may be irreversibly transferred to an attacker. ### Attack Path 1. The user asks the agent ...[truncated 858 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Never display a BIP-39 mnemonic through an agent-controlled command channel. - Require key export to occur in a dedicated local interactive terminal that is excluded from agent transcripts and logging. - Add explicit warnings that mnemonics must never be pasted into conversation. - Require hardware-wallet or offline signing workflows where possible. - For withdrawals and recovery, require the user to verify the complete destination address through an independent trusted display. - Implement transaction simulation, chain-ID verification, checksummed address validation, and a second explicit confirmation. - Separate service termination from fund transfer so each action requires independent approval. - Audit and pin the external wallet implementation before allowing it to control funded wallets. - Use low-value test wallets until the complete implementation and dependency chain have been verified. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
Findings (29)

Credential Access

High
Category
Privilege Escalation
Content
Copy the template then ask the user for credentials and write them to `.env`. **Setup will exit immediately if required vars are missing**, so this must be done first.

```bash
cp .env.example .env
```

Ask the user for these values and write them to `.env`:
Confidence
95% confidence
Finding
The instruction to ask the user for credentials and write them into `.env` is a direct credential-collection pattern. Even if intended for legitimate configuration, it concentrates sensitive material in a plaintext local file and normalizes broad secret handling by the agent, which is dangerous in a skill that also interacts with external repos, wallets, and network services.

Credential Access

High
Category
Privilege Escalation
Content
| `RPC_URL` | Yes | Base mainnet RPC URL |
| `OPERATE_PASSWORD` | Yes | Wallet encryption password (min 8 chars) |
| `GEMINI_API_KEY` | Only if no Google One AI Premium | Gemini API key from https://aistudio.google.com/apikey. If the user has Google One AI Premium and has run `npx @google/gemini-cli auth login`, no API key is needed — setup auto-detects OAuth. |
| `GITHUB_TOKEN` | Highly recommended | Personal access token with repo scope |
| `GIT_AUTHOR_NAME` | Highly recommended | Git commit author name — this becomes the identity the worker agent uses when committing code on venture jobs |
| `GIT_AUTHOR_EMAIL` | Highly recommended | Git commit author email |
Confidence
94% confidence
Finding
Requesting a GitHub personal access token with repo scope, alongside a Gemini API key and wallet password, creates a broad credential-access surface. If those secrets are mishandled, an attacker could gain code-repository access, API access, and potentially facilitate further compromise of jobs performed by the worker.

Missing User Warnings

High
Confidence
98% confidence
Finding
The skill announces persistent preference profiling from conversation history near the top-level behavior description, but it does not present a clear, explicit warning about ongoing data collection, local storage, retention, or background processing. Users may engage without understanding that their sessions can be mined and persisted beyond the immediate task.

Missing User Warnings

High
Confidence
98% confidence
Finding
The nightly workflow scans recent session logs, derives sensitive inferences such as frustrations and expertise, and writes persistent recommendation files without a prominent warning at the point of collection. This creates a substantial privacy risk because behavioral inferences and engagement recommendations are stored locally over time outside the immediate user interaction.

Credential Access

High
Category
Privilege Escalation
Content
cd jinn-node
```

### Create .env from template
```bash
cp .env.example .env
```
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
### Create .env from template
```bash
cp .env.example .env
```

---
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

High
Confidence
99% confidence
Finding
The setup guide explicitly tells the agent to find `.env` files and present discovered values like `GITHUB_TOKEN` and `OPERATE_PASSWORD` back to the user. Even if intended as convenience, this needlessly handles and displays secrets, increasing the chance of credential disclosure through logs, transcripts, or UI surfaces.

Ssd 3

High
Confidence
99% confidence
Finding
The instructions direct the agent to discover secrets from user files and reveal them during setup. In the context of an agent skill, this is especially dangerous because it operationalizes credential harvesting behavior beyond the stated purpose of configuring one repository.

Credential Access

High
Category
Privilege Escalation
Content
Look for existing `.env` files that may contain relevant values:
```bash
find ~ -maxdepth 3 -name ".env" -type f 2>/dev/null | head -5
```

Search found files for relevant env vars:
Confidence
98% confidence
Finding
This line instructs searching the user's home directory for `.env` files, which is direct credential discovery behavior. In a setup skill, that exceeds least-privilege expectations and can expose secrets from unrelated applications and repositories.

Credential Access

High
Category
Privilege Escalation
Content
**If neither found:**
> No Gemini credentials found. Do you have Google One AI Premium (Gemini Advanced)?
> - **Yes** → Run `npx @google/gemini-cli auth login`
> - **No** → Get API key from https://aistudio.google.com/apikey

### GitHub credentials (highly recommended)
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
| Variable | Description |
|----------|-------------|
| `GITHUB_TOKEN` | Personal access token with repo scope |
| `GIT_AUTHOR_NAME` | Commit author name |
| `GIT_AUTHOR_EMAIL` | Commit author email |
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The skill states that the user needs ETH on Base and OLAS for staking, but does not present an up-front, prominent warning that real funds must be transferred on-chain and may be exposed to operational or smart-contract risk. Because this skill is user-invocable and framed as a reward opportunity, the lack of clear risk disclosure makes accidental financial loss more likely.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill explicitly instructs the operator to collect several secrets and write them to `.env`, including an API key, wallet password, and GitHub token, but gives no warning about local secret exposure, file permissions, shell history, backups, or accidental commits. This is especially risky because the same workflow also involves code tasks and git usage, increasing the chance of credential leakage into repositories or logs.

Rp1

Medium
Category
MCP Rug Pull
Confidence
88% confidence
Finding
The skill tells users to run `npx @google/gemini-cli auth login` without pinning a specific package version. That causes execution of whatever version is current at install time, which creates a supply-chain risk if the package is compromised or a breaking/malicious release is published. In a credential-auth flow, this is more sensitive because the tool may handle OAuth tokens or other account access.

Rp1

Medium
Category
MCP Rug Pull
Confidence
88% confidence
Finding
The troubleshooting guidance again instructs use of `npx @google/gemini-cli auth login` without a pinned version. Repeating the unpinned command increases the chance users will execute arbitrary newly published package code, making this a real supply-chain exposure rather than a theoretical issue.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The activation rules match very common conversational phrases about ideas or automation, so the skill may trigger during ordinary discussion that is not intended to invoke launchpad behavior. In combination with profiling and write-capable actions, overbroad activation raises the chance of unintended data processing and action suggestions.

Intent-Code Divergence

Medium
Confidence
96% confidence
Finding
The document claims all actions require user approval before execution, yet the profile-builder cron reads private session logs and writes local state automatically. This mismatch undermines informed consent and can mislead operators into believing no action occurs without confirmation when background data processing actually does.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The intent patterns for venture suggestion are generic brainstorming phrases that commonly appear in benign conversations. Even if submission still requires confirmation, the skill may draft and steer users toward publishing ventures based on casual remarks, increasing the risk of misinterpretation and unnecessary processing of conversation content.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
SLUG=$(echo "$NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd 'a-z0-9-')

curl -s "${SUPABASE_URL}/rest/v1/ventures" \
  -X POST \
  -H "apikey: ${KEY}" \
  -H "Authorization: Bearer ${KEY}" \
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Context-Inappropriate Capability

Medium
Confidence
97% confidence
Finding
The skill instructs the agent to scan local session logs, infer topics/frustrations/expertise, and build a persistent user profile plus pending-action files. This is broader than the stated launchpad engagement purpose and creates a privacy-invasive surveillance mechanism that could collect sensitive behavioral data without clear, specific consent for ongoing background analysis.

Session Persistence

Medium
Category
Rogue Agent
Content
2. Analyze for: topics discussed, technical domains, frustrations, venture-relevant intents
3. Update category affinity scores (0.0-1.0), topics, keywords, expertise
4. Cross-reference with current ventures to generate pending action recommendations
5. Write pending actions to `~/.openclaw/jinn-launchpad-pending.json`

**Morning brief:**
Confidence
94% confidence
Finding
Writing persistent pending-action files based on analyzed session history creates durable behavioral state that can outlive the original conversation and be reused later. Even if stored locally, this persistence increases privacy and misuse risk, especially when combined with autonomous cron-driven recommendations and unclear user awareness.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The cron setup enables autonomous background tasks, including proactive WhatsApp outreach, under an isolated session without per-run confirmation. That expands the skill from user-initiated venture interaction into unsupervised monitoring and outbound messaging, increasing the risk of privacy violations, unwanted actions, and reputation harm.

Context-Inappropriate Capability

Medium
Confidence
99% confidence
Finding
The instructions direct searching the user's home directory for `.env` files and extracting values such as RPC URLs, passwords, GitHub tokens, and API keys. This is broader secret discovery than necessary for setting up this skill and creates an unnecessary path to collect unrelated credentials from other projects.

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
The guide instructs checking for Gemini OAuth credentials in `~/.gemini/oauth_creds.json` and reusing them for this setup. Accessing account-wide credentials from the home directory exceeds the minimum needed scope and can expose or normalize reuse of sensitive authentication artifacts across tools.

Ssd 3

Medium
Confidence
95% confidence
Finding
The guide encourages discovering and reusing previously stored Gemini credentials from local files, including OAuth credentials and API keys. This broadens credential exposure and could lead to disclosure or misuse of authentication material intended for other contexts.

Static analysis

Detected: suspicious.generated_source_template_injection

User-controlled placeholder is embedded directly into generated source code.

Critical
Code
suspicious.generated_source_template_injection
Location
references/launchpad.md:19