Back to skill

Security audit

Blog Watcher

Security checks for vulnerabilities and agentic risk

Overview

The skill is a plausible blog update checker, but it needs review because it fetches arbitrary user-provided URLs without network safety limits and overstates several features.

Install only if you are comfortable with the skill making outbound requests from the agent environment to URLs you provide. Avoid monitoring internal, localhost, metadata-service, or untrusted URLs unless the implementation is hardened with URL validation, timeouts, response-size limits, and clear dependency pinning. Also treat the advertised diff, scheduling, push, and exclusion-rule features as not actually present in this artifact.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (3)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:42
Finding

Unrestricted URL Fetching Enables Server-Side Request Forgery

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 42–77
Vulnerability Type: Server-Side Request Forgery (SSRF)
Risk Level: High

python
def add_blog(self, name: str, url: str, use_rss: bool = True):
    self.watch_list.append({
        'name': name,
        'url': url,
        'use_rss': use_rss,
    })

def _check_rss(self, blog: dict) -> dict:
    feed = feedparser.parse(blog['url'])
    if feed.entries:
        latest = feed.entries[0]
        return {
            'name': blog['name'],
            'title': latest.title,
            'link': latest.link,
            'published': latest.get('published', 'Unknown'),
        }
    return None

def _check_webpage(self, blog: dict) -> dict:
    response = requests.get(blog['url'])

Technical Analysis

add_blog() accepts an arbitrary URL and stores it without validating its scheme, hostname, resolved address, port, or redirect destination. Both monitoring paths subsequently fetch this caller-controlled URL through feedparser.parse() or requests.get().

An attacker who can add or influence a monitored URL can therefore make the process send requests to destinations reachable from the agent host. Potential targets include loopback services, private network addresses, link-local endpoints, cloud instance metadata services, and administrative interfaces that are not externally accessible. DNS rebinding and redirects can also bypass validation if checks are only applied to the initial textual hostname.

The RSS path returns response-derived title, link, and publication fields. Consequently, data obtained from an internal endpoint may be exposed through normal monitoring output when it can be interpreted as a feed.

Attack Path

  1. An attacker supplies a monitored URL that points to an internal service, a cloud metadata endpoint, or an attacker-controlled redirect.
  2. The URL is accepted by add_blog() without validation ...[truncated 1039 chars]
Remediation
View remediation

Remediation Suggestions

  • Accept only explicitly supported schemes, normally https and, if necessary, http.
  • Enforce a narrowly scoped hostname allowlist when the intended feeds are known.
  • Resolve hostnames before connecting and reject loopback, private, link-local, multicast, unspecified, reserved, and cloud metadata address ranges for both IPv4 and IPv6.
  • Protect against DNS rebinding by connecting only to a validated resolved address and ensuring the HTTP host and TLS certificate remain correct.
  • Disable redirects or validate the scheme, hostname, port, and resolved address of every redirect destination.
  • Block nonstandard ports unless they are explicitly required.
  • Apply the same policy to both requests and feedparser; preferably retrieve feeds through one hardened HTTP client and pass validated response bytes to the parser.
  • Avoid returning raw remote fields without output validation and appropriate trust labeling.
  • Apply outbound firewall or proxy restrictions as defense in depth, including explicit denial of metadata and internal network ranges.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:63
Finding

Unbounded and Unreliable Network Operations Permit Resource Exhaustion

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 63–84
Vulnerability Type: Missing timeout, response-size limit, status validation, and exception handling
Risk Level: Medium

python
def _check_rss(self, blog: dict) -> dict:
    feed = feedparser.parse(blog['url'])
    if feed.entries:
        latest = feed.entries[0]
        return {
            'name': blog['name'],
            'title': latest.title,
            'link': latest.link,
            'published': latest.get('published', 'Unknown'),
        }
    return None

def _check_webpage(self, blog: dict) -> dict:
    response = requests.get(blog['url'])
    soup = BeautifulSoup(response.text, 'html.parser')

    title = soup.title.string if soup.title else 'No title'
    content_hash = hashlib.md5(response.text.encode()).hexdigest()

Technical Analysis

The network operations do not specify connection or read timeouts. The webpage path materializes the full response as text, parses it into a document tree, encodes it again, and hashes it without imposing a maximum response size. This can substantially amplify memory use for large documents.

The implementation also does not validate HTTP status codes or content types and does not catch network, decoding, or parser exceptions. One unavailable or malicious endpoint can therefore block or terminate the complete sequential monitoring pass.

