Back to skill

Security audit

Global customs trade data aggregated across 220+ countries with integrated bulk search functionality for global B2B prospecting. Accelerate discovery ofverified genuine buyers and qualified international suppliers for export businesses. Dig into official import & export shipment records to pinpointproduct-matching importers and full historical transaction logs. Run targeted lookups filtered by company profiles, HS codes and product keywords. Trade teamsleverage verified real-world shipment intelligence to secure high-value B2B prospects and track competitors’ cross-border trading activity.

Security checks for vulnerabilities and agentic risk

Overview

The skill mostly matches its advertised trade-data purpose, but it should be reviewed because it handles API keys, paid API calls, contact data, and local persistence with weak safeguards.

Install only if you are comfortable giving this skill an UpKuaJing API key and letting it make paid API calls. Avoid printing the `.env` file in chat or logs, use a protected environment variable or locked-down secret file if possible, confirm costs before every query or contact lookup, and be careful with retrieved emails, phone numbers, social profiles, and any error reports you choose to send.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (5)

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/auth.py:60
Finding
API key stored without explicit restrictive permissions and partially disclosed<![CDATA[ ## Vulnerability Details **File Location**: `scripts/auth.py`, lines 60-74 **Vulnerability Type**: Plaintext credential storage with insufficient file-permission hardening **Risk Level**: Medium ### Vulnerable Code ```python # 确保 ~/.upkuajing 目录存在 try: UPKUAJING_DIR.mkdir(parents=True, exist_ok=True) except OSError as e: return { "success": False, "message": f"API密钥申请成功,但创建目录失败:{str(e)}。\n请手动创建目录 {UPKUAJING_DIR} 并设置环境变量 {API_KEY_ENV}。", "envFilePath": str(env_file) } # 保存到 .env 文件 try: with open(env_file, 'w', encoding='utf-8') as f: f.write(f"{API_KEY_ENV}={api_key}\n") ``` Related credential disclosure occurs at `scripts/auth.py`, lines 24-35: ```python if line.startswith(f'{API_KEY_ENV}='): existing_key = line.split('=', 1)[1].strip() if existing_key: return { "success": False, "message": f"错误: {env_file} 中已存在API密钥({existing_key[:10]}...)。\n如需重新申请,请先删除文件中的 {API_KEY_ENV} 后再运行此命令。", "envFilePath": str(env_file) } ``` The accompanying instructions at `SKILL.md`, lines 67-76, also encourage printing the credential file: ```bash cat ~/.upkuajing/.env ``` ### Technical Analysis The API key is legitimately required to authenticate requests to the declared UpKuaJing service, so reading the specific `UPKUAJING_API_KEY` environment variable is within the minimum privilege needed by the skill. However, the fallback storage implementation does not explicitly secure either the directory or the credential file. `Path.mkdir()` and `open(..., 'w')` rely on the process umask. Under a common umask of `022`, the directory can be created with mode `0755` and the file with mode `0644`, allowing other local users to traverse the directory and read the plaintext API key. The code does not check whether the existing path is a symbolic link, either, so execution in a locally compromised account may overwrite a link target. The write operation also truncates ...[truncated 1743 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Prefer an injected environment variable or operating-system credential store instead of a plaintext fallback file. 2. If file storage remains necessary: - Create `~/.upkuajing` with mode `0700`. - Create the credential file atomically with mode `0600`, such as through `os.open()` using `O_CREAT | O_EXCL | O_NOFOLLOW`. - Verify that the directory and file are owned by the current user and are not symbolic links. - Apply `chmod(0o600)` to an existing file before reading or writing it. 3. Update only the `UPKUAJING_API_KEY` entry while preserving unrelated file content. Use an atomic temporary-file replacement inside the protected directory. 4. Never include any API-key prefix in output. Report only that a key is already configured. 5. Replace the documented `cat` instruction with a non-disclosing existence check, for example checking whether the parsed variable is nonempty. 6. Clearly document key revocation and rotation procedures for users who suspect transcript or filesystem exposure. ]]>

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Unbounded dependency specification permits unreviewed future package versions<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt`, line 1 **Vulnerability Type**: Unpinned third-party dependency **Risk Level**: Medium ### Vulnerable Code ```text httpx>=0.23.0 ``` ### Technical Analysis The project accepts every future `httpx` release at or above version 0.23.0. Installation therefore is not reproducible and may resolve to code that was never tested or reviewed with this skill. No lock file, upper bound, or cryptographic hash is provided. This is particularly relevant because `httpx` runs in the same Python process that reads the API key and handles all network communication. A maliciously compromised upstream release, compromised package index, or incompatible future version would execute with the user's permissions during import or request processing. The package name is not a visible typosquat, and the audit found no evidence that the current `httpx` package is malicious. The issue is the absence of controls against future supply-chain changes. ### Attack Path 1. An attacker compromises a future release in the allowed dependency range or the package-distribution channel used by the installation environment. 2. A user follows `pip install -r requirements.txt`. 3. The resolver installs the compromised version because it satisfies the open-ended constraint. 4. The malicious package executes when imported by `common.py` or `version_check.py`. 5. Since execution occurs in-process, it can read `UPKUAJING_API_KEY`, inspect files available to the user, alter HTTP requests, or send data to an attacker-controlled service. The path depends on compromise of the dependency or distribution infrastructure; no direct remote-code download is implemented by the skill itself. ### Impact Assessment A compromised dependency would execute with the full privileges of the user running the skill. It could access the API key, task results, environment variables, and any other files readable by that account. It could also spoof API ...[truncated 102 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `httpx` to an explicitly reviewed version rather than using an unrestricted lower bound. 2. Generate a lock file containing transitive dependencies and cryptographic hashes, such as with `pip-compile --generate-hashes`. 3. Install with hash enforcement using `pip install --require-hashes`. 4. Use a trusted package index and disable unapproved extra indexes to reduce dependency-confusion exposure. 5. Automate vulnerability monitoring and deliberate dependency updates, testing each update before changing the lock file. 6. Run the skill in a least-privileged virtual environment or container with access only to the required credential and output paths. ]]>

other

Warning
Location
scripts/company_list_search.py:104
Finding
Billing confirmation policy is not enforced by executable code<![CDATA[ ## Vulnerability Details **File Location**: `scripts/company_list_search.py`, lines 104-111 **Vulnerability Type**: Missing technical authorization control for billed operations **Risk Level**: Medium ### Vulnerable Code ```python # 显示查询目标 print(f"开始查询:目标获取 {args.query_count} 条数据...") while total_retrieved < args.query_count: try: # 搜索当前批次 response = search_company_list(params, current_cursor) ``` The only technical restriction at lines 68-71 is a range check: ```python if args.query_count < 20 or args.query_count > 1000: print("错误:query_count 必须在 20 到 1000 之间", file=sys.stderr) sys.exit(1) ``` The equivalent behavior is present in `scripts/trade_list_search.py`, lines 99-106. Batch enrichment scripts similarly call billed endpoints immediately after checking only the maximum batch size, such as `scripts/company_get_contact.py`, lines 43-50: ```python company_ids = args.companyIds if len(company_ids) > 20: print(f"错误:每次最多处理20条数据", file=sys.stderr) sys.exit(1) response = get_contact_info(company_ids) ``` ### Technical Analysis `SKILL.md` states that every fee-incurring operation must wait for explicit user confirmation and specifically requires separate confirmation before list requests over 20 records or batch enrichment. The scripts do not represent or verify that consent. Supplying command-line arguments immediately starts authenticated, billed requests. For a list request, `query_count` can reach 1,000 in one invocation, resulting in repeated cursor requests until the target count is met. A caller may also continue a task with its task ID, allowing additional billed requests. The enrichment endpoints accept up to 20 IDs and charge by ID, but no confirmation flag, transaction token, budget ceiling, or interactive approval gate is enforced. Natural-language policy is useful for a cooperative agent but is not a security boundary. Accidental invocation, automation errors, or a compromised agent can bypass ...[truncated 1237 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Enforce confirmation in code for every billed operation, rather than relying solely on agent instructions. 2. Introduce a two-phase flow: - First calculate and display the exact call count or per-ID billing count and current pricing. - Then issue a short-lived approval token bound to the endpoint, parameters, maximum calls, and expiration time. - Require that token before making requests. 3. For direct CLI use, require an explicit flag such as `--confirm-billing` and an exact maximum-call or maximum-cost value. Interactive terminals should prompt separately. 4. Add hard per-invocation and daily budget limits, with a secure default below the maximum 1,000-record request. 5. Reconfirm continuation requests because they generate additional charges. 6. Stop immediately when accumulated cost reaches the approved limit, even if the requested record count has not been reached. 7. Log consent metadata without logging the API key or sensitive search results. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
scripts/error_report.py:20
Finding
Error-report context can transmit secrets or personal data without validation or redaction<![CDATA[ ## Vulnerability Details **File Location**: `scripts/error_report.py`, lines 20-31 **Vulnerability Type**: Unrestricted diagnostic-data transmission **Risk Level**: Low ### Vulnerable Code ```python # 自动填充 skillId 与 skillVersion(外部显式传入时以外部为准) params.setdefault('skillId', get_skill_name()) params.setdefault('skillVersion', get_skill_version()) # 验证必要参数 for field in ('skillId', 'skillVersion', 'requestId', 'requestPath', 'context'): if not params.get(field): print(f"错误:params中缺少{field}", file=sys.stderr) sys.exit(1) response = make_request('/agent/skill/error/report', params) return response ``` ### Technical Analysis The `context` field is forwarded directly to the authenticated remote error-report endpoint. The script checks only that the field is nonempty. It does not enforce the documented 2,000-character maximum, limit accepted fields, or redact common secret formats such as Bearer tokens, API keys, environment-variable values, email addresses, phone numbers, or customer data. The skill documentation appropriately requires user confirmation before reporting, and reports are sent to the same fixed HTTPS API host used for the declared service. Consequently, this is not evidence of covert exfiltration. Nevertheless, a user or agent may copy a raw exception, request object, stack trace, or response into `context` without realizing that it contains sensitive information. The API key itself is also sent in the Authorization header, as required for authentication. ### Attack Path 1. An API failure produces diagnostic text containing request parameters, personal information, or a credential. 2. The agent asks for reporting permission but does not separately identify every sensitive value embedded in the context. 3. The user approves reporting based on the general description. 4. `error_report.py` forwards the complete context to `/agent/skill/error/report`. 5. Sensitive content becomes stored or accessible in the platform's diagno ...[truncated 675 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Apply automatic redaction for API keys, Authorization headers, tokens, passwords, cookies, email addresses, phone numbers, and other sensitive fields before transmission. 2. Enforce the documented maximum context length and reject oversized reports. 3. Allowlist accepted report fields instead of forwarding the entire caller-provided dictionary. 4. Present the final redacted report body to the user and obtain approval for that exact content. 5. Prefer structured diagnostic codes over raw stack traces or full request and response bodies. 6. Document diagnostic retention, access, deletion, and privacy practices. 7. Add tests demonstrating that credential patterns cannot be transmitted through `context`. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
scripts/common.py:470
Finding
Search results and task metadata are persisted without explicit access controls<![CDATA[ ## Vulnerability Details **File Location**: `scripts/common.py`, lines 470-479 **Vulnerability Type**: Sensitive local data stored with umask-dependent permissions **Risk Level**: Low ### Vulnerable Code ```python def append_result_data(task_id: str, data_list: list) -> None: """ 追加结果数据到任务结果文件。 """ result_file = get_task_result_file(task_id) ensure_task_dir(task_id) with open(result_file, 'a', encoding='utf-8') as f: for item in data_list: f.write(json.dumps(item, ensure_ascii=False) + '\n') ``` Task metadata is stored similarly at lines 438-447: ```python def save_task_meta(task_id: str, meta: Dict[str, Any]) -> None: meta_file = get_task_meta_file(task_id) ensure_task_dir(task_id) with open(meta_file, 'w', encoding='utf-8') as f: json.dump(meta, f, ensure_ascii=False, indent=2) ``` ### Technical Analysis List-search responses are persisted under the skill's `task_data` directory. The files can contain trade records, company information, search criteria, server cursors, and request workflow metadata. Directories are created with `os.makedirs(..., exist_ok=True)` and files with ordinary `open()` calls, so permissions depend entirely on the process umask and the permissions of the project directory. Under a permissive installation or shared runtime, files may be readable by other local users or by unrelated processes sharing the workspace. No retention period, cleanup mechanism, encryption, or ownership verification is implemented. The UUID validation in `get_task_dir()` substantially mitigates caller-controlled path traversal, and no traversal exploit was identified. The remaining issue concerns confidentiality and retention of legitimately retrieved data. ### Attack Path 1. A user performs a company or trade-list search. 2. The script writes query metadata and response records beneath `task_data/<UUID>/`. 3. The runtime uses a permissive umask or the project workspace is shared ...[truncated 612 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Create the task-data root and per-task directories with mode `0700`. 2. Create metadata and result files with mode `0600`, using atomic creation and rejecting symbolic links. 3. Verify ownership and permissions before appending to existing files. 4. Define a retention period and securely delete expired tasks. 5. Provide a command that allows users to delete task data immediately after use. 6. Avoid storing unnecessary response fields, cursors, or personal information. 7. For shared environments, encrypt stored results with a user-specific key or place them in an operating-system-protected per-user data directory. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (43)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The finding indicates additional undeclared behaviors such as version checking against a remote service, reading and writing cache files under ~/.upkuajing, and parsing local skill metadata to emit upgrade notices. These actions are unrelated to the core advertised trade-search purpose and enlarge the attack surface by introducing hidden local-state and network interactions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding indicates additional undeclared behaviors such as version checking against a remote service, reading and writing cache files under ~/.upkuajing, and parsing local skill metadata to emit upgrade notices. These actions are unrelated to the core advertised trade-search purpose and enlarge the attack surface by introducing hidden local-state and network interactions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The finding indicates additional undeclared behaviors such as version checking against a remote service, reading and writing cache files under ~/.upkuajing, and parsing local skill metadata to emit upgrade notices. These actions are unrelated to the core advertised trade-search purpose and enlarge the attack surface by introducing hidden local-state and network interactions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The finding indicates additional undeclared behaviors such as version checking against a remote service, reading and writing cache files under ~/.upkuajing, and parsing local skill metadata to emit upgrade notices. These actions are unrelated to the core advertised trade-search purpose and enlarge the attack surface by introducing hidden local-state and network interactions.

Credential Access

High
Category
Privilege Escalation
Content
This skill requires an API key. The API key is stored in the `~/.upkuajing/.env` file:
```bash
cat ~/.upkuajing/.env
```
**Example file content**:
```
Confidence
97% confidence
Finding
The skill explicitly instructs reading a local .env file containing the API key, which is credential access to a sensitive secret stored on disk. In a skill context, direct secret-file inspection is dangerous because it normalizes exposing credentials to the agent workflow and increases risk of accidental disclosure, misuse, or propagation into logs or outputs.

Credential Access

High
Category
Privilege Escalation
Content
### **API Key Not Set**
First check if the `~/.upkuajing/.env` file has UPKUAJING_API_KEY;
If UPKUAJING_API_KEY is not set, prompt the user to choose:
1. User has one: User provides it (manually add to ~/.upkuajing/.env file)
2. User doesn't have one: You can apply using the interface (`auth.py --new_key`), the new key will be automatically saved to ~/.upkuajing/.env
Wait for user selection;
Confidence
96% confidence
Finding
The workflow tells the agent to check for UPKUAJING_API_KEY in ~/.upkuajing/.env and, if absent, obtain and save a new key automatically. This combines credential discovery and credential persistence in local storage, creating a sensitive secret-handling path that could be abused or could expose keys through file access, backups, or other processes.

Credential Access

High
Category
Privilege Escalation
Content
First check if the `~/.upkuajing/.env` file has UPKUAJING_API_KEY;
If UPKUAJING_API_KEY is not set, prompt the user to choose:
1. User has one: User provides it (manually add to ~/.upkuajing/.env file)
2. User doesn't have one: You can apply using the interface (`auth.py --new_key`), the new key will be automatically saved to ~/.upkuajing/.env
Wait for user selection;

### **Account Top-up**
Confidence
96% confidence
Finding
This step again directs access to the local .env file and automatic saving of a newly issued API key, reinforcing insecure local credential handling. Repeated local secret-file use increases the chance of exfiltration, accidental display, or unauthorized reuse by other skills or processes on the same system.

Credential Access

High
Category
Privilege Escalation
Content
"""
    申请新的 API 密钥。
    """
    # 检查是否已存在 .env 文件和 API key
    env_file = UPKUAJING_ENV_FILE

    if env_file.exists():
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""
    申请新的 API 密钥。
    """
    # 检查是否已存在 .env 文件和 API key
    env_file = UPKUAJING_ENV_FILE

    if env_file.exists():
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""
    申请新的 API 密钥。
    """
    # 检查是否已存在 .env 文件和 API key
    env_file = UPKUAJING_ENV_FILE

    if env_file.exists():
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""
    申请新的 API 密钥。
    """
    # 检查是否已存在 .env 文件和 API key
    env_file = UPKUAJING_ENV_FILE

    if env_file.exists():
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""
    申请新的 API 密钥。
    """
    # 检查是否已存在 .env 文件和 API key
    env_file = UPKUAJING_ENV_FILE

    if env_file.exists():
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""
    申请新的 API 密钥。
    """
    # 检查是否已存在 .env 文件和 API key
    env_file = UPKUAJING_ENV_FILE

    if env_file.exists():
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"envFilePath": str(env_file)
        }

    # 保存到 .env 文件
    try:
        with open(env_file, 'w', encoding='utf-8') as f:
            f.write(f"{API_KEY_ENV}={api_key}\n")
Confidence
78% confidence
Finding
This line persists an issued API key to a .env file in plaintext. Plaintext credential storage is dangerous on multi-user systems, synced home directories, CI runners, or environments where .env files are commonly ingested by tooling, increasing the chance of secret disclosure if the filesystem is accessed or the file is accidentally committed.

Credential Access

High
Category
Privilege Escalation
Content
API_BASE_URL = "https://openapi.upkuajing.com"
API_KEY_ENV = "UPKUAJING_API_KEY"
UPKUAJING_DIR = Path.home() / '.upkuajing'
UPKUAJING_ENV_FILE = UPKUAJING_DIR / '.env'
UPKUAJING_LOGS_DIR = UPKUAJING_DIR / 'logs'

# 日志开关
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Lp3

Medium
Category
MCP Least Privilege
Confidence
91% confidence
Finding
The skill declares capabilities to read environment variables, access local files, write credentials, and make network calls, but it does not define any explicit tool scope or permissions boundary. That creates an over-privileged and opaque execution model where sensitive operations like credential handling and outbound requests can occur without clear policy restriction or user visibility.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The trigger phrases are very broad and overlap with ordinary business research requests, which increases the chance of unintended invocation. In a skill that can access credentials, contact data, and fee-incurring APIs, ambiguous activation makes misuse and surprise side effects more likely.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill instructs retrieval of company contact information but does not present any privacy warning, purpose limitation, or consent language. Because contact data can be sensitive and used for outreach, omission of such warnings increases the risk of privacy-invasive or non-compliant use.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
The note 'Product names and industry names must be in English' imposes a language requirement as a blanket rule. The file does not provide user opt-in, alternatives, or a documented justification for this locale constraint, so it violates the language/locale policy criterion.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The documentation describes an API that returns emails, phone numbers, social profiles, and websites for company IDs, but it provides no privacy notice, lawful-use constraints, retention guidance, or handling requirements for this contact data. In a trade-intelligence skill whose stated purpose includes finding buyers and monitoring competitors, this omission increases the risk of misuse for unsolicited outreach, profiling, or non-compliant processing of personal data.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The document explicitly instructs callers to send request parameters, response data, and exception context to an error-reporting endpoint. Even though it says sensitive fields will be automatically redacted, the reference does not define what is considered sensitive, does not require minimization, and does not warn operators against including customer trade queries, company data, credentials, or stack traces containing secrets. In a skill that handles global trade-search activity, this can lead to unnecessary collection and transmission of user/business-sensitive data to a secondary endpoint.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The file adds account lifecycle and billing capabilities (API key issuance, balance lookup, recharge order creation) that exceed the declared trade-data search purpose of the skill. This increases the privilege and financial attack surface: a user invoking what appears to be a search skill can trigger credential provisioning and payment-related flows, which is risky in an agent ecosystem where scope creep can surprise users or higher-level orchestrators.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
pass  # 如果读取失败,继续执行

    # 不需要认证申请新密钥
    response = make_request('/agent/auth/create', {}, require_auth=False)

    # 检查是否申请成功
    if response.get('code') != 0:
Confidence
75% confidence
Finding
Tool defaults are unsafe or overly permissive (e.g. disabled TLS verification, no authentication, world-writable permissions). Unsafe defaults widen the attack surface.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
pass  # 如果读取失败,继续执行

    # 不需要认证申请新密钥
    response = make_request('/agent/auth/create', {}, require_auth=False)

    # 检查是否申请成功
    if response.get('code') != 0:
Confidence
80% confidence
Finding
Tool defaults are unsafe or overly permissive (e.g. disabled TLS verification, no authentication, world-writable permissions). Unsafe defaults widen the attack surface.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The script automatically writes a newly issued API key to a local .env file without an interactive confirmation step, permission hardening, or warning before persisting credentials. This can lead to unintended credential storage on shared machines, developer workspaces, or agent runtimes where other processes may later read the file.

Static analysis

Detected: suspicious.exposed_secret_literal

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/common.py:196

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
SKILL.md:88