binance-pay
4 findings (2 high, 2 medium), mainly data exfiltration, command injection. Most recent scan 2026-02-05.
This Binance Pay integration skill presents MULTIPLE HIGH-SEVERITY security risks primarily related to credential exposure, command injection vulnerabilities, and unsafe financial transaction handling. The skill requires sensitive API credentials and constructs bash commands with potential injection points. While it provides legitimate cryptocurrency payment functionality, the implementation lacks critical security controls: no input validation, no transaction confirmation requirements, unsafe JSON construction, and inadequate credential protection guidance. The skill should NOT be used in production without significant security hardening. The bash-based approach is inherently risky for handling financial operations and sensitive credentials - a Python implementation with proper input validation, parameterized queries, and secure credential management would be significantly safer.
Scanner's overall assessment (LLM analyzer)
Second scanner: NVIDIA SkillSpector
Independent static run, no language model, over the same files as the Cisco scan above. How the two scanners compare across the whole corpus: Two scanners, one corpus.
What this skill does
Binance Pay integration for crypto payments. Send, receive, and accept cryptocurrency payments with the world's largest exchange.
- Package
- 2 files, 5.6 KB
- SKILL.md
- 558 words, 12+ sections
- Code
- None. Instructions only.
- Requires
- bins:
curljq; env:BINANCE_PAY_API_KEYBINANCE_PAY_SECRET
SKILL.md covers: Binance Pay 🟡 · Environment Variables · Features · API Base URL · Authentication · Generate signature · Create Payment Order · Query Order Status · Close Order · Process Refund · Supported Currencies · Webhook Events
Findings
HIGH Hardcoded API Credentials Exposure Risk Data Exfiltrationllm
The skill requires sensitive Binance Pay API credentials (BINANCE_PAY_API_KEY, BINANCE_PAY_SECRET, BINANCE_PAY_MERCHANT_ID) to be stored as environment variables. While environment variables are better than hardcoding, the instructions demonstrate direct usage of these credentials in bash commands without any validation, sanitization, or secure handling guidance. If an agent executes these commands with user-controlled input, credentials could be exposed through command injection, logging, or error messages. The skill provides no guidance on secure credential management, rotation, or access control.
SKILL.md
Environment Variables section requires: BINANCE_PAY_API_KEY, BINANCE_PAY_SECRET, BINANCE_PAY_MERCHANT_ID with direct usage in bash commands like API_KEY="${BINANCE_PAY_API_KEY}" and SECRET="${BINANCE_PAY_SECRET}"HIGH Command Injection Vulnerability in Signature Generation Command Injectionllm
The generate_signature() bash function uses echo with user-controlled variables (TIMESTAMP, NONCE, payload) without proper sanitization. The function constructs a sign_string using variables that could contain malicious shell metacharacters. While TIMESTAMP and NONCE are generated locally, the payload variable is constructed from user input (merchantTradeNo, orderAmount, currency, goodsName, etc.). An attacker could inject shell commands through these fields, leading to arbitrary command execution when the signature is generated.
SKILL.md
generate_signature() { local payload="$1"; local sign_string="${TIMESTAMP}\n${NONCE}\n${payload}\n"; echo -n "$sign_string" | openssl dgst -sha512 -hmac "$SECRET" | cut -d' ' -f2 | tr '[:lower:]' '[:upper:]'; }MEDIUM Unsafe JSON Construction with User Input Command Injectionllm
The skill constructs JSON payloads by directly embedding user-controlled values using bash string interpolation (e.g., "merchantTradeNo": "'"$(date +%s)"'"). This approach is vulnerable to JSON injection attacks. If user input contains special characters like quotes, backslashes, or control characters, it could break the JSON structure, leading to malformed requests or potential injection attacks. The examples use $(date +%s) which is safe, but the pattern suggests user input would be inserted the same way.
SKILL.md
PAYLOAD='{ "merchantTradeNo": "'"$(date +%s)"'", "orderAmount": "10.00", "currency": "USDT", "goods": { "goodsName": "Product Name" } }'MEDIUM Sensitive Financial Data Transmission Without Validation Data Exfiltrationllm
The skill enables transmission of financial transaction data (payment amounts, merchant IDs, order details) to external Binance API endpoints without any input validation, amount limits, or transaction confirmation requirements. There are no safeguards against accidental large payments, no validation of currency codes, and no confirmation prompts before executing financial transactions. An agent could be manipulated into creating unauthorized payment orders or refunds.
SKILL.md
Multiple curl commands sending financial data without validation: orderAmount, refundAmount, currency fields accepted without bounds checking or confirmationWhat is in the package
| File | Kind | Size |
|---|---|---|
README.md | doc | 772 B |
SKILL.md | doc | 4.9 KB |
External hosts referenced
bpay.binanceapi.com developers.binance.com clawdbot.com merchant.binance.com
Hostnames that appear in the skill's files. Referencing a host is not a finding; compare against the findings above and the skill's stated purpose.
Environment variables referenced
API_KEY BINANCE_PAY_API_KEY BINANCE_PAY_SECRET SECRET BINANCE_PAY_MERCHANT_ID
Package contents recorded 2026-10-22. The scan above ran against the version current at scan time; the two can differ if the skill has since been updated.
What we checked
- Static analyzer. Pattern rules over SKILL.md and bundled files: known-bad commands, exfiltration URLs, secrets, obfuscation.
- Behavioral analyzer. Checks what the skill asks the agent to do against what its description claims it does.
- Llm analyzer. A language model reads the skill and reports intent-level issues the rules cannot express.
- Trigger analyzer. Looks for instructions that fire on conditions the user did not ask for.
- Meta analyzer. A second model pass that validates, deduplicates and re-scores the other analyzers' findings.
What we did not check
- Runtime behaviour. The skill was not executed; findings come from reading its files.
- Anything fetched at install or run time, including remote scripts, package dependencies, and URLs the skill tells the agent to open.
- Content the analyzers cannot read: images, binaries, and some non-English text.
- Known scanner bypass classes. See the methodology and limitations page.
Sources
- Repository: https://clawhub.ai/skills/binance-pay
- Raw scan result: binance-pay-scan.json
- Badge for your README:
 - Request a re-scan