ClawHub
Back to skill

Security audit

Clawtrade Bnb

Security checks for vulnerabilities and agentic risk

Overview

This is a real autonomous DeFi trading skill that is mostly purpose-aligned, but it asks for wallet signing authority and can repeatedly submit live transactions without enough safety controls.

Review this carefully before installing. Use only a fresh testnet wallet or a wallet with funds you can afford to lose, do not put a mainnet private key in .env, avoid running the live scheduler unattended, and do not expose the API port to untrusted networks. This should be treated as experimental financial automation until it has bounded approvals, dry-run/manual approval defaults, transaction and gas limits, authenticated APIs, and audited mainnet controls.

A.I.G

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (4)

T09 · Insecure Skill Coding Practices

Warning
Location
strategy-scheduler.js:84
Finding
Wallet Private-Key Prefix Disclosed in Scheduler Logs<![CDATA[ ## Vulnerability Details **File Location**: `strategy-scheduler.js:84-98` **Vulnerability Type**: Sensitive key material exposure through application logs **Risk Level**: Medium ### Vulnerable Code ```javascript async function startScheduler() { console.log(` ╔═══════════════════════════════════════════════════════════════════╗ ║ DeFi Strategy Scheduler - LIVE ║ ╠═══════════════════════════════════════════════════════════════════╣ ║ Engine: ${deployedConfig.network} ║ Wallet: ${PRIVATE_KEY ? PRIVATE_KEY.slice(0, 10) + '...' : 'Not loaded'} ║ RPC: ${RPC_URL.slice(0, 40)}... ║ Strategies: Compound Yield, Rebalance, Dynamic Harvest ║ ║ Cycle Interval: ${EXECUTION_INTERVAL}s ║ ║ On-Chain Logging: ENABLED ║ ╚═══════════════════════════════════════════════════════════════════╝ `); if (!PRIVATE_KEY) { console.error('❌ PRIVATE_KEY not found in .env'); process.exit(1); } ``` ### Technical Analysis The scheduler prints the first ten characters of `PRIVATE_KEY`. For a conventional Ethereum key beginning with `0x`, this discloses eight hexadecimal key digits, or 32 bits of private-key material. Private keys should be treated as indivisible secrets. Partial disclosure does not by itself make recovery of a properly generated 256-bit key computationally practical, but it unnecessarily reduces its unknown entropy and creates reusable secret material in terminal history, process supervisors, container logs, CI logs, and centralized observability systems. The disclosure is unnecessary because the public wallet address is already derivable by the initialized wallet and provides sufficient operator identification without exposing signing material. ### Attack Path 1. An operator starts `strategy-scheduler.js` with a funded wallet key in `.env`. 2. The scheduler emits the private-key prefix to standard output. 3. A user or service wi ...[truncated 766 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Never print any portion, fingerprint, hash, or encoding of a private key. - Replace the output with the public wallet address: ```javascript const walletLabel = engine.wallet?.address || 'Not loaded'; console.log(`Wallet: ${walletLabel}`); ``` - Load secrets through a dedicated secret manager where possible. - Restrict access to process and container logs. - Rotate wallet keys if existing logs containing key prefixes were broadly distributed. - Add automated secret-redaction tests that fail if private-key variables are interpolated into log messages. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
defi-strategy-engine.js:75
Finding
Missing Safety Controls and Undefined Rebalance Result Can Cause Repeated Real Transactions<![CDATA[ ## Vulnerability Details **File Location**: `defi-strategy-engine.js:75-82, 145-149, 270-282`; `strategy-scheduler.js:46-73, 105-106` **Vulnerability Type**: Unsafe autonomous transaction execution and post-transaction control-flow failure **Risk Level**: High ### Vulnerable Code ```javascript // defi-strategy-engine.js const userYield = await vaultContract.calculateUserYield(this.wallet.address); const yieldAmount = parseFloat(ethers.utils.formatEther(userYield)); console.log(`\n📊 ${vault.vaultId}`); console.log(` Pending yield: ${yieldAmount.toFixed(6)} tokens`); // Only compound if there's meaningful yield if (yieldAmount > 0.001) { console.log(` ⚡ Calling compound()...`); const tx = await vaultContract.compound({ gasLimit: 200000 }); console.log(` 📝 TX submitted: ${tx.hash}`); const receipt = await tx.wait(1); ``` ```javascript // defi-strategy-engine.js const userYield = await vaultContract.calculateUserYield(this.wallet.address); const yieldAmount = parseFloat(ethers.utils.formatEther(userYield)); if (yieldAmount > 0.001) { console.log(`\n✓ ${vault.vaultId}: Harvesting ${yieldAmount.toFixed(6)} tokens`); const tx = await vaultContract.harvest({ gasLimit: 200000 }); console.log(` TX: ${tx.hash}`); const receipt = await tx.wait(1); ``` ```javascript // defi-strategy-engine.js async executeFullCycle() { console.log(`\n${'═'.repeat(60)}`); console.log(`DeFi Strategy Engine - REAL Transactions`); console.log(`${new Date().toISOString()}`); console.log(`${'═'.repeat(60)}`); const cycleResults = { timestamp: Date.now(), compound: await this.compoundYieldStrategy(), harvest: await this.harvestStrategy(), }; this.savePerformanceMetrics(); ``` ```javascript // strategy-scheduler.js try { // Run all strategies const results = await engine.executeFullCycle(); // Log to blockchain if (results.compound.length > 0) { for (const action of results.compound) { await logger.logAction ...[truncated 3394 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Make dry-run mode the default and require an explicit `LIVE_TRADING=true` setting plus operator confirmation before signing. - Implement the declared USD and profitability controls: - Obtain prices from a validated oracle. - Estimate gas before execution. - Require expected net reward to exceed gas cost by a configured safety margin. - Return a complete, validated result schema: ```javascript return { timestamp: Date.now(), compound, harvest, rebalance: { status: 'skipped', reason: 'not implemented' } }; ``` - Validate the result before dereferencing it: ```javascript if (results.rebalance?.status === 'success') { // Log successful rebalance. } ``` - Do not compound and harvest the same vault in one cycle unless contract semantics explicitly support that sequence. - Persist transaction hashes and action identifiers before submission, then check receipts and contract state before retrying. - Add per-cycle and daily limits for transaction count, gas cost, token amount, and total portfolio exposure. - Stop the scheduler after unexpected post-transaction errors instead of automatically continuing. - Add a circuit breaker for repeated failures and require manual reactivation. - Validate chain ID, contract bytecode, and configured contract addresses before every live session. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
pancakeswap-executor.js:49
Finding
PancakeSwap Executor Grants Unlimited Persistent Token Allowance<![CDATA[ ## Vulnerability Details **File Location**: `pancakeswap-executor.js:49-61` **Vulnerability Type**: Excessive ERC-20 approval **Risk Level**: High ### Vulnerable Code ```javascript // Approve token const tokenContract = new ethers.Contract(path[0], ERC20_ABI, this.wallet); const allowance = await tokenContract.allowance(this.wallet.address, PANCAKESWAP_ROUTER); if (allowance.lt(ethers.utils.parseEther(amountIn.toString()))) { console.log(' Approving token for router...'); const approveTx = await tokenContract.approve( PANCAKESWAP_ROUTER, ethers.constants.MaxUint256 ); await approveTx.wait(); console.log(` ✓ Approved`); } ``` ### Technical Analysis The executor needs an allowance equal to the swap input, but grants `MaxUint256`. ERC-20 allowances persist until consumed or revoked and allow the approved spender to call `transferFrom` without another wallet signature. This violates least privilege because the router receives authority over the wallet's entire current and future balance of the approved token rather than only the amount required for the current swap. The executor also relies on a hardcoded router address and does not verify the connected chain ID or deployed bytecode before granting approval. If the router address is incorrect for the active chain, its contract is compromised, or RPC/network configuration places the transaction on an unexpected chain where the same address is attacker-controlled, the allowance can be used to drain the approved token. ### Attack Path 1. The wallet contains an ERC-20 token and calls `executeSwap()`. 2. Its existing allowance is lower than `amountIn`. 3. The executor approves the hardcoded router for `MaxUint256`. 4. The approval remains active after the intended swap. 5. The approved router, or an attacker controlling code at that address on an unexpected network, calls the token's `transferFrom(wallet, attacker, amount)`. 6. The attacker transfers up to the wallet's complete ap ...[truncated 539 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Approve only the exact amount required for the current operation: ```javascript const amountInWei = ethers.utils.parseEther(amountIn.toString()); if (allowance.lt(amountInWei)) { if (!allowance.isZero()) { const resetTx = await tokenContract.approve(PANCAKESWAP_ROUTER, 0); await resetTx.wait(); } const approveTx = await tokenContract.approve( PANCAKESWAP_ROUTER, amountInWei ); await approveTx.wait(); } ``` - Revoke residual allowance after the operation when protocol behavior permits. - Verify `provider.getNetwork()` and require chain ID 97 before approval. - Validate the router address against a trusted per-chain allowlist. - Check that deployed bytecode exists at the router address and, where feasible, compare its hash with an expected deployment. - Use permit-based, bounded approvals when supported. - Show the token, spender, amount, chain, and expiration policy to the operator before live approval. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
server.js:16
Finding
Unauthenticated API Exposes Wallet and Financial Execution Logs<![CDATA[ ## Vulnerability Details **File Location**: `server.js:16-36, 65`; `api/logs.js:7-48, 66`; `defi-strategy-engine.js:251-259` **Vulnerability Type**: Missing API access control and sensitive operational-data exposure **Risk Level**: Medium ### Vulnerable Code ```javascript // server.js const app = express(); app.use(cors()); app.use(express.json()); app.get('/api/logs', (req, res) => { try { const logPath = path.join(__dirname, 'execution-log.jsonl'); if (!fs.existsSync(logPath)) { return res.json([]); } const content = fs.readFileSync(logPath, 'utf8'); const logs = content .split('\n') .filter(line => line.trim()) .map(line => JSON.parse(line)); res.json(logs); } catch (err) { console.error('Error reading logs:', err); res.status(500).json({ error: err.message }); } }); ``` ```javascript // server.js const PORT = process.env.PORT || 3001; app.listen(PORT, () => { ``` ```javascript // api/logs.js const app = express(); app.use(cors()); app.use(express.json()); // Serve execution logs app.get('/api/logs', (req, res) => { try { const logPath = path.join(__dirname, '../execution-log.jsonl'); if (!fs.existsSync(logPath)) { return res.json([]); } const content = fs.readFileSync(logPath, 'utf8'); const logs = content .split('\n') .filter(line => line.trim()) .map(line => { try { const parsed = JSON.parse(line); // Ensure all fields are safe return { timestamp: parsed.timestamp || 0, cycle: parsed.cycle || 0, action: parsed.action || 'UNKNOWN', vault: parsed.vault || parsed.vault_id || 'unknown', vault_id: parsed.vault_id || parsed.vault || 'unknown', vault_name: parsed.vault_name || '', tx_hash: parsed.tx_hash || '', rewards_usd: parsed.rewards_usd || parsed.amount_tokens || 0, confidence: parse ...[truncated 2918 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Bind development services to loopback by default: ```javascript const HOST = process.env.HOST || '127.0.0.1'; app.listen(PORT, HOST, () => { console.log(`API listening on http://${HOST}:${PORT}`); }); ``` - Require authentication for every non-health endpoint. For remote deployments, use short-lived tokens or authenticated reverse-proxy identity rather than a static public endpoint. - Enforce authorization so users can only access logs for wallets they are permitted to monitor. - Replace unrestricted CORS with an explicit allowlist: ```javascript app.use(cors({ origin: ['http://localhost:5173'], methods: ['GET'], credentials: false })); ``` - Remove `...parsed` and return only explicitly permitted fields. - Redact wallet addresses where full addresses are unnecessary, and avoid returning raw provider or contract error messages. - Add pagination, maximum response size, rate limiting, and security logging. - Keep port 3001 blocked from untrusted networks unless the authenticated API is intentionally deployed. - Treat CORS only as a browser control, not as a substitute for authentication. ]]>

SkillSpector

Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (327)

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The report identifies the skill as `yield-farming-agent` while the manifested skill is `clawtrade-bnb`, creating a clear identity mismatch. In an autonomous DeFi context, this can mislead operators about what code they are reviewing or deploying, weakening trust boundaries and potentially causing the wrong strategy or artifact to be approved for on-chain use.

Missing User Warnings

High
Confidence
97% confidence
Finding
The documentation advertises autonomous real blockchain execution and frequent conditional transactions without a prominent warning about financial risk, gas expenditure, and the possibility of unintended on-chain actions. Because this is a DeFi trading skill, omission of explicit safety warnings materially increases the chance that a user enables automation without understanding that it can submit live transactions affecting funds.

Missing User Warnings

High
Confidence
99% confidence
Finding
The installation instructions end with running the scheduler but do not clearly warn that doing so may immediately begin autonomous transaction activity. This is especially dangerous in a wallet-connected agent because users may treat the command as a harmless startup step when it can trigger live on-chain behavior and repeated execution cycles.

Missing User Warnings

High
Confidence
97% confidence
Finding
The document promotes autonomous blockchain transaction execution, including signing with a private wallet and executing deposit/withdraw/harvest/rebalance actions, without prominent warnings about irreversible financial loss, strategy failure, contract risk, or misconfiguration. In a DeFi trading skill context, this omission is dangerous because operators may enable live execution without understanding that the agent can directly move assets and incur losses.

Missing User Warnings

High
Confidence
98% confidence
Finding
The scheduler is described as running decision cycles automatically and executing blockchain transactions on a timer, but there is no explicit warning about unattended operation risk such as repeated bad trades, runaway retries, stale data, or draining funds during abnormal market conditions. Because this skill is intended for autonomous DeFi operation, lack of strong warnings and guardrails materially increases the chance of user harm.

Credential Access

High
Category
Privilege Escalation
Content
# Copy config
cp .env.example .env

# Edit .env with your testnet private key
nano .env
# (Add PRIVATE_KEY=your_key)
```
Confidence
92% confidence
Finding
Instructing users to edit `.env` and place a private key there promotes handling long-lived signing material in plaintext environment files. For a trading agent that can auto-execute on-chain actions, compromise of that file directly enables unauthorized transactions and asset theft.

Credential Access

High
Category
Privilege Escalation
Content
cp .env.example .env

# Edit .env with your testnet private key
nano .env
# (Add PRIVATE_KEY=your_key)
```
Confidence
97% confidence
Finding
The explicit instruction `Add PRIVATE_KEY=your_key` normalizes storing a blockchain private key directly in an environment file. In this skill's context, that credential authorizes autonomous trading, so leakage through local compromise, backups, logs, screenshots, or accidental commits can cause immediate fund loss.

Credential Access

High
Category
Privilege Escalation
Content
#### Step 4: Set up environment file
```bash
# Create .env (git-ignored automatically)
echo "PRIVATE_KEY=YOUR_TESTNET_PRIVATE_KEY" > .env
echo "RPC_URL=https://bsc-testnet.publicnode.com" >> .env
Confidence
92% confidence
Finding
This line explicitly instructs users to create a .env file containing a private key, which is credential material for a blockchain wallet. In this skill’s context, that credential enables direct financial actions, so normalizing plaintext secret placement without stronger controls increases the chance of credential compromise and unauthorized asset movement.

Credential Access

High
Category
Privilege Escalation
Content
```bash
# Create .env (git-ignored automatically)
echo "PRIVATE_KEY=YOUR_TESTNET_PRIVATE_KEY" > .env
echo "RPC_URL=https://bsc-testnet.publicnode.com" >> .env

# Verify (should show your address)
node -e "require('dotenv').config(); const ethers = require('ethers'); const w = new ethers.Wallet(process.env.PRIVATE_KEY); console.log('Wallet:', w.address)"
Confidence
89% confidence
Finding
This verification command reads the private key from environment variables and derives the wallet address, reinforcing a workflow centered on raw private-key handling. Although it prints only the address, it encourages loading highly sensitive credentials into a general-purpose runtime and may be copied into unsafe environments, increasing exposure risk for a key that controls financial assets.

Credential Access

High
Category
Privilege Escalation
Content
```
clawtrade-bnb/
├── .env                              # Your secrets (git-ignored)
├── .network.json                     # Network preference (auto-created)
├── execution-log.jsonl               # Action history (auto-created)
├── performance-metrics.json           # Metrics (auto-created)
Confidence
87% confidence
Finding
Documenting the project structure with a .env file labeled as containing 'Your secrets' normalizes keeping sensitive wallet material in the repository workspace. In a DeFi agent context, this increases the likelihood that users store operational keys beside code, logs, and tooling where they may be accidentally backed up, shared, or exfiltrated by local compromise.

Credential Access

High
Category
Privilege Escalation
Content
### Issue: "PRIVATE_KEY is not defined"
**Solution:** Create `.env` file with `PRIVATE_KEY=your_key`
```bash
echo "PRIVATE_KEY=0x..." > .env
```

### Issue: "Cannot find module 'ethers'"
Confidence
93% confidence
Finding
This troubleshooting advice again instructs users to place a private key directly into a .env file, reinforcing insecure secret-handling habits. Repetition matters here because the skill is an autonomous financial agent, so any compromise of that key can immediately translate into unauthorized transactions and asset loss.

Missing User Warnings

High
Confidence
98% confidence
Finding
The guide encourages moving an autonomous trading agent from testnet to mainnet and adding a real private key, while offering only a minimal cautionary note. In the context of an autonomous DeFi agent with network switching and self-optimizing behavior, this can lead users to expose real funds to unreviewed code, strategy bugs, malicious dependencies, or unsafe transactions, creating severe risk of irreversible financial loss.

Credential Access

High
Category
Privilege Escalation
Content
node agent-cli.js network mainnet

# Add real contracts to config.deployed.json
# Add real private key to .env (mainnet key)
# Run with caution - this is real money!
```
Confidence
99% confidence
Finding
This line explicitly tells users to add a real mainnet private key to a .env file, which is highly dangerous because it combines plaintext credential storage with production financial authority. In the context of an autonomous DeFi agent, compromise of that file could permit immediate, irreversible theft or misuse of real assets.

Credential Access

High
Category
Privilege Escalation
Content
cat > .gitignore << 'EOF'
node_modules/
.env
.env.local
*.log
.DS_Store
dist/
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
cat > .gitignore << 'EOF'
node_modules/
.env
.env.local
*.log
.DS_Store
dist/
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill description makes strong claims about autonomous DeFi trading, network switching, and reinforcement learning, while the analyzed implementation evidence appears inconsistent and in many places limited to logging, dashboards, testing, vault operations, or transaction utilities. This mismatch is dangerous because users may grant wallet keys, enable automation, or run on mainnet under false assumptions about what the software actually does.

Static analysis

Detected: suspicious.dangerous_exec, suspicious.exposed_secret_literal

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
src/cli.js:34

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
contracts/DEPLOYMENT.md:109

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
demo-executor.js:28

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
pancakeswap-agent.js:27

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
strategy-scheduler.js:23