Back to skill

Security audit

DeepDive OSINT

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed OSINT tool, but it automatically installs and runs mutable remote code with broad local access.

Install only if you are comfortable with this skill fetching and running a full third-party app from GitHub and installing Python packages on your machine. Use a sandbox or dedicated environment, review and pin the upstream repository and dependencies first, avoid sensitive subjects with external AI providers unless you accept their data policies, and keep the local server bound to localhost.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:50
Finding
Automatic Retrieval and Execution of Mutable Remote Code<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:50-70` **Vulnerability Type**: `T03: Remote Payload Retrieval and Execution` **Risk Level**: High ### Vulnerable Code ```python if not DEEPDIVE_ROOT: print("DeepDive not found — installing from GitHub...") install_dir = os.path.expanduser('~/deepdive') subprocess.run( ['git', 'clone', 'https://github.com/Sinndarkblade/deepdive', install_dir], check=True ) subprocess.run( [sys.executable, '-m', 'pip', 'install', '-r', os.path.join(install_dir, 'requirements.txt')], check=True ) DEEPDIVE_ROOT = install_dir print(f"✓ DeepDive installed at {DEEPDIVE_ROOT}") sys.path.insert(0, os.path.join(DEEPDIVE_ROOT, 'core')) sys.path.insert(0, os.path.join(DEEPDIVE_ROOT, 'server')) sys.path.insert(0, os.path.join(DEEPDIVE_ROOT, 'src')) from graph import InvestigationGraph, Entity, Connection from build_board import build_board print(f"✓ DeepDive ready") ``` The skill also recommends directly starting the downloaded server: ```bash cd ~/deepdive && python3 server/app.py ``` ### Technical Analysis The skill clones a mutable GitHub repository without pinning an immutable commit, tag digest, or verified release artifact. It then installs dependencies from a remotely supplied `requirements.txt`, adds downloaded directories to `sys.path`, and imports Python modules from them. Python module imports execute module-level code. Package installation can also execute build-system or installation hooks. Consequently, the effective code executed by the skill is controlled by the current state of an external repository rather than by the reviewed skill package. A repository owner, compromised maintainer account, or attacker who gains control of the upstream repository can alter the payload after this skill has been audited. The separately documented command to run `server/app.py` provides another direct execution path for the unverified remote applic ...[truncated 1389 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove automatic cloning and execution of mutable upstream content. 2. Vendor the required implementation into the reviewed skill package, or use a formally reviewed release artifact. 3. If remote retrieval is unavoidable, pin an immutable Git commit and verify the downloaded content against a trusted cryptographic digest or signature. 4. Do not add downloaded source directories directly to `sys.path` before integrity verification. 5. Require explicit user confirmation before installing dependencies, importing retrieved modules, or starting a server. 6. Run the application in a sandbox or container with: - A dedicated unprivileged account. - Read-only access to required files. - No access to unrelated home-directory content. - Restricted outbound network access. - No inherited secrets unless explicitly required. 7. Pin all transitive dependencies and require hashes for installation. 8. Review the complete upstream source and dependency graph before approving a pinned version. 9. Bind any local server to loopback only, disable unsafe debug functionality, and require authentication where sensitive data or settings are exposed. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:8
Finding
Unpinned Third-Party Package Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:8-16` **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium ### Vulnerable Code ```yaml requires: bins: - python3 - git - pip3 install: - kind: uv package: duckduckgo-search bins: [ddgs] ``` ### Technical Analysis The skill requests installation of `duckduckgo-search` without specifying an exact version or cryptographic hash. Dependency resolution can therefore select different package contents over time. This makes the reviewed behavior non-reproducible and exposes installation to upstream package compromise, a malicious future release, or compromise of the package distribution account. The remote DeepDive installation also runs: ```python subprocess.run( [sys.executable, '-m', 'pip', 'install', '-r', os.path.join(install_dir, 'requirements.txt')], check=True ) ``` Because that manifest is retrieved from a mutable repository, its dependency names, versions, package sources, and build requirements can change after review. ### Attack Path 1. A user installs or invokes the skill. 2. The installation mechanism resolves the unpinned `duckduckgo-search` package, or the skill processes the mutable remote `requirements.txt`. 3. A compromised or malicious package release is selected by the resolver. 4. Package installation or import executes attacker-controlled installation hooks or Python code. 5. The code runs with the privileges of the process performing the installation or invoking the skill. ### Impact Assessment A malicious dependency can execute code with the invoking user's permissions. Potential consequences include access to local files, environment variables, provider credentials, investigation records, and network resources available to that account. The reviewed file does not prove that the current dependency release is malicious. The confirmed issue is the absence of version and integrity controls, which permits package con ...[truncated 65 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `duckduckgo-search` to an explicitly reviewed version. 2. Require a cryptographic hash for every downloaded distribution. 3. Use a lock file that records exact direct and transitive dependency versions. 4. Install only from an approved package index over authenticated TLS. 5. Prefer prebuilt, verified artifacts and reject unexpected source builds. 6. Pin build-system dependencies because installation hooks may execute before the main package is installed. 7. Generate and review a software bill of materials for the complete dependency tree. 8. Use automated vulnerability and provenance scanning before dependency updates. 9. Update dependencies through a controlled review process rather than resolving the latest available release automatically. 10. Isolate dependency installation and runtime execution in a minimally privileged environment. ]]>
Vulnerability Patterns
  • 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
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (6)

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The skill contains first-run logic that clones code from GitHub and installs dependencies with pip via subprocess. This is dangerous because it executes unpinned remote code and package installation on the user's machine, enabling supply-chain compromise, arbitrary code execution during install, and persistent system modification far beyond what a documentation-driven skill should do.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The markdown states that the skill auto-installs the full application from GitHub on first run without a prominent consent or safety warning. Users may invoke the skill expecting analysis behavior, not filesystem changes, package installation, and execution of remote project setup steps, which undermines informed consent and safe operation.

