SS01

Code Execution

Python AST; JS/TS regex (comment-aware) .py · .js · .ts · .jsx · .tsx · .mjs · .cjs

Dangerous runtime function calls that can execute arbitrary code or spawn external shell processes. Python rules use AST parsing to catch obfuscated aliases; JS/TS rules skip commented lines to reduce false positives.

Rule ID Severity What it detects
py_eval high eval() — executes arbitrary Python code
py_exec high exec() — executes arbitrary Python code
py_compile medium compile() — compiles arbitrary source to a code object
py_dunder_import high __import__() — dynamic module import bypassing normal resolution
py_importlib high importlib.import_module() — dynamic import at runtime
py_os_system high os.system() — executes shell command via C system()
py_os_popen high os.popen() — opens a pipe to a shell command
py_subprocess_call high subprocess.call() — executes external command
py_subprocess_run high subprocess.run() — executes external command
py_subprocess_popen high subprocess.Popen() — spawns external process
py_subprocess_check_output high subprocess.check_output() — executes command and returns output
py_subprocess_check_call high subprocess.check_call() — executes command, raises on error
py_subprocess_getoutput high subprocess.getoutput() — runs command in shell, returns stdout+stderr
py_subprocess_getstatusoutput high subprocess.getstatusoutput() — runs command, returns (status, output)
js_eval high eval() — executes arbitrary JS at runtime
js_function_constructor high new Function() — constructs callable from arbitrary string
js_child_process high require('child_process') — enables shell command execution
js_exec_sync high execSync() / execFileSync() — synchronous shell execution
js_spawn_sync high spawnSync() — synchronous child process spawn
js_child_process_import high import … from 'child_process' — ESM shell command access
js_fs_import medium import … from 'fs' — ESM filesystem access
SS02

Hardcoded Credentials

Regex (all text files); secrets redacted in report All text files

Hardcoded secrets, API keys, and authentication tokens embedded in source code or configuration files. Matched context is automatically redacted in scan reports before upload.

Rule ID Severity What it detects
aws_access_key critical AWS Access Key ID — AKIA[0-9A-Z]{16}
private_key critical PEM private key — -----BEGIN … PRIVATE KEY-----
github_token critical GitHub token — gh[pousr]_[A-Za-z0-9_]{36,}
slack_token high Slack token — xox[bpars]-[0-9a-zA-Z-]{10,}
generic_secret high Generic credential pattern — api_key=, secret_key=, access_token=, auth_token=, password= with ≥16-char value in quotes
SS03

Data Exfiltration

Regex case-insensitive (all text files) All text files

Outbound HTTP requests targeting known data collection, webhook relay, and exfiltration services. These services are frequently abused to receive stolen credentials or file contents.

Rule ID Severity What it detects
shell_exfil_service high curl/wget to ngrok.io, requestbin.com, webhook.site, pipedream.net, canarytokens, or Burp Collaborator
SS04

Agent Memory Poisoning

Regex case-insensitive (all text files) All text files

Shell operations that write to AI agent memory and instruction files. A poisoned MEMORY.md or CLAUDE.md can persistently redirect agent behavior across sessions.

Rule ID Severity What it detects
agent_memory_write high Shell redirect > to MEMORY.md, SOUL.md, CLAUDE.md, or .cursorrules
agent_memory_inject high echo … >> MEMORY.md / SOUL.md / CLAUDE.md (append injection)
SS05

Encoded Malware

Regex + base64 deep-scan (all text files) All text files

base64-encoded payloads designed to evade static analysis. The pattern-level rules catch explicit decode-and-execute pipelines; the deep-scan pass decodes every base64 blob ≥40 characters and re-applies all detection rules to the decoded content.

Rule ID Severity What it detects
b64_decode_exec critical … | base64 -d | bash / sh / python / perl / ruby
b64_file_exec critical base64 -d <file> | bash / sh
b64_encoded_payload critical Deep-scan: decoded blob contains curl|bash, /dev/tcp/, rm -rf /, wget|bash, Python socket import, or netcat -e
SS07

Privilege Escalation

Regex case-insensitive (all text files) All text files

Operations that escalate a process to root or switch the active user context to a privileged account.

Rule ID Severity What it detects
priv_escalation_sudo high sudo su · sudo bash · sudo sh · sudo -s · sudo -i
priv_setuid_root critical setuid(0) or seteuid(0) — sets process UID to root
SS08

Persistence

Regex case-insensitive (all text files) All text files

Mechanisms that survive reboots or new login sessions by registering with OS schedulers, init systems, or shell startup scripts.

