Back to skill

Security audit

LobsterBio - Dev

Security checks for vulnerabilities and agentic risk

Overview

This is mostly a legitimate Lobster development guide, but it tells agents to install unpinned packages automatically and includes unsafe API-key setup guidance.

Install only after reviewing the exact Lobster package source/version you intend to use, preferably with pinned dependencies or a lockfile. Do not paste API keys into chat or pass long-lived secrets on command lines; use safer secret handling where available. Treat the skill as suitable for Lobster-specific development, not as a general development assistant trigger.

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
SKILL.md:40
Finding
Mandatory Installation of Unpinned Third-Party Packages<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:40-49` **Vulnerability Type**: Unverified third-party dependency installation **Risk Level**: Medium ### Vulnerable Code ```markdown **HARD GATE — If `lobster` is not installed, STOP. Install it NOW before doing anything else:** ```bash uv venv --python 3.12 .venv && source .venv/bin/activate uv pip install 'lobster-ai[anthropic]' # or [openai], [google], depending on provider lobster --version # Must succeed before you proceed ``` Do NOT skip this. Do NOT "come back to it later". Do NOT manually create package directories. `lobster scaffold agent` is the ONLY way to create new agent packages — it generates correct PEP 420 structure, entry points, AQUADIF metadata, and contract tests that you WILL get wrong by hand. ``` ### Technical Analysis The Skill directs the agent to install `lobster-ai` and its provider-specific transitive dependencies from the default Python package index without: - Pinning a reviewed package version. - Using a lockfile. - Requiring package hashes. - Verifying the publisher or artifact provenance. - Requesting explicit user authorization before modifying the environment. Because the requirement is expressed as a mandatory hard gate, an agent following the Skill may install packages even when the user's request only requires source inspection or planning. Python package installation can place executable modules, command-line entry points, and other package-controlled files into the virtual environment. The effective code installed can change after the Skill itself has been reviewed because the dependency version is resolved at execution time. The command creates a project-local virtual environment, so it does not inherently obtain root privileges. Nevertheless, package code subsequently imported or invoked operates with the permissions of the user running the agent. ### Attack Path 1. An attacker compromises `lobster-ai`, one of its transitive dependencies, or th ...[truncated 1346 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require explicit user approval before creating a virtual environment or installing any package. 2. Pin `lobster-ai` and provider extras to reviewed versions, for example through a checked-in lockfile. 3. Require cryptographic hashes for downloaded distributions where supported. 4. Prefer a private or explicitly configured trusted package index for controlled environments. 5. Document the expected package publisher, repository, and version so users can verify provenance. 6. Separate read-only planning and source-analysis workflows from workflows that require installation. 7. Replace the unconditional hard gate with a safe prompt such as: - Report that Lobster is missing. - Explain why installation may be needed. - Show the exact proposed command and dependency source. - Wait for user approval before executing it. 8. Run installation and validation in an isolated, minimally privileged environment without unrelated credentials. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/cli.md:60
Finding
Secret Values Encouraged Through Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `references/cli.md:60-91` **Vulnerability Type**: Credential exposure through process arguments and command logging **Risk Level**: Medium ### Vulnerable Code ```markdown Interactive setup wizard for LLM provider, API keys, agent selection, and optional packages. ```bash lobster init [OPTIONS] Options: --global, -g Save config globally (~/.config/lobster/) for all projects --force, -f Overwrite existing configuration --non-interactive Non-interactive mode (for CI/CD and coding agents) --anthropic-key KEY Claude API key (non-interactive) --gemini-key KEY Google Gemini API key (non-interactive) --openai-key KEY OpenAI API key (non-interactive) --bedrock-access-key KEY AWS Bedrock access key (non-interactive) --bedrock-secret-key KEY AWS Bedrock secret key (non-interactive) --use-ollama Use Ollama local LLM (non-interactive) --ollama-model MODEL Ollama model name (default: llama3:8b-instruct) --profile PROFILE Agent profile: development, production, performance, max --ncbi-key KEY NCBI API key (optional) --cloud-key KEY Omics-OS Cloud API key (optional) --agents LIST Comma-separated agent names to enable --preset NAME Agent preset: scrna-basic, scrna-full, multiomics-full --auto-agents LLM-powered agent suggestion (requires --agents-description) --skip-docling Skip docling install prompt --install-docling Install docling for PDF intelligence --skip-extras Skip all optional package prompts --skip-ssl-test Skip SSL connectivity test ``` **NOTE:** The default (interactive) mode is a terminal wizard that requires user keyboard input. Coding agents should use `--non-interactive` with the appropriate provider flags, or ask the user to run `lobster init` in a separate terminal. ``` ### Techn ...[truncated 2470 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Stop recommending command-line arguments as the preferred mechanism for secrets. 2. Add secure alternatives such as: - Reading secrets from standard input without echo. - Interactive hidden-input prompts. - A file descriptor dedicated to secret input. - Integration with an operating-system keychain or secret manager. - CI secret injection that does not print the value. 3. If environment variables remain supported, warn that agents must not print, enumerate, or persist them in transcripts. 4. Instruct coding agents never to request users to paste credentials into chat. 5. Ensure all CLI logging, debug output, exception messages, and telemetry redact recognized secret flags and provider key formats. 6. If legacy secret flags must remain available, mark them as insecure and deprecated. 7. Encourage narrowly scoped, short-lived credentials and immediate rotation after suspected disclosure. 8. Add tests verifying that credentials do not appear in logs, error messages, shell-completion output, or process diagnostics generated by the application. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
Findings (8)

Instruction Override

High
Category
Prompt Injection
Content
--workspace, -w PATH    Set workspace directory
  --model, -m MODEL       LLM model to use (default: from config)
  --verbose, -v           Enable verbose output
  --debug                 Enable debug mode
```

