Back to skill

Security audit

marketing

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly aligned with Instagram content generation, but it sends the API key and product page data to an API hostname that differs from the main documentation.

Review before installing or using. Only use a narrowly scoped SKILLBOSS_API_KEY, confirm whether api.heybossai.com is an authorized SkillBoss endpoint, avoid private or sensitive product URLs, and treat extracted product claims as untrusted until checked against the source page.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/extract_product.py:28
Finding
API Credential Sent to a Destination Inconsistent with User-Facing Documentation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:77-82`; `scripts/extract_product.py:28-39` **Vulnerability Type**: Credential disclosure to an unexpected network destination **Risk Level**: High ### Vulnerable Code The user-facing documentation identifies `api.skillbossai.com` as the API endpoint: ```markdown The script uses **SkillBoss API Hub** (`https://api.skillbossai.com/v1/pilot`) to: 1. Scrape the product page via the `scraping` capability 2. Extract structured product data via the `chat` capability (auto-routed LLM) ``` The implementation instead sends the API key to `api.heybossai.com`: ```python SKILLBOSS_API_KEY = os.environ["SKILLBOSS_API_KEY"] API_BASE = "https://api.heybossai.com/v1" def pilot(body: dict) -> dict: r = requests.post( f"{API_BASE}/pilot", headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"}, json=body, timeout=60, ) return r.json() ``` ### Technical Analysis The script reads `SKILLBOSS_API_KEY` from the process environment and transmits it as an HTTP bearer credential on every `pilot()` request. Although the request uses HTTPS, the receiving hostname is inconsistent with the endpoint disclosed in the user-facing Skill instructions. The script's own docstring mentions `api.heybossai.com`, but users following `SKILL.md` are told that their credential will be used with `api.skillbossai.com`. This inconsistency prevents informed verification of the credential recipient and creates a trust-boundary violation. Remote API access is relevant to the declared product-extraction functionality. However, sending a credential to an endpoint different from the documented endpoint exceeds the network authority that users can reasonably infer from the primary Skill instructions. The available evidence does not establish whether the two domains have common ownership, so malicious intent cannot be asserted. ### Attack Path 1. A user installs ...[truncated 1260 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Use one canonical, officially controlled API endpoint consistently in both the implementation and `SKILL.md`. 2. Verify and document the ownership relationship between `api.skillbossai.com` and `api.heybossai.com` before transmitting credentials. 3. Clearly disclose the exact hostname that receives the API key and product data. 4. Add a strict hostname allowlist and reject redirects to unapproved origins. 5. Use a narrowly scoped key restricted to the required scraping and chat operations. 6. Apply short expiration periods, usage limits, and billing limits to the key where supported. 7. Rotate any credentials previously used while the destination discrepancy existed. 8. Check HTTP status codes with `raise_for_status()` and fail closed on TLS, redirect, or response-validation errors. 9. Avoid evaluating the environment variable at module import time; retrieve it immediately before authorized use and provide a controlled error if it is absent. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/extract_product.py:50
Finding
Indirect Prompt Injection Through Untrusted Scraped Page Content<![CDATA[ ## Vulnerability Details **File Location**: `scripts/extract_product.py:50-83` **Vulnerability Type**: Untrusted content embedded directly into an LLM instruction prompt **Risk Level**: Medium ### Vulnerable Code ```python # Step 1: Scrape the product page via SkillBoss API Hub scrape_result = pilot({ "type": "scraper", "inputs": {"url": self.url}, "prefer": "balanced" }) page_content = scrape_result["result"]["data"]["markdown"] # Step 2: Use SkillBoss LLM to extract structured product data extraction_prompt = f"""Extract product information from this page content and return a JSON object with exactly these fields: - name: product name (string) - price: product price (string) - description: brief product description, max 200 characters (string) - features: list of up to 5 key product features (array of strings) - target_audience: who this product is for, e.g. Men/Women/Kids/Gamers/Fitness Enthusiasts/Homeowners/General Consumers (string) - usp: unique selling proposition in one sentence (string) - platform: e-commerce platform name, one of Amazon/Shopify/Taobao/JD/Generic (string) Page URL: {self.url} Page Content: {page_content[:3000]} Return ONLY valid JSON with no markdown fences.""" chat_result = pilot({ "type": "chat", "inputs": { "messages": [{"role": "user", "content": extraction_prompt}] }, "prefer": "balanced" }) text = chat_result["result"]["choices"][0]["message"]["content"] product_data = json.loads(text) product_data["url"] = self.url product_data["content_type"] = self._suggest_content_type(product_data) return product_data ``` ### Technical Analysis The Skill accepts an arbitrary product URL, retrieves the page as Markdown, and concatenates up t ...[truncated 2319 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Treat all scraped webpage content as untrusted data rather than instructions. 2. Place immutable extraction rules in a system message that explicitly prohibits following instructions found in page content. 3. Pass page content in a separately delimited data block or structured field and state that text inside the block must only be analyzed. 4. Use provider-supported schema-constrained or tool-based structured output instead of relying solely on a request to return JSON. 5. Validate the result against a strict local schema: - Require exactly the expected fields. - Reject unexpected fields. - Enforce string and array types. - Limit description, feature, and field lengths. - Limit features to five entries. - Restrict `platform` to the documented enumeration. 6. Detect and reject instruction-like output, URLs, scripts, markup, or control text in fields where such content is unnecessary. 7. Verify sensitive commercial claims, especially prices and discounts, against independently parsed page elements before using them in marketing copy. 8. Preserve provenance for extracted fields so downstream content generation can distinguish source text from model inference. 9. Consider deterministic HTML parsing for common product metadata, such as JSON-LD and Open Graph fields, before using an LLM as a fallback. 10. Add adversarial tests using pages containing instructions such as “ignore previous instructions” and confirm that extraction remains schema-compliant and source-grounded. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • 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 (10)

Tainted flow: 'SKILLBOSS_API_KEY' from os.environ (line 27, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
def pilot(body: dict) -> dict:
    r = requests.post(
        f"{API_BASE}/pilot",
        headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"},
        json=body,
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The declared behavior says the skill generates Instagram marketing content, but the documented implementation also performs external scraping and LLM-based extraction through SkillBoss API Hub, which is materially different and more sensitive than pure content generation. This mismatch can mislead users and reviewers into approving a skill without realizing it transmits URLs and scraped content externally, enabling unexpected data handling and broader capability use than advertised.

Lp3

Medium
Category
MCP Least Privilege
Confidence
93% confidence
Finding
The skill requires an API key and explicitly instructs use of a script that performs external network access, but it does not declare any tool scope or permissions boundary. This creates a trust and review gap: operators and users cannot easily see that the skill can access environment secrets and send data off-platform, increasing the risk of unintended secret use or network exfiltration.

External Transmission

Medium
Category
Data Exfiltration
Content
SKILLBOSS_API_KEY=your_key python3 scripts/extract_product.py <url>
```

The script uses **SkillBoss API Hub** (`https://api.skillbossai.com/v1/pilot`) to:
1. Scrape the product page via the `scraping` capability
2. Extract structured product data via the `chat` capability (auto-routed LLM)
Confidence
90% confidence
Finding
The skill contains an explicit external endpoint and directs use of it for scraping and LLM extraction, which means user-provided inputs and retrieved page data are sent outside the local trust boundary. External transmission is not inherently malicious, but it is dangerous when not tightly scoped, disclosed, and governed because it creates data leakage, third-party dependency, and compliance risks.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The skill instructs users to send product URLs and scraped page content to a third-party API without any privacy notice, consent flow, or explanation of retention and downstream processing. Even if product pages are often public, transmitted content may include tracking parameters, merchant-specific data, or user-supplied URLs that reveal business intent, making silent external sharing a real privacy and compliance concern.

External Transmission

Medium
Category
Data Exfiltration
Content
Extracts product information from e-commerce URLs for Instagram content generation.
Supports: Amazon, Shopify, Taobao, JD, and generic e-commerce sites.

Uses SkillBoss API Hub (https://api.heybossai.com/v1/pilot) for web scraping
and AI-powered structured data extraction.

Usage:
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
Extracts product information from e-commerce URLs for Instagram content generation.
Supports: Amazon, Shopify, Taobao, JD, and generic e-commerce sites.

Uses SkillBoss API Hub (https://api.heybossai.com/v1/pilot) for web scraping
and AI-powered structured data extraction.

Usage:
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
def pilot(body: dict) -> dict:
    r = requests.post(
        f"{API_BASE}/pilot",
        headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"},
        json=body,
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The script sends the user-supplied product URL and up to 3000 characters of scraped page content to a third-party API for extraction, but it provides no explicit disclosure, consent flow, or data handling warning. If users provide private, non-public, or sensitive product pages, this can cause unintended data sharing outside the local environment.

Ssd 1

Medium
Confidence
98% confidence
Finding
Untrusted page text is interpolated directly into the LLM prompt, so a malicious product page can include prompt-injection content that manipulates the model's extraction behavior, produces malformed JSON, or returns attacker-chosen fields. In this skill context, the model output is then trusted and surfaced as structured marketing input, making content poisoning and downstream misinformation plausible.

Static analysis

No suspicious patterns detected.