Attack Path

  1. An attacker controls or compromises a monitored endpoint, or persuades a user to monitor one.
  2. The endpoint accepts a connection but sends data indefinitely, responds extremely slowly, or returns an oversized document.
  3. feedparser.parse() or requests.get() waits without an application timeout or consumes the response without a byte limit.
  4. For webpages, the process creates multiple in-memory representations during decoding, HTML parsing, re-encoding, and hashing.
  5. The monitoring process becomes blocked, ex ...[truncated 459 chars]
Remediation
View remediation

Remediation Suggestions

  • Use explicit connection and read timeouts for every request.
  • Stream responses and stop reading after a strict maximum byte count.
  • Reject responses whose declared Content-Length exceeds the limit, while still enforcing the streamed limit because that header is untrusted.
  • Call raise_for_status() and accept only expected status codes.
  • Validate content types before parsing and restrict accepted character encodings.
  • Catch request, timeout, decoding, and parser exceptions per watched item so one failure does not terminate the entire monitoring pass.
  • Impose parser, CPU, and overall execution deadlines at the worker level.
  • Avoid retaining unnecessary duplicate representations of response content.
  • Add retry limits with exponential backoff and circuit-breaking behavior rather than retrying indefinitely.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:18
Finding

Unpinned Third-Party Dependency Installation

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, line 18
Vulnerability Type: Non-reproducible and insufficiently verified dependency installation
Risk Level: Medium

bash
pip install feedparser beautifulsoup4 requests

Technical Analysis

The installation command requests mutable package names without exact version constraints or artifact hashes. A future installation can therefore retrieve package versions different from those reviewed with this skill.

This increases exposure to a compromised package release, a compromised package registry or mirror, and unexpected breaking or security-relevant changes in transitive dependencies. The metadata declares feedparser and beautifulsoup4, while the documented implementation also imports requests, creating an additional dependency-declaration inconsistency.

There is no evidence that the listed package names are typosquatted or intentionally malicious. The finding concerns unsafe dependency-management practices rather than a confirmed malicious package.

Attack Path

  1. A user follows the documented installation command at a later time or in a different environment.
  2. pip resolves the newest versions allowed by the active package index and local configuration.
  3. A compromised, replaced, or incompatible package artifact is selected without hash verification.
  4. Package installation, import, or runtime behavior executes code with the privileges of the installing or monitoring process.

Impact Assessment

A malicious dependency artifact could execute arbitrary Python code with the privileges of the user or environment running pip or the skill. This could affect files, credentials, network access, and application data available to that process. The practical likelihood depends on compromise of the package distribution chain or environment configuration; no such compromise is established by the reviewed file.

Remediation
View remediation

Remediation Suggestions

  • Pin every direct and transitive dependency to reviewed versions through a lock file.
  • Require cryptographic hashes for downloaded artifacts, such as with a hash-locked requirements file and pip --require-hashes.
  • Configure the expected official package index explicitly and prevent fallback to untrusted extra indexes.
  • Build and retain verified wheels in a controlled artifact repository for reproducible deployments.
  • Scan pinned dependencies for known vulnerabilities and establish a reviewed update process.
  • Declare requests consistently in the skill metadata because the implementation imports it.
  • Install dependencies in an isolated virtual environment under a nonprivileged account rather than using system-wide or administrative installation.
Vulnerability Patterns
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (5)

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The manifest description explicitly advertises '变化diff对比、摘要推送、排除规则' as added capabilities. However, the only provided code computes an MD5 of the entire page and returns a minimal {'updated': True} result without any diff output, summarization, push/notification implementation, or exclusion-rule handling.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The listed trigger phrases "博客监控 / 网站更新 / 追踪博客" are short natural-language phrases without constraints or exclusion examples. In particular, "网站更新" is broad enough to match common conversational requests about website updates, which could cause unintended activation.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The feature list states '定时检查' and '通知提醒', which implies the skill performs scheduled execution and sends alerts. The documented implementation only exposes in-memory methods for adding URLs and checking them synchronously; there is no timer, job scheduler, webhook/email/message sending, or other notification mechanism.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

The skill makes outbound network requests to user-supplied URLs via feedparser.parse() and requests.get() without warning or documenting that behavior. This can surprise users and, depending on the runtime environment, may enable misuse for probing internal services, contacting unintended hosts, or causing privacy-sensitive egress from the agent environment.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
81% confidence
Finding

The description text is written in Chinese, and the activation wording later in the file is also Chinese-only. This can impose a language preference without user opt-in, which matches the locale/language policy concern for natural-language content.

Content

No source excerpt is available for this finding.