Context-Inappropriate Capability

Medium
Confidence
89% confidence
Finding
The skill documentation instructs users to run a local web server and configure third-party AI providers, expanding the skill from simple OSINT guidance into operating a networked application with external integrations. This increases attack surface and can expose investigation data, API keys, and local files through a broader server/UI environment than users may expect from a markdown skill.

External Transmission

Medium
Category
Data Exfiltration
Content
| Provider | Model | Notes |
|----------|-------|-------|
| **DeepSeek** | `deepseek-chat` | Best value — cheap, strong — `https://api.deepseek.com/v1` |
| **Groq** | `llama-3.3-70b-versatile` | Free tier, fast — `https://api.groq.com/openai/v1` |
| **OpenAI** | `gpt-4o-mini` | Widely available |
| **Ollama** | any local model | Offline only, lower quality on large investigations |
Confidence
78% confidence
Finding
The skill explicitly recommends configuring an external AI provider endpoint, which would transmit investigation prompts and potentially sensitive OSINT-derived data off-host. In an investigation context, subjects, connections, and notes may be confidential, so external transmission introduces privacy, compliance, and data retention risk.

External Transmission

Medium
Category
Data Exfiltration
Content
| Provider | Model | Notes |
|----------|-------|-------|
| **DeepSeek** | `deepseek-chat` | Best value — cheap, strong — `https://api.deepseek.com/v1` |
| **Groq** | `llama-3.3-70b-versatile` | Free tier, fast — `https://api.groq.com/openai/v1` |
| **OpenAI** | `gpt-4o-mini` | Widely available |
| **Ollama** | any local model | Offline only, lower quality on large investigations |
Confidence
78% confidence
Finding
The Groq provider recommendation similarly implies sending investigation data to an external service. Because this skill is intended for deep investigations involving people, companies, finances, and allegations, transmitting raw prompts or extracted entities to third parties can create material confidentiality and legal exposure.

Missing User Warnings

Low
Confidence
87% confidence
Finding
The skill uses subprocess.Popen to open a generated HTML board automatically in the user's environment without a clear warning. While lower severity, unexpected application launch can be abused for social engineering, can surprise users in sensitive environments, and may trigger browser handling of untrusted locally generated content.

Static analysis

No suspicious patterns detected.