Detections
Explore public detection logic contributed by the community across SIEM and rule languages.
733 detections
Filters
Last updated
All Time
Detection languages
362
124
60
58
35
Contributors
222
123
75
46
32
Categories
334
253
143
139
101
Platforms
525
383
290
80
34
Products / Services
161
158
114
72
47
MITRE Techniques
18,123
15,639
12,581
8,394
6,215
733
CVEs
4
3
3
2
2
IDS Classtypes
17
2
1
1
IDS Protocols
15
2
2
1
Detects unexpected child process creation spawned by npm or node.exe that is characteristic of the IronWorm Rust-based infostealer. This rule monitors for malicious npm preinstall or postinstall hooks executing common living-off-the-land binaries (like curl, powershell, or regsvr32) from within a node_modules directory structure, common in supply chain compromise scenarios.
Detects suspicious git commit activity associated with the IronWorm campaign. The rule monitors for git operations involving backdated commits or force-pushes, particularly those using a specific noreply email address or common maintenance commit messages, which are indicative of supply-chain compromise and timestomping techniques within npm repositories.
Detects instances where 'node.exe' executes common npm lifecycle scripts (e.g., preinstall, postinstall) that subsequently spawn suspicious child processes such as shell interpreters, network utilities, or scripting engines. This behavior is indicative of malicious packages (such as those associated with the Trum3it campaign) attempting to download or execute secondary payloads during the installation phase.
This rule detects suspicious activity related to GitHub Actions workflows, including the creation or modification of workflow configuration files, the placement of suspicious JavaScript files in the repository's .github directory, the execution of the 'Bun' runtime within an Actions runner environment, and cloud-based events indicating workflow modification containing 'Run Copilot' strings. These patterns are often associated with CI/CD pipeline compromise, malicious automation, or unauthorized code execution within build environments.
Detects the creation of Model Context Protocol (MCP) server configuration files (e.g., mcp.json) in workspace directories triggered by process executions typically associated with package installation tools such as npm, npx, pip, or python. This behavior can indicate the installation of a malicious or typosquatted package designed to register a malicious MCP server and facilitate credential theft or unauthorized access.
Detects the creation of Model Context Protocol (MCP) server configuration files (such as .mcp.json or those in .vscode/ and .amazonq/ directories) shortly after a Git operation (pull, fetch, merge, or clone). This pattern is indicative of a supply chain attack where a contributor introduces malicious MCP configurations into a workspace, which are subsequently loaded by development tools like VS Code, Cursor, or language servers to execute arbitrary code or exfiltrate data.
Detects malicious child process creation behavior associated with the BeaverTail JavaScript infostealer during the installation of compromised npm packages. The rule monitors for 'node.exe' spawning suspicious shell or interpreter processes (e.g., python, curl, powershell) in conjunction with strings indicative of known malicious delivery mechanisms (e.g., specific filenames like 'lserver.js', 'jsonwebauth', or external hosting domains).
Detects the installation of known malicious Chrome extensions, specifically Adblock for YouTube, Adblock for Chrome, Adblock for You, and AdBlock Suite. These extensions have been associated with malware distribution, removal from the Chrome Web Store, or dormant remote code execution capabilities via server-fetched scriptlets.
Detects the obfuscated 'setup.cjs' dropper associated with the easy-day-js npm supply chain attack. The rule identifies unique obfuscated variable names, XOR-encoded marker bytes, and specific campaign-related strings, including postinstall commands, package names, second-stage payload filenames, self-deletion patterns, and TLS bypass indicators.
Supply chain worm targeting npm packages and GitHub Actions, linked to Shai-Hulud/Hades lineage
Detects instances where package managers like npm, pip, or python execute shells or scripting interpreters with command-line arguments indicative of software installation or build processes. This pattern is common in supply chain attacks where malicious packages run code during their installation phase.
Detects suspicious modifications to .github/workflows YAML files, unauthorized git commits with backdated timestamps, usage of noreply.github.com bot author names, and git push commands initiated by node.exe. This activity is indicative of the IronWorm malware attempting to manipulate CI/CD pipelines and exfiltrate secrets.
This rule monitors for suspicious activity associated with npm or Node.js processes. This includes potential credential misuse during npm publish or login, unauthorized build-time execution via node-gyp, and the use of unconventional preinstall/postinstall hooks that spawn external binaries or scripts, which are often indicative of software supply chain attacks.
Detects suspicious 'npm publish' or 'npm login' commands executed as child processes of 'node' or 'npm'. This pattern indicates programmatic execution from within package install hooks (such as preinstall or postinstall scripts) instead of manual developer interaction, a behavior characteristic of malicious npm supply chain attacks (e.g., IronWorm) aiming to trojanize packages using stolen tokens.
Detects in-memory execution of the MYRA RAT originating from a node.exe process. The rule monitors for suspicious process creation patterns associated with fileless techniques, including execution from memory file descriptors (memfd), /proc/self/fd, or empty process image paths, as well as unauthorized process interaction with systemd-userdbd, indicative of node.js supply chain compromises.
Detects anomalous behaviors associated with malicious npm package self-upgrades, where node.exe modifies its own source files within node_modules or spawns npm pack commands to replace existing dependencies with malicious versions.
Detects the execution of a malicious npm package disguised as '@withgoogle/stitch-sdk'. The package uses a 'preinstall.js' script to harvest sensitive developer credentials, including API keys, Git credentials, SSH keys, and Docker tokens, and attempts to exfiltrate this data to an attacker-controlled domain (stitch-production.org).
Detects node.exe executing 'test.js' as a child process of NPM lifecycle scripts (postinstall/preinstall). This behavior is characteristic of malicious NPM packages like 'ts-bn-lint' and 'log-taker' used in the Polymarket Trap campaign to execute an embedded infostealer payload.
Detects outbound network connections from node.exe or npm related processes to domains associated with the Polymarket Trap supply chain attack. This detection highlights the malicious behavior of compromised npm packages that initiate C2 communication at import time, bypassing standard postinstall security scripts.
Detects reconnaissance activity originating from npm or Node.js processes, specifically targeting system information (OS, network, user context, and hardware identifiers). This activity is associated with supply chain compromise attempts where malicious npm postinstall scripts or inline Node.js execution are used to enumerate the host environment.
This rule detects suspicious activity associated with the Bun runtime after an npm package install. It flags instances where Bun, or download utilities (curl/wget) fetching 'bun.sh', are spawned from Node.js-related processes (npm, node, node-gyp) particularly when located in common temporary or cache directories, indicating potential supply chain compromise or unauthorized runtime deployment during build processes.
Page 17 of 35