Linkfox 亚马逊选品

• Outcome: Review
• Latest audit: Sep 16, 2026 · 10:24 AM UTC
• Version: 1.2.3

Overview

The skill mostly matches its Amazon product research purpose, but it handles account credentials and remote endpoints too broadly for automatic installation without review.

Review this skill before installing. Use it only in an environment where LinkFox endpoint variables cannot be changed by untrusted users, avoid custom gateway URLs unless you trust them, treat generated API keys as secrets, and prefer a secret manager over shell-profile storage. Be aware it writes full API responses under a local linkfox directory and may create payment/order QR files during billing flows.

A.I.G

Vulnerability Patterns

• Skill Instruction Hijacking: Alters the agent's session goals or safety constraints when the skill loads
• Insecure Dependencies: Introduces malicious components through unsafe dependency sources
• Insecure Skill Coding Practices: Finds exploitable flaws such as hardcoded secrets or command injection
• Agent Memory Poisoning: Writes attacker-controlled rules into memory that affect later sessions
• Remote Payload Retrieval and Execution: Fetches external code whose behavior can change after review

Findings (6)

T09 · Insecure Skill Coding Practices

Error

• Location: scripts/amazon_search.py:37

Finding

Credentials and Login Data Can Be Redirected to Arbitrary Network Destinations

Content

View full analysis

