Back to skill

Security audit

SearXNG-lite

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent local multi-engine search skill that sends user queries to external search providers, with privacy and dependency caveats but no evidence of hidden control, persistence, destructive behavior, or malicious exfiltration.

Install in a virtual environment, pin dependencies if you need reproducibility, and avoid searching for secrets, proprietary incident details, regulated personal data, or confidential terms because queries may be sent to multiple external search services or through your configured proxy.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:31
Finding
Unpinned Third-Party Runtime Dependencies## Vulnerability Details **File Location**: `SKILL.md`, lines 31–34 and 40 **Vulnerability Type**: Unpinned third-party dependencies **Risk Level**: Medium ### Vulnerable Code Snippet ```markdown - `httpx` — HTTP client (`pip3 install httpx`) - `lxml` — HTML parser (`pip3 install lxml`, pre-installed on macOS) - (Optional) `socksio` — for SOCKS proxy support (`pip3 install socksio`) - (Optional) `pyyaml` — for config parsing (`pip3 install pyyaml`; falls back to built-in parser) ``` ```bash pip3 install httpx lxml ``` ### Technical Analysis The installation instructions resolve mutable latest versions of packages from the configured Python package index. No reviewed versions, integrity hashes, or lock file are provided. This creates a supply-chain exposure: a compromised package release, compromised transitive dependency, malicious package-index configuration, or unsafe future update could introduce arbitrary code during installation or runtime. The audit did not identify a currently malicious dependency; the issue is the absence of reproducible and integrity-verified dependency resolution. ### Attack Path 1. An attacker compromises a listed package, one of its transitive dependencies, or the package source configured on the victim's system. 2. A user follows the documented `pip3 install httpx lxml` command. 3. `pip` resolves and downloads the mutable package version without checking a project-provided expected hash. 4. Malicious installation or imported runtime code executes with the privileges of the user running `pip` or the Skill. 5. That code can access resources available to the process, potentially including submitted search queries, proxy configuration, environment data, and user-accessible files. ### Impact Assessment Successful exploitation could result in arbitrary code execution under the installing or executing user's account. The resulting scope would be limited by that account's operating-system permissions, but could include theft or m ...[truncated 321 chars]
Remediation
## Remediation Suggestions 1. Create a dependency lock file containing reviewed, exact versions for all direct and transitive dependencies. 2. Include cryptographic hashes and require their verification during installation, for example: ```bash python3 -m pip install --require-hashes -r requirements.txt ``` 3. Install dependencies in a dedicated virtual environment rather than the system Python environment: ```bash python3 -m venv .venv . .venv/bin/activate python3 -m pip install --require-hashes -r requirements.txt ``` 4. Review dependency updates before changing locked versions and use automated vulnerability and provenance checks. 5. Document the trusted package index and discourage installation from unverified mirrors. 6. Pin optional dependencies such as `socksio` and `pyyaml` under the same integrity policy.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (13)

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The description substantially matches the code’s core purpose: a local Python-based multi-engine search aggregator for web, developer, academic, discussion, HuggingFace, StackOverflow, and news searches. The implementation uses concurrent HTTP requests, supports category/engine selection, and outputs aggregated deduplicated results, which aligns well with the declared primary behavior. However, the description also says the skill is NOT for image generation, which is fine, but the actual code does include image search capability (Unsplash), video search (YouTube), translation (Lingva), and utility/knowledge engines such as WolframAlpha and Wikipedia/Wikidata that are not mentioned in the declared purpose. These are materially undeclared capabilities beyond the stated scope, even though they are search-related. Therefore this should be flagged as a mismatch due to under-declared functionality rather than a different primary purpose.

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill advertises and documents code that uses environment variables and outbound network access, but it does not declare an explicit tool scope such as permissions or allowed-tools. This can cause the agent platform or user to underestimate the capability boundary of the skill, increasing the risk of unintended data exposure or unauthorized network use.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The documentation explains search usage but does not clearly warn that user queries are transmitted to multiple third-party services over the network. This is dangerous because prompts may contain sensitive, proprietary, or regulated data that would be disclosed externally without an informed user opt-in.

Natural-Language Policy Violations

Medium
Confidence
89% confidence
Finding
Natural-language strings throughout the file, including the main docstring, engine descriptions, and CLI help text, are presented in Chinese only. This effectively forces a specific language for users without opt-in or justification, which matches the locale policy violation criterion.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
User queries are sent to many third-party services, often concurrently, without any in-code disclosure, consent step, or minimization control. If users include sensitive data in queries, that data may be exposed to multiple external providers, expanding privacy and compliance risk beyond what a normal single-engine search expectation implies.

