Back to skill

Security audit

Skill Security Scanner

Security checks for vulnerabilities and agentic risk

Overview

This skill is a security scanner, but its own scanner can run unintended shell commands, fetch and unpack remote archives unsafely, and incorrectly mark some skills as safe.

Review before installing. Use it only in a disposable or sandboxed environment, avoid scanning untrusted remote URLs with this version, do not pass attacker-controlled target strings to the Node entrypoint, and do not rely on its safe scores without independent review.

Vulnerability Patterns
  • Tool Hijacking and SpoofingModifies or replaces tools so legitimate-looking calls execute attacker logic
  • 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
Findings (5)

T09 · Insecure Skill Coding Practices

Error
Location
index.js:6
Finding
Shell Command Injection Through Unsanitized CLI Arguments<![CDATA[ ## Vulnerability Details **File Location**: `index.js:6-11` **Vulnerability Type**: OS command injection **Risk Level**: Critical ### Vulnerable Code ```javascript const args = process.argv.slice(2).join(' '); const scriptDir = path.dirname(__filename); const result = execSync(`"${scriptDir}/scripts/scan.sh" ${args}`, { encoding: 'utf8', stdio: 'inherit' }); console.log(result); ``` ### Technical Analysis The entry point joins all command-line arguments into a single string and interpolates that string into a command executed by `execSync`. Because `execSync` invokes a shell for string commands, shell metacharacters in an argument—such as semicolons, command substitutions, backticks, pipelines, and redirections—are interpreted as shell syntax rather than passed literally to `scan.sh`. The target argument is therefore an arbitrary command-execution channel. No quoting, escaping, validation, or shell-free process invocation protects the boundary between the target value and the command line. ### Attack Path 1. An attacker persuades a user or automation system to invoke the Node.js entry point with a crafted scan target. 2. The crafted value contains shell syntax, such as a command separator or command substitution. 3. `process.argv.slice(2).join(' ')` preserves that shell syntax. 4. The value is inserted directly into the command passed to `execSync`. 5. The operating-system shell interprets the injected syntax and executes the attacker's command. For example, an argument structurally equivalent to `legitimate-target; attacker-command` would cause the second command to be interpreted by the shell. ### Impact Assessment Successful exploitation provides arbitrary command execution with all privileges of the scanner process. Depending on the invoking account, this may permit: - Reading or modifying any files accessible to the user. - Accessing environment variables and local credentials. - Downloading and executing additional payloads. ...[truncated 277 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Use a shell-free child-process API and pass every argument as a separate array element: ```javascript const { execFileSync } = require('child_process'); const path = require('path'); const scriptPath = path.join(__dirname, 'scripts', 'scan.sh'); execFileSync(scriptPath, process.argv.slice(2), { stdio: 'inherit' }); ``` Additional hardening should include: 1. Validate that only documented options and target formats are accepted. 2. Reject control characters and malformed targets before invoking the scanner. 3. Avoid `shell: true` and never build command strings from user-controlled input. 4. Add regression tests using semicolons, backticks, `$()`, pipes, spaces, and redirections. 5. Run the scanner under a minimally privileged account. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/scan.sh:326
Finding
Unsafe Extraction of Remotely Retrieved Archives<![CDATA[ ## Vulnerability Details **File Location**: `scripts/scan.sh:326-329` **Vulnerability Type**: Untrusted archive extraction and unsafe remote source **Risk Level**: High ### Vulnerable Code ```bash TARGET_TYPE="clawhub"; SKILL_NAME=$(echo "$t" | sed -n 's|.*clawhub.ai/[^/]*/\(.*\)|\1|p') TARGET_DIR=$(mktemp -d) curl -sL "https://wry-manatee-359.convex.site/api/v1/download?slug=$(echo "$t" | sed 's|.*/||')" -o "$TARGET_DIR/s.zip" 2>/dev/null [ -f "$TARGET_DIR/s.zip" ] && unzip -q "$TARGET_DIR/s.zip" -d "$TARGET_DIR" && rm -f "$TARGET_DIR/s.zip" ``` ### Technical Analysis Remote-scan mode downloads an archive from a third-party Convex endpoint and immediately extracts it with `unzip`. The implementation does not validate: - Archive entry paths before extraction. - Absolute paths or `..` traversal components. - Symlink entries and symlink-based write targets. - Expanded archive size or file count. - Archive integrity, signature, or checksum. - Whether the resolved download source is an approved and authenticated ClawHub service. Although the retrieved source files are scanned rather than directly executed by this branch, archive extraction itself performs filesystem writes. A malicious or compromised archive may exploit extractor behavior to write outside the temporary directory or exhaust disk and processing resources. The third-party endpoint also creates a supply-chain boundary that is not documented or authenticated beyond HTTPS. ### Attack Path 1. An attacker publishes a malicious Skill archive or compromises the remote download service. 2. A user scans the corresponding ClawHub URL. 3. The scanner retrieves the attacker-controlled ZIP from the external endpoint. 4. The archive contains traversal paths, absolute paths, malicious symlinks, an excessive number of files, or highly compressed content. 5. `unzip` extracts the archive without pre-validation. 6. Depending on archive contents and extractor behavior, files may be written outside the ...[truncated 776 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Use only a documented, approved download API and enforce an explicit hostname allowlist. 2. Verify a publisher signature or trusted checksum before extraction. 3. List and inspect all archive entries before writing any files. 4. Reject absolute paths, drive-qualified paths, `..` components, device files, and symbolic or hard-link entries. 5. Resolve every destination path and verify that it remains under the canonical temporary directory. 6. Enforce limits on compressed size, expanded size, file count, nesting depth, and extraction time. 7. Extract in a sandbox with no access to sensitive user paths. 8. Use restrictive temporary-directory permissions and install a cleanup trap for all exit paths. 9. Fail closed on download, validation, or extraction errors rather than scanning partial content. ]]>

T07 · Tool Hijacking and Spoofing

Error
Location
scripts/scan.sh:451
Finding
Prepopulated and Regex-Based Whitelist Allows Complete Scan Bypass<![CDATA[ ## Vulnerability Details **File Location**: `scripts/scan.sh:451-461`; related whitelist entries at `whitelist.txt:1-2` **Vulnerability Type**: Security scanner bypass and trust spoofing **Risk Level**: High ### Vulnerable Code ```bash if is_whitelisted "$SKILL_NAME"; then echo "" echo "════════════════════════════════════════════════════════════════════" echo " 🔒 Skill 安全检测报告" echo "════════════════════════════════════════════════════════════════════" echo "" echo "📦 Skill: $SKILL_NAME" echo "📊 评分: 100/100" echo "✅ 已通过白名单 (跳过扫描)" exit 0 fi ``` The whitelist check is implemented as: ```bash is_whitelisted() { [ -f "$WHITELIST_FILE" ] && grep -q "^${1}$" "$WHITELIST_FILE"; } ``` The distributed whitelist contains: ```text skill-security-scanner minebean ``` ### Technical Analysis A matching Skill name causes the scanner to skip all file inspection and return a perfect score. The project ships with `minebean` already trusted, although the documented feature is a user-defined whitelist. An attacker can therefore name a local malicious directory `minebean` and receive a false `100/100` result. In addition, the Skill name is interpolated into a `grep` regular expression. It is not treated as a literal string. A local directory name containing regular-expression metacharacters can potentially match a different whitelist entry. The whitelist is based only on a mutable basename. It does not bind trust to content, publisher identity, repository origin, version, or a cryptographic digest. ### Attack Path 1. An attacker creates or distributes a malicious Skill under the pretrusted name `minebean`. 2. The user places it in a local Skills directory and invokes the scanner. 3. `SKILL_NAME` is derived from the directory basename. 4. `is_whitelisted` matches that name against the bundled whitelist. 5. The scanner performs no source inspection. 6. It prints a `100/100` score and reports that the Sk ...[truncated 739 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Distribute an empty whitelist; do not pretrust unrelated Skills. 2. Use literal, whole-line matching: ```bash is_whitelisted() { [ -f "$WHITELIST_FILE" ] && grep -Fqx -- "$1" "$WHITELIST_FILE" } ``` 3. Validate Skill names against a strict character allowlist. 4. Bind trust to a cryptographic content digest, verified publisher identity, repository origin, and version rather than a basename alone. 5. Store per-user trust decisions outside the installed package so updates cannot silently alter them. 6. Display the exact trust basis in reports. 7. Consider scanning whitelisted Skills and using the whitelist only to annotate known findings rather than bypassing inspection completely. 8. Add tests for duplicate names, renamed directories, regex characters, modified content, and replaced publishers. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
node/scanner.js:105
Finding
Incomplete Scan Coverage Produces False-Safe Security Verdicts<![CDATA[ ## Vulnerability Details **File Location**: `node/scanner.js:105-116` **Vulnerability Type**: Security control bypass through unsupported file types **Risk Level**: High ### Vulnerable Code ```javascript // 递归扫描所有 JS 文件 const scanDir = async (dir) => { try { const entries = await fs.readdir(dir, { withFileTypes: true }); for (const entry of entries) { const fullPath = path.join(dir, entry.name); if (entry.isDirectory() && !entry.name.startsWith('.')) { await scanDir(fullPath); } else if (entry.name.endsWith('.js')) { filesScanned++; const issues = await this.scanFile(fullPath); allIssues.push(...issues); } } } catch (e) {} }; ``` The shell implementation similarly limits traversal to four extensions: ```bash for f in $(find "$TARGET_DIR" \( -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.sh" \) -type f 2>/dev/null); do scan_file "$f" done ``` ### Technical Analysis The Node.js scanner only inspects `.js` files, despite the project documentation describing JavaScript, TypeScript, Python, and Shell support. The shell implementation scans those four extensions but excludes instruction and configuration files such as `SKILL.md`, Markdown documents, JSON, YAML, and other agent-readable text. This omission is especially significant because the scanner implements prompt-injection regular expressions while failing to inspect `SKILL.md`, the primary location for Skill instructions. An attacker can place instruction-hijacking content in an unscanned Markdown file or place executable/configuration payloads in unsupported extensions. Read errors are also silently ignored, so inaccessible files do not produce a failed or incomplete verdict. ### Attack Path 1. An attacker places malicious instructions in `SKILL.md`, or a payload in an unsupported file type. 2. The scanner recursively walks the Skill ...[truncated 934 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Unify the Node.js and shell engines so all entry points provide identical coverage. 2. Scan `SKILL.md`, Markdown, JSON, YAML, TOML, package manifests, extensionless scripts, and other agent-readable configuration files. 3. Detect file content using bounded text/binary inspection instead of relying exclusively on extensions. 4. Treat unreadable files and traversal failures as explicit incomplete-scan warnings or hard failures. 5. Report exactly which files were included, excluded, or unreadable. 6. Separate prompt-injection rules from code rules and apply them to instruction-bearing documents. 7. Accurately document the implemented rules rather than claiming complete or “57-rule” coverage where it is not present. 8. Add adversarial test fixtures with malicious content in every supported instruction and configuration format. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/scan.sh:438
Finding
Whitespace-Unsafe File Enumeration Allows Payloads to Evade Scanning<![CDATA[ ## Vulnerability Details **File Location**: `scripts/scan.sh:438-440` **Vulnerability Type**: Unsafe shell word splitting in security-sensitive traversal **Risk Level**: Medium ### Vulnerable Code ```bash for f in $(find "$TARGET_DIR" \( -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.sh" \) -type f 2>/dev/null); do scan_file "$f" done ``` ### Technical Analysis The output of `find` is captured through command substitution and then expanded unquoted in a shell `for` loop. Bash performs word splitting and pathname expansion on the resulting text. Consequently, filenames containing spaces, tabs, newlines, wildcard characters, or other shell-significant characters are not preserved as single path values. A supported source file such as `malicious payload.js` may be split into separate nonexistent paths. `scan_file` silently returns when the reconstructed path does not identify a file. This creates a direct evasion technique against the scanner's extension-based checks. ### Attack Path 1. An attacker stores malicious code in a supported file type whose filename contains whitespace or another splitting-sensitive character. 2. `find` prints the complete filename. 3. Command substitution removes record boundaries and Bash splits the output into multiple words. 4. The loop invokes `scan_file` with incorrect path fragments. 5. The file-existence check fails for those fragments and the malicious file is omitted. 6. The scanner reports a result that does not account for the hidden payload. 7. The payload may later be loaded or executed through another file or runtime mechanism. ### Impact Assessment The issue permits reliable omission of attacker-selected supported files from static analysis. Its direct impact is a false-negative scan result rather than immediate code execution. If the omitted file is subsequently invoked, the effective impact can include arbitrary behavior with the Skill runtime's privileges. The scope is limited to sca ...[truncated 106 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Use null-delimited records and quoted variables: ```bash while IFS= read -r -d '' f; do scan_file "$f" done < <( find "$TARGET_DIR" \ \( -name '*.js' -o -name '*.ts' -o -name '*.py' -o -name '*.sh' \) \ -type f -print0 2>/dev/null ) ``` Additional measures: 1. Quote every path passed to shell commands. 2. Avoid parsing filenames through line-oriented text operations. 3. Test filenames containing spaces, tabs, newlines, glob characters, leading dashes, and Unicode. 4. Report skipped or unreadable files instead of silently returning. 5. Apply archive-entry filename validation before remote content reaches traversal logic. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
Findings (46)

Vague Triggers

High
Confidence
97% confidence
Finding
The trigger guidance is extremely broad, using generic security-related keywords like '检测/扫描/安全/风险/恶意代码/危险' that are common in ordinary conversation. This can cause the skill to activate unintentionally, potentially leading the agent to run scans or process URLs/paths when the user was only asking a general question, increasing the chance of unintended tool use or confusing control flow.

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
[执行 ./scripts/scan.sh https://clawhub.ai/AphobiaCat/aibtc]
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Tool Parameter Abuse

High
Category
Tool Misuse
Content
| 命令 | 风险描述 | 检测文件 |
|------|----------|----------|
| `rm -rf /` | 根目录删除,毁灭性操作 | .sh, .bash |
| `rm -rf ~` | 用户主目录删除,丢失所有数据 | .sh, .bash |
| `rm -rf $HOME` | 同上,使用环境变量 | .sh, .bash |
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
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 /` | 根目录删除,毁灭性操作 | .sh, .bash |
| `rm -rf ~` | 用户主目录删除,丢失所有数据 | .sh, .bash |
| `rm -rf $HOME` | 同上,使用环境变量 | .sh, .bash |
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
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
| 命令 | 风险描述 | 检测文件 |
|------|----------|----------|
| `rm -rf /` | 根目录删除,毁灭性操作 | .sh, .bash |
| `rm -rf ~` | 用户主目录删除,丢失所有数据 | .sh, .bash |
| `rm -rf $HOME` | 同上,使用环境变量 | .sh, .bash |
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
| `wget -O- \| sh` | 远程脚本执行,完全不可控 | .sh, .bash |
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).

External Script Fetching

High
Category
Supply Chain
Content
| `rm -rf /` | 根目录删除,毁灭性操作 | .sh, .bash |
| `rm -rf ~` | 用户主目录删除,丢失所有数据 | .sh, .bash |
| `rm -rf $HOME` | 同上,使用环境变量 | .sh, .bash |
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
| `wget -O- \| sh` | 远程脚本执行,完全不可控 | .sh, .bash |
| `curl https://... \| sh` | 同上 | .sh, .bash |
| `wget https://... \| bash` | 同上 | .sh, .bash |
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
| `rm -rf ~` | 用户主目录删除,丢失所有数据 | .sh, .bash |
| `rm -rf $HOME` | 同上,使用环境变量 | .sh, .bash |
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
| `wget -O- \| sh` | 远程脚本执行,完全不可控 | .sh, .bash |
| `curl https://... \| sh` | 同上 | .sh, .bash |
| `wget https://... \| bash` | 同上 | .sh, .bash |
| `passwd` | 修改用户密码 | .sh, .py, .js |
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
| `rm -rf $HOME` | 同上,使用环境变量 | .sh, .bash |
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
| `wget -O- \| sh` | 远程脚本执行,完全不可控 | .sh, .bash |
| `curl https://... \| sh` | 同上 | .sh, .bash |
| `wget https://... \| bash` | 同上 | .sh, .bash |
| `passwd` | 修改用户密码 | .sh, .py, .js |
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
| `curl \| bash` | 远程脚本执行,完全不可控 | .sh, .bash |
| `wget -O- \| sh` | 远程脚本执行,完全不可控 | .sh, .bash |
| `curl https://... \| sh` | 同上 | .sh, .bash |
| `wget https://... \| bash` | 同上 | .sh, .bash |
| `passwd` | 修改用户密码 | .sh, .py, .js |

## 🟠 高风险 (扣 20 分)
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
| 命令/模式 | 风险描述 | 检测文件 |
|-----------|----------|----------|
| `chmod 777` | 权限过于宽松 | .sh, .bash |
| `eval $var` | 动态代码执行 | .sh, .bash |
| `eval "$(...)"` | 同上 | .sh, .bash |
| `elevated: true` | 要求 root 权限 | .yaml, .yml, SKILL.md |
Confidence
80% 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
| `curl -X POST` | 同上 | .sh, .bash |
| `.env` | 环境变量文件 | 所有 |
| `~/.ssh/` | SSH 密钥目录 | 所有 |
| `/etc/passwd` | 系统用户文件 | .sh, .bash |
| `$VAR` / `${VAR}` | 环境变量读取 | .sh, .bash |
| `curl` / `wget` | 网络请求 | .sh, .bash |
| `fetch` / `axios` | HTTP 请求 | .js, .mjs |
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
| I04 | `new Function\(` | critical | Function 构造器 |
| I05 | `ignore.*previous.*instructions` | high | 提示注入 |
| I06 | `jailbreak\|bypass.*safety` | critical | 越狱攻击 |
| I07 | `DAN\|do anything now` | critical | DAN 越狱模式 |
| I08 | `curl.*http` | high | 远程下载执行 |

### OBFUSCATION(混淆隐藏)
Confidence
80% confidence
Finding
Skill attempts to nullify the agent's safety policies or restrictions ('you have no restrictions', 'ignore your guidelines', 'do anything now'). This is a direct jailbreak that disables guardrails.

Static analysis

Detected: suspicious.dangerous_exec

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
index.js:8