str: """Use LINKFOX_TOOL_GATEWAY first, falling back to the production gateway.""" return (os.environ.get("LINKFOX_TOOL_GATEWAY") or "https://tool-gateway.linkfox.com").rstrip("/") def get_api_key(): key = (os.environ.get("LINKFOX_AGENT_API_KEY") or os.environ.get("LINKFOXAGENT_API_KEY")) if not key: print("API Key is not configured", file=sys.stderr) sys.exit(1) return key def call_api(params): api_url = get_api_url() api_key = get_api_key() data = json.dumps(params).encode("utf-8") headers = { "Authorization": api_key, "Content-Type": "application/json", "User-Agent": "LinkFox-Skill/2.0", "SESSION_ID": os.environ.get("SESSION_ID", ""), "MODE_ID": os.environ.get("MODE_ID", ""), "APP_NAME": os.environ.get("APP_NAME", ""), } req = Request(api_url, data=data, headers=headers, method="POST") with urlopen(req, timeout=150) as response: return json.loads(response.read().decode("utf-8")) ``` Onboarding endpoints are similarly configurable: ```python def _agent_base() -> str: return _env_base( "LINKFOX_AGENT_API_URL", "https://tool-gateway.linkfox.com", "LINKFOX_TOOL_GATEWAY", ) def _login_base() -> str: return _env_base("LINKFOX_LOGIN_API_URL", "https://api.linkfox.com") def _agent_user_base() -> str: return _env_base( "LINKFOX_AGENT_USER_API_URL", "https://agent-api.linkfox.com", ) ``` Sensitive authentication data is sent to those destinations: ```python def _login_by_token(access_token: str, refresh ...[truncated 2311 chars]

Remediation

View remediation

other

Note

• Location: scripts/amazon_search.py:63

Finding

Unnecessary Host and Session Metadata Is Transmitted with Every API Query

Content

View full analysis

Remediation

View remediation

T09 · Insecure Skill Coding Practices

Warning

• Location: scripts/amazon_search.py:250

Finding

Path Traversal Through an Unvalidated Session Identifier

Content

View full analysis

str: """Use SESSION_ID first; otherwise generate a stable identifier.""" env = os.environ.get("SESSION_ID") if env: return env.strip() if "_auto" not in _SESSION_CACHE: _SESSION_CACHE["_auto"] = ( time.strftime("%H%M%S", time.localtime(ts)) + "-" + secrets.token_hex(3) ) return _SESSION_CACHE["_auto"] def _ensure_session(ts: float) -> tuple[str, str]: """Return the LinkFox root and session directory.""" date_str = time.strftime("%Y-%m-%d", time.localtime(ts)) sid = _session_id(ts) root = _linkfox_root() session_dir = os.path.join(root, date_str, sid) os.makedirs(session_dir, exist_ok=True) _ensure_meta(root, session_dir, date_str, sid, ts) return root, session_dir ``` A similar construction is used by onboarding: ```python def session_dir() -> str: ts = time.time() sid = (os.environ.get("SESSION_ID") or "").strip() or ( time.strftime("%H%M%S", time.localtime(ts)) + "-" + secrets.token_hex(3) ) path = os.path.join( _linkfox_root(), time.strftime("%Y-%m-%d", time.localtime(ts)), sid, ) os.makedirs(path, exist_ok=True) return path ``` ### Technical Analysis `SESSION_ID` is treated as a trusted path component. The code does not reject: - Absolute paths - `..` traversal components - Directory separators - Platform-specific path prefixes - Symlink-mediated escapes On POSIX systems, an absolute final component passed to `os.path.join` discards preceding components. Traversal components can similarly cause the resolved directory to leave the intended date and LinkFox roots. The ordinary scripts then persist complete API responses and metadata b ...[truncated 1043 chars]

Remediation

View remediation

T09 · Insecure Skill Coding Practices

Warning

• Location: scripts/onboarding.py:483

Finding

Generated API Keys Are Printed and Recommended for Plaintext Shell Persistence

Content

View full analysis

dict: masked = _mask_phone(phone) if not re.fullmatch(r"\d{11}", phone): return { "error": f"login: invalid phone format: {phone}", "phone": masked, } if not re.fullmatch(r"\d{4,8}", code): return { "error": f"login: invalid verification-code format: {code}", "phone": masked, } lg = _login_v3(phone, code, channel) if "error" in lg: return {"error": lg["error"], "phone": masked} info = _fetch_user_info_v3(lg["access_token"], lg["user_id"]) if "error" in info: return {"error": info["error"], "phone": masked} tok = _get_or_generate_api_token( lg["access_token"], lg["user_id"], info["group_id"], ) if "error" in tok: return {"error": tok["error"], "phone": masked} return { "api_key": tok["api_key"], "phone": masked, "group_id": info["group_id"], "member_id": info["member_id"], "source": tok["source"], "nick_name": lg.get("nick_name", ""), "team_name": info.get("team_name", ""), "is_new_user": lg.get("is_new_user", False), } def _emit(obj: dict) -> None: print(json.dumps(obj, ensure_ascii=False, indent=2)) ``` The accompanying setup instructions recommend commands equivalent to: ```shell setx LINKFOX_AGENT_API_KEY "" echo 'export LINKFOX_AGENT_API_KEY=""' >> ~/.zshrc echo 'export LINKFOX_AGENT_API_KEY=""' >> ~/.bashrc ``` ### Technical Analysis The onboarding command returns the complete API key in a JSON object and prints that object to standard output. In an Agent environment, standard output may be cap ...[truncated 1269 chars]

Remediation

View remediation

T08 · Insecure Dependencies

Warning

• Location: references/linkfox-amazon-search.md:137

Finding

Fallback Skill Installation Uses an Unpinned Remote Archive Without Integrity Verification

Content

View full analysis

Remediation

View remediation

T01 · Skill Instruction Hijacking

Note

• Location: SKILL.md:263

Finding

Skill Text Unconditionally Asserts the Host Agent Identity

Content

View full analysis

Remediation

View remediation

SkillSpector

Vulnerability Patterns

• Taint Tracking: Direct Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
• Prompt Injection: Instruction Override, Hidden Instructions, Exfiltration Commands
• Data Exfiltration: External Transmission, Env Variable Harvesting, File System Enumeration
• Privilege Escalation: Excessive Permissions, Sudo/Root Execution, Credential Access
• Supply Chain: Unpinned Dependencies, External Script Fetching, Obfuscated Code

Findings (238)

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

Critical

• Category: Data Flow
• Confidence: 93% confidence

Finding

The request sent to the remote API includes environment-derived values such as LINKFOX_TOOL_GATEWAY, SESSION_ID, MODE_ID, APP_NAME, and the API key in the Authorization header. Because LINKFOX_TOOL_GATEWAY can redirect traffic to an arbitrary host and metadata is transmitted automatically, a compromised or attacker-controlled environment can cause sensitive request data and credentials to be exfiltrated over the network.

Content

Scanner excerpt · scripts/amazon_alexa_search.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 96% confidence

Finding

The request sent via urlopen includes multiple headers sourced directly from environment variables, and the destination host is also overrideable via LINKFOX_TOOL_GATEWAY. In an agent/runtime context where environment variables may be influenced by upstream tooling or untrusted configuration, this can exfiltrate sensitive session metadata and the API key to an attacker-controlled endpoint via SSRF-style redirection.

Content

Scanner excerpt · scripts/amazon_opportunity_screener.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 97% confidence

Finding

The request sent via urlopen includes headers populated directly from environment variables, and the destination base URL is also environment-controlled through LINKFOX_TOOL_GATEWAY. This creates a server-side request and credential exfiltration risk: if an attacker can influence the environment, they can redirect the request to an attacker-controlled host and cause the API key and session metadata to be transmitted there.

Content

Scanner excerpt · scripts/amazon_product_detail.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 93% confidence

Finding

The outbound request includes multiple headers populated directly from environment variables, and the destination base URL is also overrideable via LINKFOX_TOOL_GATEWAY. In an agent/runtime context where env can be influenced by other components, this can exfiltrate the API key and request data to an attacker-controlled endpoint or leak untrusted metadata off-host.

Content

Scanner excerpt · scripts/amazon_reviews.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 95% confidence

Finding

The request ultimately uses a gateway base URL taken from the environment variable LINKFOX_TOOL_GATEWAY, and also forwards several environment-derived headers. In an agent/runtime context, allowing untrusted environment configuration to control the outbound destination can exfiltrate the API key in the Authorization header to an attacker-controlled server, making this effectively an SSRF-plus-secret-leak issue rather than a harmless configuration feature.

Content

Scanner excerpt · scripts/amazon_search_by_image.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 96% confidence

Finding

The script allows the destination host to be overridden via the LINKFOX_TOOL_GATEWAY environment variable and then sends the API key plus SESSION_ID, MODE_ID, APP_NAME, and request data to that URL. In an agent/runtime setting where environment can be influenced, this enables silent exfiltration of credentials and user/task data to an attacker-controlled endpoint.

Content

Scanner excerpt · scripts/jiimore_get_niche_info.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 98% confidence

Finding

The request URL is derived from LINKFOX_TOOL_GATEWAY, an environment variable, and then used by urlopen along with the Authorization API key and other environment-derived headers. If an attacker can influence the environment, they can redirect the request to an arbitrary host and exfiltrate credentials, session identifiers, and request data; in an agent/runtime context, that is a real SSRF-plus-secret-leak risk.

Content

Scanner excerpt · scripts/jiimore_get_niche_review.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

The request sent via urlopen includes multiple headers populated directly from environment variables, and the destination host is also overridable through LINKFOX_TOOL_GATEWAY. In this skill context, that means a caller-controlled or compromised execution environment can exfiltrate the API key and session metadata to an attacker-controlled endpoint, making this a real SSRF/credential-leak style issue rather than a harmless configuration feature.

Content

Scanner excerpt · scripts/jiimore_product_discovery.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 94% confidence

Finding

The request sent via urlopen includes security-sensitive headers derived directly from environment variables, including Authorization and routing metadata, and the destination base URL is also overridable via LINKFOX_TOOL_GATEWAY. In an untrusted or multi-tenant agent environment, an attacker who can influence environment variables can redirect requests to an attacker-controlled host and exfiltrate API keys and session metadata.

Content

Scanner excerpt · scripts/junglescout_keyword_by_asin.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 97% confidence

Finding

The request sent to urlopen includes headers and routing data derived directly from environment variables, including LINKFOX_TOOL_GATEWAY and authentication/session-related values. If an attacker can influence the process environment, they can redirect requests to an attacker-controlled host and exfiltrate the API key and session metadata via the Authorization and custom headers.

Content

Scanner excerpt · scripts/junglescout_keyword_by_keyword.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 94% confidence

Finding

The request sent via urlopen includes multiple values sourced from environment variables, and the destination base URL is also overridable through LINKFOX_TOOL_GATEWAY. In an agent/runtime environment, attackers or untrusted wrappers can manipulate these environment variables to exfiltrate API keys, session identifiers, and user query data to an attacker-controlled endpoint, creating a server-side data exfiltration risk.

Content

Scanner excerpt · scripts/junglescout_product_database.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 95% confidence

Finding

The script builds outbound request headers from environment variables, including a user-controlled gateway base URL and session/app metadata, then sends them directly via urlopen. If an attacker can influence LINKFOX_TOOL_GATEWAY or the execution environment, they can redirect requests and exfiltrate API keys, request contents, and session metadata to an attacker-controlled endpoint.

Content

Scanner excerpt · scripts/keepa_product_detail.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 96% confidence

Finding

The request sent via urlopen includes attacker-influenced values from environment variables, most importantly the gateway base URL and authorization/session headers. In an agent or CI context, a malicious caller can override LINKFOX_TOOL_GATEWAY to exfiltrate the API key and request payload to an arbitrary host, turning this script into a credential and data exfiltration primitive.

Content

Scanner excerpt · scripts/keepa_product_history.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 95% confidence

Finding

The script allows base URLs for login and agent-user APIs to be overridden by environment variables, then sends sensitive data such as phone numbers, SMS codes, access tokens, refresh tokens, and generated API keys to those endpoints via requests.post. If an attacker can influence the environment, they can redirect authentication traffic to a malicious server and capture credentials and tokens, making this a real exfiltration risk rather than a benign configuration pattern.

Content

Scanner excerpt · scripts/onboarding.py (reported line 196)May include surrounding context.

python

except RuntimeError as e:
        return {"_error": str(e)}
    try:
        r = requests.post(url, json=body or {}, headers=headers, timeout=timeout)
        return r.json()
    except Exception as e:
        body_text = ""

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

Critical

• Category: Data Flow
• Confidence: 93% confidence

Finding

The gateway URL is derived from environment variables and then used to construct urllib requests carrying the Authorization header with the LinkFox API key and order/account operations. An attacker who can set the environment can redirect these authenticated requests to an attacker-controlled endpoint, exposing API credentials and potentially enabling account, billing, or order abuse.

Content

Scanner excerpt · scripts/onboarding.py (reported line 246)May include surrounding context.

python

headers["Content-Type"] = "application/json"
        req = Request(url, method=method, data=body_bytes, headers=headers)
        try:
            with urlopen(req, timeout=30) as resp:
                return json.loads(resp.read().decode())
        except urllib.error.HTTPError as e:
            status = e.code

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

Critical

• Category: Data Flow
• Confidence: 93% confidence

Finding

The request sent to urlopen includes headers derived from environment variables, and the destination host is also configurable via LINKFOX_TOOL_GATEWAY. In an agent/runtime context where untrusted users or upstream workflows can influence environment variables, this can leak the API key and session metadata to an attacker-controlled endpoint, creating a server-side request forgery and credential exfiltration path.

Content

Scanner excerpt · scripts/sellersprite_competitor_lookup.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

The request destination is influenced by environment-controlled configuration via LINKFOX_TOOL_GATEWAY, and the request includes a sensitive Authorization header from environment variables. In an agent or multi-tenant runtime where environment variables can be set by untrusted parties, this can redirect authenticated traffic and metadata headers (including SESSION_ID/MODE_ID/APP_NAME) to an attacker-controlled endpoint, causing credential exfiltration and unauthorized API use.

Content

Scanner excerpt · scripts/sellersprite_market_statistics.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 97% confidence

Finding

The request sent to the remote gateway includes environment-derived identifiers and credentials, and the destination base URL is itself overridable via the LINKFOX_TOOL_GATEWAY environment variable. That means an attacker who can influence the execution environment can redirect requests, exfiltrate the API key and session metadata, or cause sensitive product-search inputs to be posted to an untrusted endpoint.

Content

Scanner excerpt · scripts/sellersprite_product_search.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

The outbound request includes multiple headers populated directly from environment variables, and the destination host is also overridable via LINKFOX_TOOL_GATEWAY. In an agent or multi-tenant execution environment, attacker-controlled environment data can cause this skill to send sensitive metadata and the API key to an arbitrary endpoint, creating a server-side request forgery and credential exfiltration path.

Content

Scanner excerpt · scripts/sif_asin_keywords.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 91% confidence

Finding

The outbound request includes headers populated directly from environment variables, and the destination base URL is also taken from LINKFOX_TOOL_GATEWAY without validation. In a hostile or untrusted execution environment, an attacker who can influence these variables can redirect requests and exfiltrate the API key and session metadata to an attacker-controlled server, causing credential leakage and unauthorized data disclosure.

Content

Scanner excerpt · scripts/sif_asin_summary.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/aba_query.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/amazon_opportunity_report.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/amazon_search.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/jiimore_get_niche_info_by_keyword.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

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

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/jiimore_page_asins_by_asin.py (reported line 79)May include surrounding context.

python

method="POST",
    )
    try:
        with urlopen(req, timeout=150) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""

Static analysis

No suspicious patterns detected.