External Transmission

Medium
Category
Data Exfiltration
Content
# ── 开发/IT ──

def _github(query: str, client: httpx.Client, **_) -> list[dict]:
    resp = client.get("https://api.github.com/search/repositories",
        params={"q": query, "sort": "stars", "order": "desc"},
        headers={"Accept": "application/vnd.github.v3+json", "User-Agent": _ua()}, timeout=10)
    resp.raise_for_status()
Confidence
95% confidence
Finding
This function transmits raw search queries to GitHub's external API. In the context of an agent skill, unreviewed user queries may contain secrets, internal project names, incident details, or other sensitive terms, creating external data exposure risk when sent off-platform.

External Transmission

Medium
Category
Data Exfiltration
Content
return results

def _stackoverflow(query: str, client: httpx.Client, page: int = 1, **_) -> list[dict]:
    resp = client.get("https://api.stackexchange.com/2.3/search/advanced",
        params={"q": query, "page": str(page), "pagesize": "10", "site": "stackoverflow", "sort": "relevance", "order": "desc"},
        headers={"User-Agent": _ua()}, follow_redirects=True, timeout=10)
    resp.raise_for_status()
Confidence
95% confidence
Finding
This function sends user-supplied queries to the StackExchange API, which is an external transmission boundary. In an agent setting, that creates privacy risk if prompts or embedded search terms contain confidential information, especially because the skill aggregates many such providers.

External Transmission

Medium
Category
Data Exfiltration
Content
def _semantic_scholar(query: str, client: httpx.Client, page: int = 1, **_) -> list[dict]:
    offset = (page - 1) * 10
    resp = client.get("https://api.semanticscholar.org/graph/v1/paper/search",
        params={"query": query, "offset": str(offset), "limit": "10",
                "fields": "title,url,abstract,year,citationCount,authors"},
        headers={"User-Agent": _ua()}, follow_redirects=True, timeout=10)
Confidence
95% confidence
Finding
Semantic Scholar receives the search query and returns metadata, so the main risk is outbound disclosure of potentially sensitive research topics or internal terms. This is more concerning in a multi-engine aggregator because one user action can fan out to several external services.

External Transmission

Medium
Category
Data Exfiltration
Content
return results

def _crossref(query: str, client: httpx.Client, page: int = 1, **_) -> list[dict]:
    resp = client.get("https://api.crossref.org/works",
        params={"query": query, "offset": str((page - 1) * 10), "rows": "10"},
        headers={"User-Agent": _ua()}, follow_redirects=True, timeout=10)
    resp.raise_for_status()
Confidence
95% confidence
Finding
Crossref is another third-party endpoint receiving raw user queries. While expected for search functionality, it still represents external data transfer that can leak confidential strings, especially absent consent, warning, or policy enforcement.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
The manifest describes this skill as a multi-engine web search aggregator for web pages, code repositories, papers, discussions, models, StackOverflow, and news. However, the engine registry also exposes YouTube video search, Unsplash image search, Lingva translation, Wolfram|Alpha computation, and Lemmy social search, which are materially broader capabilities not described in the manifest and include categories the manifest explicitly says not to use for image-related tasks.

Context-Inappropriate Capability

Medium
Confidence
87% confidence
Finding
The manifest positions the skill as a web-search tool and explicitly says it is not for image generation, suggesting non-image-focused usage. The Unsplash engine adds a distinct image-search capability that is not mentioned in the approved use cases and is not necessary to fulfill the stated web/code/paper/news search purpose.

External Transmission

Medium
Category
Data Exfiltration
Content
# ── 实用工具 ──

def _wolframalpha(query: str, client: httpx.Client, **_) -> list[dict]:
    resp = client.get("https://api.wolframalpha.com/v1/result",
        params={"i": query, "appid": "DEMO"},
        headers={"User-Agent": _ua()}, follow_redirects=True, timeout=10)
    if resp.status_code == 200 and resp.text:
Confidence
96% confidence
Finding
WolframAlpha receives the full query text, which may include sensitive user data, and the code uses a public DEMO appid rather than a managed credential flow. Besides privacy concerns, relying on a demo credential can cause unpredictable behavior, shared-rate-limit issues, and poor accountability for external requests.

Natural-Language Policy Violations

Low
Confidence
82% confidence
Finding
The arguments table sets `--lang` default to `en`, which establishes a default language/locale behavior in the skill documentation. While other languages are supported, the file does not frame English as a user choice or opt-in, which can be a language/locale policy concern.

Static analysis

No suspicious patterns detected.