APEX IA Pro

• Outcome: Review
• Latest audit: Sep 16, 2026 · 8:09 AM UTC
• Version: 3.2.0

Overview

This skill advertises a Binance Futures scanner, but the package also contains under-disclosed automated trading programs with embedded Binance credentials and default-on leveraged execution paths.

Review this as more than a scanner. Do not install or run the trader scripts unless you intentionally want automated Binance Futures trading, have rotated any exposed credentials, understand whether testnet or live endpoints are configured, and have explicit controls for order confirmation, leverage, stop loss, and account permissions.

A.I.G

Vulnerability Patterns

• Unauthorized Access and Privilege Escalation: Obtains permissions beyond the task's legitimate needs
• Insecure Dependencies: Introduces malicious components through unsafe dependency sources
• Insecure Skill Coding Practices: Finds exploitable flaws such as hardcoded secrets or command injection
• Skill Instruction Hijacking: Alters the agent's session goals or safety constraints when the skill loads
• Agent Memory Poisoning: Writes attacker-controlled rules into memory that affect later sessions

Findings (6)

T09 · Insecure Skill Coding Practices

Error

• Location: apex-ia-trader.mjs:14
• Finding: Plaintext Binance API credentials embedded in multiple executable files<![CDATA[ ## Vulnerability Details **File Location**: `apex-ia-trader.mjs:14-19`; repeated in `apex-ia-aggressive.mjs:13-16`, `apex-ia-final.mjs:13-16`, `apex-ia-final-20x.mjs:53-56`, `apex-ia-robot.mjs:13-16`, and `apex-ia-smc.mjs:53-56` **Vulnerability Type**: Hardcoded exchange credentials **Risk Level**: High ### Vulnerable Code ```js const API_KEY = 'Dq0vl5xeDxwQKMBwoJT5A9yxsJiW8hbXyVO7831c4xbI0N1tfiQjsTf1ZKsSVIXL'; const API_SECRET = '1kVF6XZuV5rVnKyIiAjbLTNcN50tQZEI8M5p90piOblTOl4W19rpgIeZMRzDlBBb'; const USE_DEMO = true; // true = conta demo, false = conta real // URLs const BASE_URL = USE_DEMO ? 'https://testnet.binancefuture.com' : 'https://fapi.binance.com'; ``` The credentials are subsequently used to create authenticated Binance request signatures: ```js function generateSignature(queryString, secret) { return crypto.createHmac('sha256', secret).update(queryString).digest('hex'); } ``` ### Technical Analysis The package distributes a Binance API key and secret in plaintext. The same credential pair is duplicated across several executable trading programs. Anyone who can obtain the package can extract and reuse the credentials without needing access to the original deployment environment. The reviewed defaults direct these credentials to Binance Futures testnet. This limits the currently demonstrated exposure, but it does not make plaintext credential distribution safe. The credentials permit signed account and order requests according to whatever permissions Binance has assigned to the key. Moreover, the source pattern encourages users to replace the constants with their own credentials, which could then be accidentally redistributed. ### Attack Path 1. An attacker downloads or otherwise obtains the package. 2. The attacker extracts `API_KEY` and `API_SECRET` from one of the executable files. 3. The attacker constructs Binance API query strings and signs them using HMAC-SHA256. 4. The attacker submits authenticated requests using th ...[truncated 622 chars]
• Remediation: <![CDATA[ ## Remediation Suggestions 1. Revoke and rotate the exposed API key and secret immediately. 2. Remove all credentials from source files, compiled artifacts, examples, and repository history. 3. Load user-specific credentials from a protected secret manager or environment variables. 4. Refuse to start authenticated components when required secrets are absent. 5. Use separate, read-only API keys for scanning and narrowly scoped trading keys for execution. 6. Enable Binance IP allowlisting and disable withdrawal permissions. 7. Add automated secret scanning to CI and pre-commit checks. 8. Ensure logs and error messages never print API keys, signatures, or complete signed URLs. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error

• Location: apex-ia-aggressive.mjs:21
• Finding: Default-enabled automatic leveraged trading exceeds the declared scanner scope<![CDATA[ ## Vulnerability Details **File Location**: `apex-ia-aggressive.mjs:21-30`, `apex-ia-aggressive.mjs:63-69`, `apex-ia-aggressive.mjs:87-121`, and `apex-ia-aggressive.mjs:250-281` **Vulnerability Type**: Undisclosed account-authorized financial execution **Risk Level**: Critical ### Vulnerable Code The aggressive executable enables automatic trading, configures 20× leverage, and disables stop-loss protection by default: ```js const FIXED_ENTRY_USD = 10; // Entrada fixa de $10 por operação let MAX_LEVERAGE = 20; // Alavancagem 20x let TAKE_PROFIT_PERCENT = 50; // Take profit em % (50% a 400%) let USE_STOP_LOSS = false; // SEM STOP LOSS (seu estilo) let STOP_LOSS_PERCENT = 0; // Sem stop loss const SYMBOLS = ['btcusdt', 'ethusdt', 'bchusdt', 'solusdt', 'adausdt', 'dogeusdt', 'xrpusdt']; const TIMEFRAMES = ['5m', '15m', '30m', '1h', '4h']; let autoTrade = true; ``` It changes account leverage through an authenticated request: ```js async function setLeverage(symbol, leverage) { const result = await binanceRequest('POST', '/fapi/v1/leverage', { symbol: symbol.toUpperCase(), leverage: leverage }, true); if (result) console.log(` ✅ Alavancagem ${leverage}x configurada`); return result; } ``` It submits a market order and intentionally omits stop-loss protection: ```js const order = await binanceRequest('POST', '/fapi/v1/order', { symbol: symbol.toUpperCase(), side: side.toUpperCase(), type: 'MARKET', quantity: quantity, reduceOnly: 'false' }, true); if (order && order.orderId) { console.log(` ✅ Ordem executada! ID: ${order.orderId}`); // SEM STOP LOSS (seu estilo) if (!USE_STOP_LOSS) { console.log(` ⚠️ SEM STOP LOSS - risco total de perda`); } ``` A qualifying signal is executed without per-order confirmation: ```js async function executeTrade(signal) { if (!autoTrade) return false; const current ...[truncated 3014 chars]
• Remediation: <![CDATA[ ## Remediation Suggestions 1. Remove all automatic trading executables from the analysis-only Skill package. 2. Publish trading automation as a separate, explicitly labeled component with a separate permission model. 3. Default every trading component to manual mode and require informed, per-order confirmation. 4. Enforce testnet through configuration and code-level safeguards during evaluation. 5. Require a dedicated trading key rather than reusing scanner credentials. 6. Apply minimal API permissions, IP allowlisting, position-size limits, daily-loss limits, and maximum leverage limits. 7. Enable stop-loss protection by default and reject orders that cannot establish required protective orders. 8. Present the selected account, environment, leverage, quantity, stop, and maximum loss before execution. 9. Add a global emergency stop and persist risk state safely across process restarts. 10. Include automated tests proving that installation and ordinary scanner invocation cannot submit authenticated requests. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error

• Location: start-apex-completo.sh:6
• Finding: Complete launcher starts an account-authorized trader as a background process<![CDATA[ ## Vulnerability Details **File Location**: `start-apex-completo.sh:6-24` **Vulnerability Type**: Unexpected background execution of a privileged trading component **Risk Level**: High ### Vulnerable Code ```bash echo "Iniciando APEX IA Scanner e Trader Automático..." echo "" # Limpar sinais anteriores rm -f bridge-signals.json # Criar arquivo de ponte vazio echo '{"lastSignal": null, "timestamp": null, "updated": false}' > bridge-signals.json # Iniciar o trader em background node apex-ia-trader.mjs & TRADER_PID=$! # Aguardar 2 segundos sleep 2 # Iniciar o scanner node apex-ia-software.mjs # Quando o scanner fechar, matar o trader kill $TRADER_PID 2>/dev/null ``` The trader initializes its mode as automatic: ```js let autoMode = true; setInterval(async () => { if (autoMode) { await getBalance(); await monitorPositions(); drawTraderUI(); } }, 2000); ``` ### Technical Analysis The “complete” launcher starts `apex-ia-trader.mjs` in the background before starting the scanner. The background process immediately uses authenticated Binance functionality to obtain account data and monitor its in-memory positions. The reviewed `apex-ia-trader.mjs` exports order-execution functions, but the inspected launcher and scanner do not demonstrate a direct call from `apex-ia-software.mjs` into those functions. Therefore, the confirmed automatic effect of this launcher is background startup and account access; automatic order placement through this particular launcher requires an additional signal-integration call not established in the reviewed path. Even with that limitation, launching an account-authorized trading process as a side effect of starting a scanner is inconsistent with least privilege and creates a dangerous operational boundary. ### Attack Path 1. A user runs `start-apex-completo.sh` to start the advertised complete scanner system. 2. The script starts `apex-ia-trader.mjs` as a background process. 3. The ...[truncated 1035 chars]
• Remediation: <![CDATA[ ## Remediation Suggestions 1. Separate scanner and trader launchers completely. 2. Never start an account-authorized financial process in the background as an incidental scanner side effect. 3. Require an explicit interactive confirmation that identifies the account environment and requested permissions. 4. Default the trader to manual, read-only, and testnet operation. 5. Use shell traps to reliably terminate child processes on `EXIT`, `INT`, and `TERM`. 6. Display and record the trader PID rather than concealing it behind the scanner interface. 7. Require a separate command-line flag such as `--enable-trading` and reject unattended activation. 8. Ensure the scanner can operate with no authenticated Binance credentials. ]]>

T08 · Insecure Dependencies

Warning

• Location: realtime-scanner.js:154
• Finding: Runtime npm installation executes mutable third-party dependency code<![CDATA[ ## Vulnerability Details **File Location**: `realtime-scanner.js:154-155` **Vulnerability Type**: Unsafe runtime dependency installation **Risk Level**: Medium ### Vulnerable Code ```js const { execSync } = await import('child_process'); execSync('npm install ws', { stdio: 'inherit' }); ``` ### Technical Analysis The executable invokes the system package manager at runtime to install `ws`. This bypasses the package's normal reviewed and locked installation flow. The version resolved by npm can vary according to registry state, npm configuration, lockfile behavior, and the current working directory. Although `ws` is a legitimate package and no malicious dependency was confirmed in the supplied lockfile, runtime installation can execute npm lifecycle scripts and mutate the local dependency tree using the current process privileges. It also makes the effective code executed by the scanner less reproducible than the audited artifact. ### Attack Path 1. The scanner reaches the runtime dependency-installation branch. 2. It imports `child_process` and invokes `npm install ws`. 3. npm resolves the dependency using the user's current registry and configuration. 4. A compromised registry, malicious proxy, poisoned npm configuration, or future dependency compromise supplies altered package content. 5. npm installs the package and may execute lifecycle scripts with the scanner user's privileges. 6. The newly installed code is subsequently loaded by the scanner. ### Impact Assessment Successful exploitation can modify project files and execute third-party lifecycle code with the privileges of the user running the scanner. The practical scope includes the current project directory and any additional files or resources accessible to that user. No dependency-confusion or malicious package was confirmed in the reviewed artifact; the risk arises from the mutable runtime installation mechanism. ]]>
• Remediation: <![CDATA[ ## Remediation Suggestions 1. Remove the runtime `execSync('npm install ws')` behavior. 2. Declare `ws` only in `package.json` and pin it through the committed lockfile. 3. Install dependencies during a controlled build or deployment stage with `npm ci`. 4. Disable lifecycle scripts where feasible during controlled installation. 5. Use registry allowlisting, integrity verification, and dependency scanning in CI. 6. If the dependency is unavailable at runtime, fail safely with a clear error rather than installing code dynamically. 7. Run the application under an unprivileged account with a read-only application directory where practical. ]]>

T09 · Insecure Skill Coding Practices

Warning

• Location: webapp/server.js:14
• Finding: Unauthenticated web API permits cross-origin signal access and outbound request abuse<![CDATA[ ## Vulnerability Details **File Location**: `webapp/server.js:14-16`, `webapp/server.js:46-62`, and `webapp/server.js:69-79` **Vulnerability Type**: Unrestricted CORS, missing authentication, and unvalidated proxy parameters **Risk Level**: Medium ### Vulnerable Code The application enables unrestricted CORS and exposes its routes without authentication: ```js app.use(cors()); app.use(express.json()); app.use(express.static('public')); ``` The `/api/klines` route forwards unvalidated user input to Binance: ```js app.get('/api/klines', async (req, res) => { const { symbol = 'BTCUSDT', interval = '1h', limit = 50 } = req.query; try { const response = await axios.get(`https://api.binance.com/api/v3/klines`, { params: { symbol, interval, limit } }); const klines = response.data.map(k => ({ time: k[0], open: parseFloat(k[1]), high: parseFloat(k[2]), low: parseFloat(k[3]), close: parseFloat(k[4]), volume: parseFloat(k[5]) })); res.json(klines); } catch (err) { res.status(500).json({ error: err.message }); } }); ``` The `/api/signals` route exposes locally stored signal history: ```js app.get('/api/signals', (req, res) => { try { if (fs.existsSync(SIGNALS_FILE)) { const signals = JSON.parse(fs.readFileSync(SIGNALS_FILE, 'utf-8')); res.json(signals.slice(-50).reverse()); } else { res.json([]); } } catch (err) { res.status(500).json({ error: err.message }); } }); ``` ### Technical Analysis The server has no authentication or rate limiting. `cors()` permits browser scripts from any origin to read API responses when they can reach the service. The kline route accepts arbitrary `symbol`, `interval`, and `limit` values and forwards them to Binance without type checks, allowlists, or application-level bounds. The outbound host is fixed to Binance, so this is not general server-side request forgery. It can nevertheless be abused as a request r ...[truncated 1333 chars]
• Remediation: <![CDATA[ ## Remediation Suggestions 1. Bind explicitly to loopback when remote access is unnecessary, for example `app.listen(PORT, '127.0.0.1')`. 2. Restrict CORS to a documented allowlist of trusted origins. 3. Add authentication and authorization before exposing signal data. 4. Apply per-client and global rate limits to all API routes. 5. Validate `symbol` and `interval` against strict allowlists. 6. Parse `limit` as an integer and enforce a conservative minimum and maximum. 7. Configure Axios timeouts and request cancellation. 8. Add response caching to reduce repeated upstream requests. 9. Avoid returning raw upstream error details to untrusted clients. 10. Apply firewall rules and avoid publishing the port from containers unless explicitly required. ]]>

T09 · Insecure Skill Coding Practices

Warning

• Location: src/scanner.ts:327
• Finding: Unbounded Agent-controlled scan parameters can amplify Binance API requests<![CDATA[ ## Vulnerability Details **File Location**: `src/index.ts:9-18` and `src/scanner.ts:327-354` **Vulnerability Type**: Missing runtime input validation and resource limits **Risk Level**: Medium ### Vulnerable Code The tool schema provides defaults but does not enforce safe runtime limits: ```ts parameters: { type: 'object', properties: { minScore: { type: 'number', description: 'Score mínimo (0-10, padrão: 5)', default: 5 }, includeTFs: { type: 'array', items: { type: 'string' }, default: ['15m', '1h', '4h'] }, symbolLimit: { type: 'number', description: 'Limite de pares (padrão: 20)', default: 20 } } }, handler: async (args: ScanOptions) => { const signals = await scanAll(args); ``` The values are used directly: ```ts export async function scanAll(options: ScanOptions = {}): Promise<FinalSignal[]> { const { minScore = 6, includeTFs = ['15m', '1h', '4h'], symbolLimit = 30 } = options; console.log(`🔍 Escaneando até ${symbolLimit} pares...`); let symbols = await fetchSymbols(); if (symbolLimit && symbols.length > symbolLimit) { symbols = symbols.slice(0, symbolLimit); } const allSignals: FinalSignal[] = []; const batchSize = 3; for (let i = 0; i < symbols.length; i += batchSize) { const batch = symbols.slice(i, i + batchSize); const batchResults = await Promise.all( batch.map(symbol => scanSymbol(symbol, includeTFs)) ); allSignals.push(...batchResults.flat()); } ``` For every supplied timeframe value, `scanSymbol` makes another request: ```ts for (const tf of timeframes) { try { const candles = await fetchKlines(symbol, intervalMap[tf] || '1h', 100); const signal = calculateFinalSignal(symbol, tf, candles); if (signal && signal.score >= 6) { results.push(signal); } await new Promise(resolve => setTimeout(resolve, 100)); } catch (error) { // Silencia erros individuais } } ``` ### Technical Analysis TypeScript interfaces are comp ...[truncated 1528 chars]
• Remediation: <![CDATA[ ## Remediation Suggestions 1. Perform explicit runtime validation before invoking `scanAll`. 2. Require `symbolLimit` to be a finite integer within a safe range, such as 1 through 50. 3. Require `minScore` to be finite and within its documented range. 4. Restrict timeframes to a fixed allowlist such as `1m`, `5m`, `15m`, `30m`, `1h`, `4h`, and `1d`. 5. Deduplicate timeframe values and cap the array length. 6. Reject unsupported values instead of silently mapping them to `1h`. 7. Enforce a total outbound-request budget per invocation. 8. Add Axios timeouts, cancellation support, and a global execution deadline. 9. Return explicit validation errors rather than silently ignoring malformed input or network failures. ]]>

SkillSpector

Vulnerability Patterns

• Data Exfiltration: External Transmission, Env Variable Harvesting, File System Enumeration
• Excessive Agency: Unrestricted Tool Access, Autonomous Decision Making, Scope Creep
• MCP Tool Poisoning: Hidden Instructions, Unicode Deception, Parameter Description Injection
• Prompt Injection: Instruction Override, Hidden Instructions, Exfiltration Commands
• Privilege Escalation: Excessive Permissions, Sudo/Root Execution, Credential Access

Findings (200)

Description-Behavior Mismatch

Critical

• Confidence: 99% confidence
• Finding: The skill is described as a market scanner, but the code enables automated leveraged futures trading by default via `autoTrade = true` and related position-management logic. This is dangerous because users expecting passive analysis could unknowingly authorize live or testnet account actions, and the mismatch obscures the true risk profile of the skill.

Context-Inappropriate Capability

Critical

• Confidence: 98% confidence
• Finding: The skill contains signed Binance request support and account-changing API operations inconsistent with a scanner-only description. This is dangerous because it gives the skill the ability to modify leverage, place orders, and affect account state while appearing to be a read-only analysis tool.

Description-Behavior Mismatch

Critical

• Confidence: 99% confidence
• Finding: These functions open and close market positions, calculate targets, and maintain internal position state, clearly exceeding the described scope of scanning. In context, this is especially dangerous because futures market orders with leverage can create immediate financial exposure and losses without users realizing the skill is an execution bot.

Tp4

High

• Category: MCP Tool Poisoning
• Confidence: 99% confidence
• Finding: The implemented behavior appears narrower and different than advertised: fixed 1h timeframe only, spot API instead of Futures, only SMA crossover logic, undeclared local signal file reads, and extra API endpoints beyond the described scanner. This mismatch is dangerous because it undermines informed consent, can expose local data through filesystem access, and may lead users to rely on incorrect market assumptions.

Tp4

High

• Category: MCP Tool Poisoning
• Confidence: 96% confidence
• Finding: The implemented behavior appears narrower and different than advertised: fixed 1h timeframe only, spot API instead of Futures, only SMA crossover logic, undeclared local signal file reads, and extra API endpoints beyond the described scanner. This mismatch is dangerous because it undermines informed consent, can expose local data through filesystem access, and may lead users to rely on incorrect market assumptions.

Tp4

High

• Category: MCP Tool Poisoning
• Confidence: 96% confidence
• Finding: The implemented behavior appears narrower and different than advertised: fixed 1h timeframe only, spot API instead of Futures, only SMA crossover logic, undeclared local signal file reads, and extra API endpoints beyond the described scanner. This mismatch is dangerous because it undermines informed consent, can expose local data through filesystem access, and may lead users to rely on incorrect market assumptions.

Tp4

High

• Category: MCP Tool Poisoning
• Confidence: 99% confidence
• Finding: The implemented behavior appears narrower and different than advertised: fixed 1h timeframe only, spot API instead of Futures, only SMA crossover logic, undeclared local signal file reads, and extra API endpoints beyond the described scanner. This mismatch is dangerous because it undermines informed consent, can expose local data through filesystem access, and may lead users to rely on incorrect market assumptions.

Tp4

High

• Category: MCP Tool Poisoning
• Confidence: 95% confidence
• Finding: The implemented behavior appears narrower and different than advertised: fixed 1h timeframe only, spot API instead of Futures, only SMA crossover logic, undeclared local signal file reads, and extra API endpoints beyond the described scanner. This mismatch is dangerous because it undermines informed consent, can expose local data through filesystem access, and may lead users to rely on incorrect market assumptions.

Tp4

High

• Category: MCP Tool Poisoning
• Confidence: 95% confidence
• Finding: The implemented behavior appears narrower and different than advertised: fixed 1h timeframe only, spot API instead of Futures, only SMA crossover logic, undeclared local signal file reads, and extra API endpoints beyond the described scanner. This mismatch is dangerous because it undermines informed consent, can expose local data through filesystem access, and may lead users to rely on incorrect market assumptions.

Context-Inappropriate Capability

High

• Confidence: 100% confidence
• Finding: Hardcoded Binance API credentials are embedded directly in the skill file, making them trivially extractable by anyone with file access, logs, backups, or repository history. In a trading context this is especially dangerous because the credentials authorize authenticated exchange actions, potentially including account access and order placement.

Missing User Warnings

High

• Confidence: 99% confidence
• Finding: Using hardcoded exchange credentials for authenticated requests without clear user disclosure creates both a secret-exposure risk and an unauthorized-action risk. Anyone reusing or obtaining the file may unknowingly operate with embedded credentials or exfiltrate them for direct account abuse.

Description-Behavior Mismatch

High

• Confidence: 98% confidence
• Finding: The skill is presented as a market scanner, but this code also places leveraged futures orders, manages positions, and closes trades automatically. That mismatch is dangerous because users may grant trust or run the skill expecting passive analysis, while it can perform destructive financial actions with real exchange APIs if demo mode is changed or reused elsewhere.

Missing User Warnings

High

• Confidence: 97% confidence
• Finding: The skill enables automatic leveraged trading without per-trade confirmation, while configured for aggressive behavior and with stop loss disabled by default. In this context, silent execution is a serious safety issue because market orders can create immediate financial loss before the user realizes the tool is acting autonomously.

Missing User Warnings

High

• Confidence: 99% confidence
• Finding: The code hardcodes an API key and performs signed exchange requests without any prominent warning, consent flow, or safety disclosure. This is dangerous because users may run the skill without realizing it can authenticate to exchange endpoints and potentially act on account data or trading permissions.

Description-Behavior Mismatch

High

• Confidence: 99% confidence
• Finding: The skill is described as a scanner, but this code contains full trade execution and position-closing logic for Binance Futures orders. That mismatch is dangerous because users may grant trust or credentials expecting passive market analysis while the code is capable of taking direct trading actions on their account.

Description-Behavior Mismatch

High

• Confidence: 98% confidence
• Finding: The auto-trading path expands the skill from signal generation into autonomous execution of futures trades. In the context of a tool presented as a scanner, this creates a harmful capability gap where financial loss can occur without users understanding they enabled order placement.

Missing User Warnings

High

• Confidence: 99% confidence
• Finding: Automatic trade execution can place market orders without a per-order confirmation prompt, creating a direct path to unintended financial loss. This is particularly dangerous for futures trading, where leverage and rapid price movement can amplify losses beyond what users expect from a scanning tool.

Description-Behavior Mismatch

High

• Confidence: 98% confidence
• Finding: The main loop automatically executes trades from generated signals when autoTrade is enabled, turning scan results into live actions. This is especially risky because the overall skill description suggests an analytical scanner, not an autonomous trading bot operating on a derivatives exchange.

Context-Inappropriate Capability

High

• Confidence: 100% confidence
• Finding: Hardcoded Binance API credentials are embedded directly in source code. Even if `USE_DEMO` is currently true, exposed credentials can be copied, reused, or accidentally promoted to production patterns later, and they normalize unsafe secret handling in code distributed to others.

Missing User Warnings

High

• Confidence: 99% confidence
• Finding: The code uses hardcoded API credentials without any warning, consent prompt, or disclosure to the user. This is dangerous because users may run the skill unaware that private exchange credentials are embedded and actively used for authenticated requests.

Missing User Warnings

High

• Confidence: 98% confidence
• Finding: Automatic trading is enabled by default, and the main loop will execute market orders based on generated signals without explicit confirmation. This is dangerous because default-on auto-execution can cause unintended leveraged trades immediately after startup.

Description-Behavior Mismatch

High

• Confidence: 95% confidence
• Finding: The manifest claims confirmation using Pivot SuperTrend, RSI, volume, and confluence, but the implemented scan logic only evaluates SMA 8/21 cross/touch conditions. This discrepancy is dangerous because it misrepresents how signals are produced, causing users to trust trades based on controls that do not actually exist.

Missing User Warnings

High

• Confidence: 100% confidence
• Finding: Hardcoded API credentials in source code are a direct secret-exposure vulnerability. Anyone with access to the file can reuse the credentials to access the linked Binance account on the configured environment, potentially reading balances and placing or managing futures orders.

Context-Inappropriate Capability

High

• Confidence: 98% confidence
• Finding: The code includes signed account-access and trading-request capability via API key/secret handling even though the skill is presented as a scanner. In this context, unnecessary authenticated exchange access greatly increases risk because the skill can query private account data and submit trades beyond the user's likely expectations.

Description-Behavior Mismatch

High

• Confidence: 98% confidence
• Finding: The skill is described as a scanner, but it contains active trade execution and position-closing functions that submit authenticated Binance Futures market orders. This mismatch is dangerous because users may grant trust or run the skill expecting passive analysis while it can perform irreversible financial actions on their account.

Static analysis

Detected: suspicious.dangerous_exec, suspicious.exposed_secret_literal

Shell command execution detected (child_process).

Critical

• Code: suspicious.dangerous_exec
• Location: realtime-scanner.js:155

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-aggressive.mjs:13

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-all.mjs:13

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-final-20x.mjs:53

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-final.mjs:13

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-robot.mjs:13

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-smc.mjs:53

File appears to expose a hardcoded API secret or token.

Critical

• Code: suspicious.exposed_secret_literal
• Location: apex-ia-trader.mjs:14