The skill is Datadata-focused and I found no prompt injection or hidden payloads. Most static alerts are false positives from markdown backticks, Chinese documentation, placeholders, and Datadata resource IDs. Confirmed issues involve authenticated network use, local credential storage, API key exposure in device-flow output, broad default permissions, and local result-file writes.
The device-flow completion path returns the full API key in command output, and a fallback path prints the key if saving fails. Command output can persist in logs or agent transcripts.
The code explicitly includes the key in printed output fields and fallback messages. This is direct credential disclosure, even though it occurs during a legitimate auth flow.
The default device-flow key requests read, scan, replace-file, query execution, result access, and data-space write permissions for every authorization. Read-only workflows receive write-capable credentials.
The permission list is hardcoded and reused for both device-flow entry points. It includes write and replace-file scopes beyond many documented read-only tasks.
The result download command writes to a user-supplied output path or a default path built from the execution ID. The execution ID is not sanitized before becoming part of a filesystem path.
The code joins the execution ID into a temp filename and then opens the resolved path for writing. Legitimate IDs are likely safe, but the CLI does not enforce that format.
Capability review items (46)
These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.
The API reference example prints the full API key after device-flow token exchange. This can teach users or agents to leak a newly issued credential into logs or chat transcripts.
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
5. API Key 自动保存到 `~/.config/datadata/datadata-api-skills/config.json`(Unix 权限 0600),后续直接使用,无需重复授权
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
The script stores Datadata authentication material under a hidden user config directory. The Unix permission hardening helps, but persistent local secret storage remains sensitive.
The script stores Datadata authentication material under a hidden user config directory. The Unix permission hardening helps, but persistent local secret storage remains sensitive.
with open(API_KEY_CONFIG_FILE, "w", encoding="utf-8") as fh:
The script stores Datadata authentication material under a hidden user config directory. The Unix permission hardening helps, but persistent local secret storage remains sensitive.
default=os.environ.get("DATADATA_API_KEY") or load_api_key_from_config() or "",
The script reads DATADATA_API_KEY from the environment and uses it for authenticated requests. Environment-based secret access is expected but sensitive.
The script reads DATADATA_API_KEY from the environment and uses it for authenticated requests. Environment-based secret access is expected but sensitive.
default=os.environ.get("DATADATA_API_KEY") or load_api_key_from_config() or "",
The script reads DATADATA_API_KEY from the environment and treats it as an authentication secret. This is legitimate configuration but still secret access.
The script places the Datadata API key into request headers for outbound HTTP calls. This is required for authentication, but it is sensitive if the base URL is misconfigured.
The script places the Datadata API key into request headers for outbound HTTP calls. This is required for authentication, but it is sensitive if the base URL is misconfigured.
The script places the Datadata API key into request headers for outbound HTTP calls. This is required for authentication, but it is sensitive if the base URL is misconfigured.
with open(API_KEY_CONFIG_FILE, "r", encoding="utf-8") as fh:
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
api_key = config.get("apiKey") if isinstance(config, dict) else None
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
with open(API_KEY_CONFIG_FILE, "w", encoding="utf-8") as fh:
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script can print or return the full Datadata API key in command output. That exposes a reusable credential to terminal logs, chat transcripts, or command capture.
The script can print or return the full Datadata API key in command output. That exposes a reusable credential to terminal logs, chat transcripts, or command capture.
The script can print or return the full Datadata API key in command output. That exposes a reusable credential to terminal logs, chat transcripts, or command capture.
The script reads DATADATA_API_KEY from the environment and treats it as an authentication secret. This is legitimate configuration but still secret access.
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
5. API Key 自动保存到 `~/.config/datadata/datadata-api-skills/config.json`(Unix 权限 0600),后续直接使用,无需重复授权
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
with open(DEVICE_FLOW_STATE_FILE, "w", encoding="utf-8") as fh:
The script creates or writes Datadata config, device-flow state, or result files on disk. This is intended behavior, but it can persist sensitive data or overwrite files if misused.
The script creates or writes Datadata config, device-flow state, or result files on disk. This is intended behavior, but it can persist sensitive data or overwrite files if misused.
The script creates or writes Datadata config, device-flow state, or result files on disk. This is intended behavior, but it can persist sensitive data or overwrite files if misused.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The result download path is built in the system temp directory by default. This is expected for exports, but it still writes data artifacts to local storage.
The script reads DATADATA_BASE_URL from the environment, which controls the remote endpoint. This is intended for configuration, but a bad value can redirect requests.
The skill is Datadata-focused and I found no prompt injection or hidden payloads. Most static alerts are false positives from markdown backticks, Chinese documentation, placeholders, and Datadata resource IDs. Confirmed issues involve authenticated network use, local credential storage, API key exposure in device-flow output, broad default permissions, and local result-file writes.
The device-flow completion path returns the full API key in command output, and a fallback path prints the key if saving fails. Command output can persist in logs or agent transcripts.
The code explicitly includes the key in printed output fields and fallback messages. This is direct credential disclosure, even though it occurs during a legitimate auth flow.
The default device-flow key requests read, scan, replace-file, query execution, result access, and data-space write permissions for every authorization. Read-only workflows receive write-capable credentials.
The permission list is hardcoded and reused for both device-flow entry points. It includes write and replace-file scopes beyond many documented read-only tasks.
The result download command writes to a user-supplied output path or a default path built from the execution ID. The execution ID is not sanitized before becoming part of a filesystem path.
The code joins the execution ID into a temp filename and then opens the resolved path for writing. Legitimate IDs are likely safe, but the CLI does not enforce that format.
Capability review items (46)
These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.
The API reference example prints the full API key after device-flow token exchange. This can teach users or agents to leak a newly issued credential into logs or chat transcripts.
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
5. API Key 自动保存到 `~/.config/datadata/datadata-api-skills/config.json`(Unix 权限 0600),后续直接使用,无需重复授权
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
The script stores Datadata authentication material under a hidden user config directory. The Unix permission hardening helps, but persistent local secret storage remains sensitive.
The script stores Datadata authentication material under a hidden user config directory. The Unix permission hardening helps, but persistent local secret storage remains sensitive.
with open(API_KEY_CONFIG_FILE, "w", encoding="utf-8") as fh:
The script stores Datadata authentication material under a hidden user config directory. The Unix permission hardening helps, but persistent local secret storage remains sensitive.
default=os.environ.get("DATADATA_API_KEY") or load_api_key_from_config() or "",
The script reads DATADATA_API_KEY from the environment and uses it for authenticated requests. Environment-based secret access is expected but sensitive.
The script reads DATADATA_API_KEY from the environment and uses it for authenticated requests. Environment-based secret access is expected but sensitive.
default=os.environ.get("DATADATA_API_KEY") or load_api_key_from_config() or "",
The script reads DATADATA_API_KEY from the environment and treats it as an authentication secret. This is legitimate configuration but still secret access.
The script places the Datadata API key into request headers for outbound HTTP calls. This is required for authentication, but it is sensitive if the base URL is misconfigured.
The script places the Datadata API key into request headers for outbound HTTP calls. This is required for authentication, but it is sensitive if the base URL is misconfigured.
The script places the Datadata API key into request headers for outbound HTTP calls. This is required for authentication, but it is sensitive if the base URL is misconfigured.
with open(API_KEY_CONFIG_FILE, "r", encoding="utf-8") as fh:
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
api_key = config.get("apiKey") if isinstance(config, dict) else None
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
with open(API_KEY_CONFIG_FILE, "w", encoding="utf-8") as fh:
The script reads or writes a persisted Datadata API key in the local config file. Local persistence is useful but creates a credential exposure surface.
The script can print or return the full Datadata API key in command output. That exposes a reusable credential to terminal logs, chat transcripts, or command capture.
The script can print or return the full Datadata API key in command output. That exposes a reusable credential to terminal logs, chat transcripts, or command capture.
The script can print or return the full Datadata API key in command output. That exposes a reusable credential to terminal logs, chat transcripts, or command capture.
The script reads DATADATA_API_KEY from the environment and treats it as an authentication secret. This is legitimate configuration but still secret access.
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
5. API Key 自动保存到 `~/.config/datadata/datadata-api-skills/config.json`(Unix 权限 0600),后续直接使用,无需重复授权
The CLI documentation describes persistent API key storage under a hidden config path. The documented 0600 permission reduces exposure, but this is still sensitive filesystem behavior.
with open(DEVICE_FLOW_STATE_FILE, "w", encoding="utf-8") as fh:
The script creates or writes Datadata config, device-flow state, or result files on disk. This is intended behavior, but it can persist sensitive data or overwrite files if misused.
The script creates or writes Datadata config, device-flow state, or result files on disk. This is intended behavior, but it can persist sensitive data or overwrite files if misused.
The script creates or writes Datadata config, device-flow state, or result files on disk. This is intended behavior, but it can persist sensitive data or overwrite files if misused.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The Python CLI performs real HTTP requests to the configured Datadata base URL. This is intended behavior, but it transmits queries, metadata requests, and authenticated headers over the network.
The result download path is built in the system temp directory by default. This is expected for exports, but it still writes data artifacts to local storage.
The script reads DATADATA_BASE_URL from the environment, which controls the remote endpoint. This is intended for configuration, but a bad value can redirect requests.
Static command-execution and weak-crypto alerts are mostly false positives from Markdown backticks, SQL examples, and ordinary text. The real risks are broad Datadata API access, API-key persistence, remote SQL execution, data-space writes, network requests, and local result-file writes; no prompt injection or confirmed malicious intent was found.
The skill supports creating tables, inserting rows, and dropping data-space tables through authenticated API calls. These are legitimate commands, but marketplace users need a clear warning because mistaken datasource selection can alter user-managed data spaces.
The API endpoints and documented workflow directly support data-space mutation. The skill includes confirmation rules, but the capability itself is high impact.
Capability review items (4)
These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.
The skill guides agents through device authorization and the CLI requests a 90-day key with datasource read, scan, execute, replace-file, and data-space write permissions. The key is saved locally, which is legitimate for the tool but high impact if the agent is misused or the host is shared.
The code explicitly lists broad default permissions and writes the issued key to a config file with a 90-day lifetime. This is intended functionality, not hidden behavior, but it materially increases account exposure.
The CLI sends user-provided SQL scripts and datasource bindings to the Datadata execute-adhoc endpoint. Documentation says this is read-only, but it can still expose private data or run expensive queries if used without careful confirmation.
The script field is sent directly to a remote execution API and the references confirm SQL execution is a core capability. The server may enforce read-only behavior, so the risk is high but not confirmed malicious.
Configurable Base URL Sends Credentials to Chosen Host
DATADATA_BASE_URL and --base-url can override the service endpoint, while API keys are placed in request headers. This is useful for development, but a malicious or mistaken base URL could receive Datadata credentials.
The base URL is user-configurable and request headers include the API key. The default is the legitimate Datadata domain, so this is a misuse risk rather than confirmed exfiltration.
Query result artifacts are downloaded and written to a caller-provided output path or a temp-file path. This is expected behavior, but it can store sensitive query output on disk and may overwrite a selected path.
The write path is clear in the code and result data may be sensitive. There is no evidence of stealthy writes, but users should know outputs persist locally.
Static false positives ignored (3)
These static matches were dismissed by semantic review or matched schema-only tokens, so they are shown for transparency but do not drive the quality score.
Markdown Backticks Misclassified as Shell Execution
Most external command findings occur in SKILL.md and reference files where backticks mark inline code, command examples, SQL examples, and Markdown fences. The inspected Python script does not call shell, subprocess, eval, or os.system.
Manual review shows Markdown formatting and examples at representative flagged lines. No evidence found of shell execution in the Python entry point.
The weak-cryptography and high-entropy alerts align with words such as API key, SQL, Chinese documentation, and example identifiers. No evidence found of encoded payloads, encrypted blobs, or custom cryptography in the reviewed files.
The files are human-readable documentation and Python source. Static entropy is plausibly inflated by non-English text and dense examples, but a full byte-level entropy review was not repeated.
Targeted review did not find text claiming to override system instructions, skip security review, force approval, or impersonate a higher-priority role. No evidence found of prompt injection in the inspected files.
The reviewed instruction sections contain operational rules for Datadata use, not marketplace-audit override language. The finding is framed as absence of evidence after targeted keyword and context review.
This skill is a legitimate API client for the Datadata platform. All 815 static findings are false positives resulting from documentation code examples in markdown files (backtick shell commands), standard API client patterns (HTTP requests, credential storage), and heuristic entropy detection on legitimate content. The Python CLI script is well-structured, uses stdlib only, stores credentials with proper filesystem permissions (0700/0600), and connects only to the known datadata.com domain. No evidence of malicious intent, obfuscation, or data exfiltration was found.
7
Files scanned
2,698
Lines analyzed
4
Review items
7
False positives ignored
Static false positives ignored (7)
These static matches were dismissed by semantic review or matched schema-only tokens, so they are shown for transparency but do not drive the quality score.
External command execution in documentation examples
FALSE POSITIVE: The static analyzer detected backtick patterns in reference markdown files and SKILL.md as Ruby/shell execution. These are shell command examples (curl, CLI invocations) shown in code blocks for documentation purposes. They are not executable code within the skill itself. The actual CLI execution happens through the agent running python3 scripts/datadata_query.py as a subprocess, which is the expected operation of this skill.
FALSE POSITIVE: The openai.yaml agent definition includes backtick-delimited code examples demonstrating CLI usage patterns. These are instructional examples for the AI agent, not executable Ruby/shell code. The skill is designed to run datadata_query.py as a Python subprocess, which is its legitimate function.
FALSE POSITIVE: The script reads DATADATA_API_KEY from environment variables and a local config file (~/.config/datadata/config.json). This is expected behavior for a legitimate API client tool. Credentials are stored with secure filesystem permissions (0600). The access pattern is not malicious - it is the standard way CLI tools handle authentication.
FALSE POSITIVE: The script imports urllib.request and makes HTTP requests to api.datadata.com endpoints. This is expected behavior for an API client tool. The script connects only to a single known domain (datadata.com) for legitimate data query operations, with no evidence of data exfiltration or connections to unknown endpoints.
Weak cryptographic algorithm detection on datetime import
FALSE POSITIVE: The static analyzer flagged import datetime as a weak cryptographic algorithm. The datetime module is used for timestamp calculations (API key expiry checks, device flow state expiration). No actual cryptographic operations are performed. This is a standard library import with no security implications.
FALSE POSITIVE: The script stores API keys in ~/.config/datadata/config.json with proper Unix permissions (0700 for directory, 0600 for file). This is the standard and recommended practice for CLI tools to persist credentials. The access pattern is not suspicious or malicious.
System reconnaissance detection on whoami API call
FALSE POSITIVE: The script includes a whoami command that calls a Datadata API endpoint (/api/v1/api-keys/whoami) to verify API key validity and inspect permissions. This is not Unix system reconnaissance. The static analyzer confused the API endpoint name with the Unix whoami command.