**In-chat commands:**
Confidence
70% confidence
Finding
This pattern attempts to override system instructions or ignore safety constraints. Without LLM analysis, manual review is recommended.

Self-Modification

High
Category
Rogue Agent
Content
Options:
  --global, -g              Save config globally (~/.config/lobster/) for all projects
  --force, -f               Overwrite existing configuration
  --non-interactive         Non-interactive mode (for CI/CD and coding agents)
  --anthropic-key KEY       Claude API key (non-interactive)
  --gemini-key KEY          Google Gemini API key (non-interactive)
Confidence
85% confidence
Finding
Skill modifies its own code, configuration, or behavior at runtime. Self-modification enables an agent to escalate privileges, disable safety constraints, or install persistent backdoors.

Credential Access

High
Category
Privilege Escalation
Content
| Mode | Config | Credentials |
|------|--------|-------------|
| Workspace (default) | `.lobster_workspace/provider_config.json` | `.env` |
| Global (`--global`) | `~/.config/lobster/providers.json` | `~/.config/lobster/credentials.env` (0600) |

Agent selection stored in `.lobster_workspace/agents.json`.
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Lp3

Medium
Category
MCP Least Privilege
Confidence
89% confidence
Finding
The skill includes executable shell and Python commands for environment discovery and installation, but it does not declare an explicit tool scope such as permissions or allowed-tools. That creates ambiguity about what actions the agent may take and increases the risk of unreviewed file reads or command execution in environments where skill instructions are auto-followed.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The trigger phrases are broad enough to activate on many normal software-development requests such as 'fix bug', 'add feature', 'write tests', or 'contribute'. Over-broad activation can cause the skill to be invoked in unrelated contexts, pulling in strong instructions like forced installation and scaffold requirements that may lead to unnecessary environment changes or mis-scoped actions.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The CLI documentation explicitly instructs users to pass API keys and cloud credentials as command-line arguments in non-interactive mode, but does not warn that such secrets may be exposed via shell history, process listings, CI logs, or telemetry. In a development/agent-oriented tool, this increases the chance of credential leakage because automation commonly captures command invocations verbatim.

Intent-Code Divergence

Medium
Confidence
94% confidence
Finding
Earlier guidance says system prompts must never duplicate tool information already present in tool docstrings/schemas and explicitly forbids a <Your_Tools> section or duplicate tool listings. The testing requirement at L550 for semantic prompt tests ensuring 'all tools documented by name' conflicts with that documented intent and would push contributors to add the very duplication the file says to avoid.

Scope Creep

Low
Category
Excessive Agency
Content
- Importing signal track files (bigWig, bedGraph) as coverage matrices over defined genomic windows
- Importing fragment files from assays that produce per-read coordinate data (e.g., ATAC-seq fragments)

These illustrate that IMPORT is not limited to count matrices — any domain-specific file format that needs parsing into the internal AnnData representation is an IMPORT tool.

**Boundary with `data_expert`:** Lobster's `data_expert` agent (in core) already handles generic file loading via `load_modality(adapter="...")` and database downloads via `execute_download_from_queue`. Your domain IMPORT tools should only handle **formats requiring domain expertise to parse** (vendor-specific outputs, domain-specific file structures with scientific defaults). Do not duplicate generic CSV/H5AD loading — that is `data_expert`'s job. See `creating-agents.md` → "Data Loading Boundary" for the full decision rule.
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Static analysis

No suspicious patterns detected.