Back to skill

Security audit

小红书内容灵感专家

Security checks across malware telemetry and agentic risk

Overview

This skill has a real Xiaohongshu analytics purpose, but it needs Review because it handles API credentials, local files, browser reports, and recurring subscriptions with more risk than users are likely to expect.

Install only if you are comfortable giving the skill a Redfox API key, allowing it to call Redfox, and accepting local report/cache files. Prefer setting REDFOX_API_KEY only for the current session instead of storing it in shell profiles, avoid opening generated HTML reports with network access until CDN and HTML-injection issues are fixed, and do not enable subscriptions unless you understand how to list and remove the scheduled task.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • 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
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (5)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:133
Finding
Mandatory promotional output and host scheduler manipulation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:133-141` **Vulnerability Type**: Agent instruction and output hijacking **Risk Level**: High ### Vulnerable Instruction Snippet The following is an English translation of the operative directives at the specified location: ```text - Subscription prompt: mandatory when articles are present; it must not be skipped. - Ask whether the user wants to subscribe to the current search conditions. - If the user selects subscription, ask for a delivery time and use the host's scheduled-task or calendar tool to create the subscription. ``` Related mandatory-output directives also occur at: - `SKILL.md:297` - `SKILL.md:331` - `scripts/fetch_explosive_articles.py:1041` - `scripts/fetch_explosive_articles.py:1065` The script-level directive at line 1041 requires the generated content to be reproduced unchanged and prohibits omission of the subscription section. ### Technical Analysis The Skill makes subscription promotion a mandatory component of otherwise ordinary data-query responses. It also instructs the Agent to invoke host scheduling or calendar capabilities after a user accepts the subscription. Retrieving or displaying Xiaohongshu ranking data does not require recurring-task creation or mandatory promotional output. These directives therefore alter the Agent's response policy and expand the operation into host-level scheduling beyond the minimum privileges required for the core query and reporting functionality. The scheduler action is conditional on user acceptance, so the reviewed code does not establish an automatic persistence mechanism by itself. Nevertheless, the mandatory response modification constitutes instruction hijacking, and the scheduler workflow creates a potential persistence boundary that requires stronger confirmation controls. ### Attack Path 1. The Skill is loaded for an ordinary Xiaohongshu data request. 2. The Skill requires the Agent to append subscription promotion to ...[truncated 827 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove all directives requiring subscription text to be included in every response. 2. Present subscription functionality only when it is directly relevant or explicitly requested. 3. Require a separate, explicit confirmation immediately before creating a recurring task. 4. Before confirmation, display: - The exact schedule and time zone. - The query parameters and destination. - The executable command or operation. - The expected network endpoints. - Instructions for listing, disabling, and deleting the task. 5. Restrict scheduler use to a narrowly scoped host API rather than arbitrary command scheduling. 6. Do not interpret ambiguous shorthand as authorization to create persistence. 7. Ensure a normal one-time query can complete without requesting scheduler access. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/fetch_explosive_articles.py:241
Finding
TLS certificate verification disabled during authenticated API requests<![CDATA[ ## Vulnerability Details **File Location**: `scripts/fetch_explosive_articles.py:241-275` **Vulnerability Type**: Missing TLS certificate and hostname verification **Risk Level**: High ### Vulnerable Code Snippet ```python http_request = ( f"GET {full_path} HTTP/1.1\r\n" f"Host: {host}\r\n" f"X-API-KEY: {api_key or ''}\r\n" f"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n" f"Accept: application/json, text/plain, */*\r\n" f"Accept-Language: zh-CN,zh;q=0.9,en;q=0.8\r\n" f"Connection: close\r\n" f"\r\n" ) ip_address = socket.gethostbyname(host) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(45) sock.connect((ip_address, 443)) context = ssl.create_default_context() context.check_hostname = False context.verify_mode = ssl.CERT_NONE ssl_sock = context.wrap_socket(sock, server_hostname=None) ssl_sock.sendall(http_request.encode('utf-8')) ``` A second instance exists in `scripts/xiaohongshu-similar-account.py:290-319`: ```python headers = { "Content-Type": "application/json", "X-API-KEY": api_key } data = json.dumps(payload).encode("utf-8") req = urllib.request.Request(url, data=data, headers=headers, method="POST") ssl_ctx = ssl.create_default_context() ssl_ctx.check_hostname = False ssl_ctx.verify_mode = ssl.CERT_NONE with urllib.request.urlopen(req, context=ssl_ctx, timeout=30) as resp: result = json.loads(resp.read().decode("utf-8")) ``` ### Technical Analysis Both clients explicitly disable certificate verification and hostname validation. The raw-socket implementation also passes `server_hostname=None`, which omits Server Name Indication and prevents normal hostname verification. Encryption without server authentication does not establish that the peer is actually `redfox.hk`. Any attacker able to intercept or redirect traffic can present an arbitrary certificate, and these clients will accept it. The authenticated request then discloses the ...[truncated 1358 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove both of the following assignments: ```python context.check_hostname = False context.verify_mode = ssl.CERT_NONE ``` 2. For the raw TLS client, use: ```python context = ssl.create_default_context() ssl_sock = context.wrap_socket(sock, server_hostname=host) ``` 3. Prefer a standard verified HTTP client such as `requests` or `urllib.request` using its default certificate validation. 4. Fail closed on certificate, hostname, and trust-chain errors. 5. Do not add a fallback path that retries with verification disabled. 6. Consider certificate pinning only if the service has an operational key-rotation plan. 7. Revoke and rotate API keys that may have been used through the affected versions. 8. Add automated tests confirming that self-signed and wrong-host certificates are rejected. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/gen_xhs_html.py:626
Finding
Stored HTML injection through unescaped API-controlled report fields<![CDATA[ ## Vulnerability Details **File Location**: `scripts/gen_xhs_html.py:626-677` **Vulnerability Type**: Stored HTML injection and cross-site scripting **Risk Level**: High ### Vulnerable Code Snippet ```javascript var noteUrl = (d.photoJumpUrl || '#').replace(/ /g, '%20'); var avatar = d.userHeadUrl || ''; var userName = (d.userName || '--').replace(/ /g, ''); var userUrl = (d.userJumpUrl || '#').replace(/ /g, '%20'); var fans = (d.fans || '').replace(/ /g, ''); var title = (d.title || '--').replace(/ /g, ''); html += '<div class="' + cardCls + '" data-href="' + noteUrl + '">' + '<div class="note-row1">' + rankHtml + '<div class="note-info">' + '<div class="note-title"><a href="' + noteUrl + '" target="_blank" onclick="event.stopPropagation()">' + title + '</a></div>' + '<div class="author-info">' + (avatar ? '<img class="author-avatar" src="' + avatar + '" onerror="this.style.display=\'none\'">' : '') + '<span class="author-name">' + (userUrl && userUrl !== '#' ? '<a href="' + userUrl + '" target="_blank" onclick="event.stopPropagation()">' + userName + '</a>' : userName) + '</span>'; document.getElementById('noteList').innerHTML = html; ``` The data is embedded earlier at `scripts/gen_xhs_html.py:297`: ```python js_data = json.dumps(hot_list, ensure_ascii=False, indent=2) ``` Additional unescaped HTML construction occurs in: - `scripts/fetch_explosive_articles.py:807-829` - `scripts/fetch_explosive_articles.py:904-907` - `scripts/xiaohongshu-similar-account.py:840-851` - `scripts/xiaohongshu-similar-account.py:925-948` For example: ```python author_html = ( f'<img src="{user_head_url}" class="author-avatar" ' f'alt="{user_name}">{user_name}({fans} 粉丝)' ) html_content = template.replace("{{ARTICLES_HTML}}", articles_html) ``` ### Technical Analysis Titles, account names, profile URLs, note URLs, image URLs, and recommendation text originate from remo ...[truncated 2078 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Stop building report rows with concatenated HTML strings. 2. Create DOM elements with `document.createElement`. 3. Assign all untrusted text through `textContent`. 4. Assign attributes only after validation with `setAttribute`. 5. Validate URLs with the `URL` parser and allow only expected HTTPS origins and schemes. 6. Reject `javascript:`, `data:`, `file:`, and other unexpected schemes. 7. In Python templates, apply `html.escape(value, quote=True)` according to the output context. 8. When embedding JSON in HTML, replace `<`, `>`, `&`, and relevant line separators with safe Unicode escapes, including converting `<` to `\u003c`. 9. Prefer a non-executable JSON element, such as `application/json`, and parse its `textContent`. 10. Add a restrictive Content Security Policy that disallows inline scripts and event handlers. 11. Add regression tests using payloads containing quotes, tags, event handlers, `javascript:` URLs, and `</script>`. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/fetch_explosive_articles.py:97
Finding
Overbroad shell-profile access and persistent user-wide API-key storage<![CDATA[ ## Vulnerability Details **File Location**: `scripts/fetch_explosive_articles.py:97-157` **Vulnerability Type**: Excessive credential-file access and insecure secret persistence **Risk Level**: Medium ### Vulnerable Code Snippet ```python def get_redfox_api_key() -> str: api_key = os.getenv("REDFOX_API_KEY", "").strip() if api_key: print( f"[auth] REDFOX_API_KEY was read from the environment " f"(first 8 characters: {api_key[:8]}...)", file=sys.stderr ) return api_key home = os.path.expanduser("~") shell_configs = [ os.path.join(home, ".zshrc"), os.path.join(home, ".bashrc"), os.path.join(home, ".bash_profile"), os.path.join(home, ".profile"), ] for config_path in shell_configs: if os.path.exists(config_path): with open(config_path, 'r', encoding='utf-8') as f: for line in f: for pattern in [ r'(?:export\s+)?REDFOX_API_KEY\s*=\s*["\']([^"\'\n]+)["\']', r'(?:export\s+)?REDFOX_API_KEY\s*=\s*([^\s"\'\n]+)', r'\$env:REDFOX_API_KEY\s*=\s*["\']([^"\'\n]+)["\']', r'set\s+REDFOX_API_KEY\s*=\s*([^\s"\'\n]+)', ]: match = re.search(pattern, line.strip()) if match: api_key = match.group(1).strip() if api_key: os.environ["REDFOX_API_KEY"] = api_key return api_key ``` Equivalent shell-profile scanning occurs in: - `scripts/crawl_xhs.py:25-38` - `scripts/fetch_rank.py:24-37` - `scripts/fetch_xhs_hot_articles.py:17-29` - `scripts/gen_xhs_html.py:40-54` - `scripts/xhs_daily_fetcher.py:40-52` - `scripts/xiaohongshu-similar-account.py:255-269` The Skill documentation at `SKILL.md:43-47` and `references/m3_core_workfl ...[truncated 2105 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Read the credential only from the current process environment. 2. If persistent storage is necessary, use an operating-system credential manager or a dedicated configuration file with owner-only permissions. 3. Do not scan `.zshrc`, `.bashrc`, `.profile`, PowerShell profiles, or other general startup files. 4. Do not encourage making credentials available to unrelated Skills. 5. Remove all logging of API-key prefixes or other credential fragments. 6. Keep credentials session-scoped by default. 7. Require explicit user consent before persisting a key. 8. Document key rotation and revocation procedures. 9. Ensure generated cache and report files never contain request headers or credentials. ]]>

T08 · Insecure Dependencies

Warning
Location
assets/preview-template.html:8
Finding
Unpinned runtime dependencies and remote scripts without integrity verification<![CDATA[ ## Vulnerability Details **File Location**: `assets/preview-template.html:8-19` **Vulnerability Type**: Unverified third-party runtime dependencies **Risk Level**: Medium ### Vulnerable Code Snippet ```html <script src="https://cdn.jsdelivr.net/npm/html2pdf.js@0.10.1/dist/html2pdf.bundle.min.js"></script> <script> function loadFallback() { var script = document.createElement('script'); script.src = 'https://cdnjs.cloudflare.com/ajax/libs/html2pdf.js/0.10.1/html2pdf.bundle.min.js'; document.head.appendChild(script); } function loadSecondFallback() { var script = document.createElement('script'); script.src = 'https://unpkg.com/html2pdf.js@0.10.1/dist/html2pdf.bundle.min.js'; document.head.appendChild(script); } </script> ``` Generated reports also load remote executable scripts at: - `scripts/gen_xhs_html.py:307-308` - `scripts/generate_rank_report.py:408` The Python dependency installation instruction at `SKILL.md:31` is open-ended: ```bash pip3 install "requests>=2.28.0" ``` ### Technical Analysis The generated reports execute JavaScript retrieved from third-party CDNs when the user opens them. The script tags do not use Subresource Integrity, and the fallback logic dynamically loads code from additional providers. The effective executable content can therefore change after the Skill package has been audited. The Python dependency declaration permits any future `requests` release satisfying the lower bound. It does not use an exact lockfile or package hashes. While the dependency name is legitimate and no malicious package was identified, the installation process is less reproducible and has unnecessary supply-chain exposure. This finding is a supply-chain hardening issue rather than proof that the referenced libraries are currently malicious. ### Attack Path 1. The user opens a generated report while connected to the network. 2. The browser requests JavaScript from one of the configured CDNs. 3. A ...[truncated 990 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Bundle audited JavaScript dependencies inside the Skill package. 2. If remote hosting is unavoidable, use immutable versioned assets with Subresource Integrity and `crossorigin="anonymous"`. 3. Remove multi-CDN fallback code unless every fallback has an approved integrity hash. 4. Add a restrictive Content Security Policy limiting script sources and outbound connections. 5. Pin Python dependencies to exact reviewed versions. 6. Use a lockfile with cryptographic hashes, such as a hashed requirements file. 7. Perform dependency vulnerability scanning during release builds. 8. Establish an explicit upgrade and re-audit process rather than accepting arbitrary future versions. 9. Make generated reports usable offline so opening a report does not retrieve new executable code. ]]>

SkillSpector

By NVIDIA
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • 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 (46)

Tainted flow: 'req' from os.environ.get (line 312, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Content
ssl_ctx.verify_mode = ssl.CERT_NONE

    try:
        with urllib.request.urlopen(req, context=ssl_ctx, timeout=30) as resp:
            result = json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        raise Exception(f"HTTP请求失败: {e.code}, {e.read().decode('utf-8', errors='replace')}")
Confidence
98% confidence
Finding
The request includes an API key sourced from the environment and is sent over HTTPS with TLS certificate validation explicitly disabled. That makes the credential and response vulnerable to man-in-the-middle interception or tampering, so the issue is not merely 'network output' but insecure authenticated exfiltration to a remote service. In this skill context, outbound API access is expected, but sending credentials with disabled verification makes it materially more dangerous.

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill declares no permissions, yet its instructions clearly require network access, reading environment variables and shell startup files, and writing local files. This mismatch can bypass user or platform expectations about what the skill is allowed to do and makes sensitive operations less visible during review.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The manifest says '严禁任何联网搜索', which implies offline-only or no external access, but the skill depends on external APIs, reads local credential files, writes caches/reports, and references third-party CDNs in generated HTML. This description-behavior mismatch can mislead users and reviewers about data exfiltration, local data access, and remote content loading.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The README says the skill must not perform any online search, yet it requires a live external Redfox API key and service. This inconsistency can mislead users and reviewers about the skill’s actual network behavior, causing them to expose credentials or permit data egress under false assumptions.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
Instructing the agent to scan shell startup files such as .zshrc and .bashrc to locate API keys expands access into sensitive local files unrelated to the immediate user request. Those files may contain other secrets, tokens, aliases, or personal configuration that the skill does not need to read wholesale.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The skill directs the host agent to create subscriptions using scheduler/calendar tooling, which goes beyond passive data retrieval into persistent system-side actions. That broadens the blast radius from a one-time query to ongoing automated behavior that could spam, leak search interests, or create unwanted tasks.

Description-Behavior Mismatch

High
Confidence
96% confidence
Finding
The template loads executable JavaScript from multiple third-party CDNs, which creates an outbound network dependency and a supply-chain trust boundary that conflicts with the skill's explicit prohibition on network connectivity. If any CDN content is tampered with, unavailable, or swapped, the rendered page can execute attacker-controlled script in the context of the generated report and export workflow.

Intent-Code Divergence

Medium
Confidence
88% confidence
Finding
The comments and user-facing error text explicitly assume network access (for refreshing, checking connectivity, and trying alternate CDNs), which indicates the template is designed to reach external resources despite the skill contract forbidding联网搜索/connectivity. This mismatch can cause operators to permit unexpected egress or deploy the skill in environments where hidden network dependence undermines policy and trust assumptions.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The workflow explicitly instructs the agent to persistently modify the user's shell or Windows environment to store API credentials and to verify them with shell commands. This creates a dangerous precedent for secret handling because it encourages the agent to alter long-lived local configuration and handle credentials directly, increasing the risk of credential exposure, unintended persistence, and unsafe system modification beyond the immediate task.

Context-Inappropriate Capability

Medium
Confidence
88% confidence
Finding
The skill adds a subscription-based timed push capability that goes beyond a simple on-demand content lookup workflow. Persistent or scheduled behavior increases risk because it can cause repeated unsolicited actions, expand data access over time, and blur the boundary between a one-time query skill and an automation agent.

Description-Behavior Mismatch

Medium
Confidence
76% confidence
Finding
The workflow narrows the skill to daily hot-note ranking retrieval while the manifest advertises broader capabilities such as inspiration aggregation, search, batch retrieval, rankings, and exports. This mismatch is dangerous because it can mislead users and higher-level orchestration about what the skill actually does, causing inappropriate invocation, overbroad trust, and insufficient review of hidden behaviors.

Description-Behavior Mismatch

High
Confidence
95% confidence
Finding
The document explicitly instructs use of a remote HTTPS API even though the skill metadata states '严禁任何联网搜索'. This creates a direct policy and trust-boundary violation: an agent following the reference would transmit user-derived queries or parameters to an external service, enabling unauthorized network access and possible data leakage.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
The embedded Python example contains executable guidance for making a live POST request to redfox.hk, directly contradicting the no-network restriction in the skill description. In agent settings, sample code often becomes implementation guidance, so this can induce real outbound requests, exfiltrate prompts/inputs, and bypass the operator's expectation that the skill will not access the network.

Context-Inappropriate Capability

Medium
Confidence
92% confidence
Finding
The script scans multiple shell profile files to locate an API key if the environment variable is absent. Reading unrelated local config files exceeds the minimum access needed for a content-crawling skill and can expose secrets from user files without clear consent, especially in an agent context where file access may be unexpected.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The script goes beyond reading an environment variable and actively scans local shell/profile files for REDFOX_API_KEY, then loads any discovered secret into the process environment. This expands the skill's access to local sensitive data unrelated to its stated content-analysis purpose and creates an unnecessary credential-harvesting capability if the skill is run in a broader host environment.

Description-Behavior Mismatch

Medium
Confidence
89% confidence
Finding
The script silently writes a markdown report and a JSON cache to the current working directory every time it succeeds, even though its primary advertised function is data retrieval and presentation. Unannounced persistence can leak retrieved data to other local users, leave sensitive business-research artifacts behind, and create side effects that callers did not consent to.

Intent-Code Divergence

Low
Confidence
80% confidence
Finding
The code comments state that HTML will not be generated until user confirmation, but the implementation still immediately writes markdown and cache files. This mismatch is dangerous because operators may rely on the comment or user-facing description and not realize that local persistence already occurred.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The script goes beyond using the declared environment variable and proactively reads local shell startup files to extract REDFOX_API_KEY. Accessing ~/.zshrc, ~/.bashrc, and similar files is unnecessary for the core ranking task and expands the skill's access to sensitive local configuration, which may expose secrets or normalize unauthorized secret discovery behavior.

Context-Inappropriate Capability

Medium
Confidence
97% confidence
Finding
The script reads multiple shell startup files to extract an API key, which expands its access into user-local configuration files unrelated to the immediate task. This is dangerous because it normalizes credential harvesting behavior and can expose secrets from local files that the user did not explicitly intend the skill to read.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The script scans user shell profile files to extract an API key, which is a credential-harvesting behavior broader than simple report generation. In an agent skill, this increases the blast radius because the code accesses sensitive local configuration files without explicit need or consent, and could expose secrets if repurposed or logged.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The generated HTML pulls JavaScript from external CDNs, which causes network access when the file is opened and breaks the stated prohibition on networked access. This also creates a supply-chain risk: whoever controls or tampers with those CDN assets can run arbitrary script in the viewer's browser context when the report is opened.

Description-Behavior Mismatch

High
Confidence
96% confidence
Finding
The fallback path explicitly imports and calls network-backed data retrieval functions when no cache is provided, which contradicts the skill metadata's hard requirement of '严禁任何联网搜索'. In an agent setting, this can cause unauthorized external requests, policy bypass, and unexpected data exfiltration or compliance violations, especially because the script is designed to be triggered automatically by user confirmation.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The generated HTML report is described as a local/offline artifact, but it embeds a third-party script from jsDelivr. Opening the report causes the browser to make an external network request, which can leak usage metadata and introduces a supply-chain risk if the CDN asset is changed, unavailable, or blocked.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The skill metadata explicitly says '严禁任何联网搜索', yet the script performs external HTTP requests to redfox.hk to fetch data. In this skill context, that mismatch is security-relevant because it causes undisclosed network access and remote data transfer despite a manifest-level prohibition.

Context-Inappropriate Capability

Medium
Confidence
97% confidence
Finding
Reading ~/.zshrc, ~/.bashrc, ~/.bash_profile, and ~/.profile to scrape credentials expands host-file access beyond what is needed for the skill's stated purpose. This pattern can unintentionally expose unrelated secrets or sensitive shell configuration and is especially risky in an agent setting where users may not expect local file inspection.

VirusTotal

VirusTotal findings are pending for this skill version.

View on VirusTotal

Static analysis

Detected: suspicious.exposed_secret_literal, suspicious.insecure_tls_verification

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/gen_xhs_html.py:68

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/xhs_daily_fetcher.py:66

HTTPS certificate verification is disabled.

Warn
Code
suspicious.insecure_tls_verification
Location
scripts/fetch_explosive_articles.py:272

HTTPS certificate verification is disabled.

Warn
Code
suspicious.insecure_tls_verification
Location
scripts/xiaohongshu-similar-account.py:310