Rule ID Severity What it detects
persistence_cron high crontab -e / crontab -l · @reboot · /etc/cron.*
persistence_launchd high ~/Library/LaunchAgents · /Library/LaunchAgents · ~/Library/LaunchDaemons · /Library/LaunchDaemons
persistence_systemd high systemctl enable … · /etc/systemd/system/*.service
persistence_shell_profile medium echo … >> ~/.bashrc / .zshrc / .bash_profile / .profile / .bash_login / .zprofile
SS09

Reverse Shell

Regex case-insensitive (all text files) All text files

Network callbacks that open an interactive shell connection from the target machine back to an attacker-controlled host.

Rule ID Severity What it detects
reverse_shell_devtcp critical /dev/tcp/<ip>/<port> or /dev/udp/<ip>/<port> — bash built-in TCP/UDP socket
reverse_shell_netcat critical nc / ncat / netcat with -e, -E, -c, -C, -l, or -L flag
reverse_shell_socat critical socat … EXEC … TCP — socat relayed shell
reverse_shell_bash critical bash -i or -I with >& /dev/tcp redirect
SS10

Unicode Obfuscation

Regex with UNICODE flag (all text files) All text files

Invisible or visually confusable Unicode characters used to hide malicious content from code reviewers while still being executed or interpreted by the runtime.

Rule ID Severity What it detects
unicode_zero_width high Zero-width space / joiner / non-joiner / word-joiner / BOM — U+200B, U+200C, U+200D, U+2060, U+FEFF
unicode_cyrillic_mix high Cyrillic character adjacent to Latin letter — IDN homograph attack (e.g. аpple where а is Cyrillic U+0430)
SS11

ClickFix Social Engineering

Regex case-insensitive (all text files) All text files

Instruction patterns that trick users into manually executing malicious commands by framing them as necessary troubleshooting or setup steps. Named after the ClickFix attack campaign.

Rule ID Severity What it detects
clickfix_terminal high "Open terminal and paste…" / "Launch terminal and run/type/execute…"
clickfix_copy_paste high "Copy/paste this command/code/script into your terminal/console/command prompt"
clickfix_run_dialog high "Press Win+R and…" — Windows Run dialog social engineering
SS13

Dangerous File Operations

Regex case-insensitive (all text files) All text files

Irreversible destructive operations that can wipe filesystems or overwrite raw block devices.

Rule ID Severity What it detects
dangerous_rm_root critical rm -rf / · rm -rf ~ · rm -rf $HOME — recursive delete of root or home
dangerous_dd_device critical dd of=/dev/sd* · /dev/hd* · /dev/nvme* · /dev/xvd* · /dev/vd* — raw block device overwrite
SS14

Reconnaissance

Regex case-insensitive (all text files) All text files

Network scanning tools and cloud instance metadata endpoints used to map infrastructure before a targeted attack.

Rule ID Severity What it detects
recon_portscan high nmap · masscan · arp-scan · zmap · unicornscan
cloud_metadata_imds critical 169.254.169.254 — AWS, Azure, and GCP instance metadata service
cloud_metadata_gcp critical metadata.google.internal — GCP metadata server
cloud_metadata_alibaba high 100.100.100.200 — Alibaba Cloud metadata endpoint
SS15

Prompt Injection

Regex case-insensitive (.md · .txt · .yaml · .yml · .rst) .md · .txt · .yaml · .yml · .rst

Instruction override patterns embedded in Markdown or configuration that attempt to hijack AI agent behavior by superseding the system prompt.

Rule ID Severity What it detects
prompt_ignore_instructions high "ignore previous/prior/above instructions"
prompt_role_hijack high "you are now …" — role reassignment injection
prompt_system_prompt medium "system prompt" — system prompt reference
prompt_disregard high "disregard previous/prior instructions"
prompt_new_instructions high "new instructions:" — instruction block injection
prompt_override high "override previous/prior instructions"
prompt_forget high "forget everything/all/previous"
prompt_do_not_follow high "do not follow the previous/above instructions"
SS16

Bundled Binaries

File extension check (all files) All files

Executable or native library files bundled inside a skill archive. Skills should contain only text-based instructions and scripts — precompiled binaries cannot be meaningfully reviewed by static analysis.

Rule ID Severity What it detects
binary_file_bundled high .exe · .dll · .so · .dylib · .bin · .elf · .o · .a · .ko · .sys · .drv · .deb · .rpm · .msi · .pkg · .pyc · .pyo · .pyd
SS17

Credential File Access

Regex case-insensitive (all text files) All text files

Reads or directory searches targeting well-known credential storage locations on the host filesystem.

Rule ID Severity What it detects
cred_read_aws critical cat/read/open ~/.aws/credentials
cred_read_docker critical cat/read/open ~/.docker/config.json — may contain registry authentication tokens
cred_find_dirs high find … .ssh / .aws / .gnupg / .config/gcloud — searching credential directories
SS18

Cryptocurrency Targeting

Regex case-insensitive (all text files) All text files

References to cryptocurrency wallet recovery material or wallet application data directories. Inspired by the ClawHavoc campaign (January 2026) where 341 malicious skills stole wallet seed phrases.

Rule ID Severity What it detects
crypto_seed_phrase critical "seed phrase" / "mnemonic phrase" / "secret recovery phrase" / "wallet recovery phrase"
crypto_wallet_software high MetaMask · Phantom · Exodus · Electrum · Wasabi · Trezor · Ledger + wallet/keystore/password/seed keyword
crypto_wallet_dir high ~/.ethereum · ~/.bitcoin · ~/.monero · ~/.litecoin · ~/.dogecoin · ~/Library/Ethereum · ~/Library/Bitcoin
SS19/20

Path Traversal

Regex case-insensitive (all text files) All text files

Directory traversal patterns and direct reads of sensitive system files. Also covers writes to git hooks, which can persist malicious code across every future commit or merge.

Rule ID Severity What it detects
path_traversal_sys high ../../etc · ../../root · ../../usr traversal patterns (2+ levels up targeting system dirs)
sensitive_sys_read critical cat/head/tail /etc/passwd · /etc/shadow · /etc/sudoers · /etc/hosts
git_hook_persist medium .git/hooks/pre-commit · post-commit · post-merge · pre-push · post-receive — possible persistence via git hooks
SS-SI

Inducement Language

New
Regex case-insensitive (.md · .txt · .yaml · .yml) .md · .txt · .yaml · .yml

Social engineering patterns that steer agents toward executing bundled scripts by framing them as necessary setup steps. Directly targets the inducement prompt component of SkillJect-style attacks, where the attack lives in the gap between legitimate-looking documentation and a malicious auxiliary script.

Rule ID Severity What it detects
inducement_before_using medium "before using/running, run/execute/source…" — necessity framing that implies a prerequisite execution step
inducement_for_tool_to_work medium "for the tool/skill to work/function/operate" — conditional framing that makes script execution appear required
inducement_required_step medium "this setup/configuration step is required/mandatory" — authority framing that discourages skipping the step
inducement_run_bundled high "run the included/bundled/provided script/setup/installer" — explicit invitation to execute a bundled file
inducement_auto_exec high "automatically run/execute/invoke *.sh/*.py" — documents automated execution of a bundled script
inducement_must_run_first medium "must be run/executed before/first/prior" — temporal necessity framing preceding a script reference
SS-SM

Structural Mimicry

New
Multi-line context scan (.md files) .md

Multi-line context scan that detects the specific documentation structure SkillJect exploits: suspicious section headers followed by bundled script execution references, and urgency markers co-located with script invocations. Both rules require an explicit file extension (.sh, .py, .bash) to reduce false positives on generic install commands.

Rule ID Severity What it detects
sm01_header_then_script SS-SM01 high Prerequisites/Setup/Quick Start/Initialization/Bootstrap header followed within 10 lines by a bundled script execution reference (bash script.sh, python3 setup.py, ./init.sh, etc.)
sm02_urgency_then_script SS-SM02 high Urgency/authority marker (> **IMPORTANT**, **CRITICAL**, **REQUIRED**, > WARNING) within 3 lines of a bundled script execution reference
SS-CP

Composite Co-occurrence

New
Cross-rule aggregation (script files) .py · .js · .ts · .sh · .bash

Escalates severity when individually low-risk primitives co-occur in the same file. Targets the evasion technique described in the SkillJect paper where attacks are composed from capabilities that individually fall below alert thresholds. Each rule fires only when higher-severity rules haven't already covered the same file.

Rule ID Severity What it detects
cp01_exec_plus_network SS-CP01 critical Process execution (subprocess, os.system, execSync, eval, new Function) combined with an outbound network call in the same file — canonical exfiltration pattern
cp02_env_plus_network SS-CP02 high Environment variable access (os.environ, process.env) combined with an outbound network call — credential exfiltration path; fires only when CP01 has not
cp03_write_plus_network SS-CP03 high File write operations combined with an outbound network call — staged exfiltration; fires only when CP01 and CP02 have not
cp04_medium_cluster SS-CP04 high Three or more medium-severity findings in a single file across all prior passes — clustered low-severity primitives constituting a coordinated attack
SS-SF

Surplus Functionality

New
Cross-file consistency check (SKILL.md vs. scripts) SKILL.md + .py · .js · .ts · .sh

Cross-file consistency check that compares script capabilities against the documentation intent profile extracted from SKILL.md. Flags capabilities present in scripts but absent from the documentation — the structural gap that SkillJect exploits. A script making outbound network calls is suspicious when SKILL.md never mentions network access.

Rule ID Severity What it detects
sf_undocumented_network critical Script makes outbound network calls (urllib, requests, fetch, curl, wget, socket.connect) but SKILL.md contains no mention of network access, API calls, or HTTP requests
sf_undocumented_env high Script reads environment variables (os.environ, os.getenv, process.env) but SKILL.md contains no mention of environment variables, credentials, or secrets
sf_undocumented_subprocess high Script spawns subprocesses (subprocess, os.system, child_process, execSync) but SKILL.md contains no mention of running commands or shell execution
sf_undocumented_filewrite medium Script writes files (open(…, 'w'), fs.writeFile, fs.writeFileSync) but SKILL.md contains no mention of writing, saving, or creating files