eslint-plugin-security

What is eslint-plugin-security?

eslint-plugin-security is an ESLint plugin that helps identify potential security issues in your JavaScript code. It provides a set of rules that can be used to catch common security vulnerabilities, such as the use of eval(), potential XSS vulnerabilities, and more.

What are eslint-plugin-security's main functionalities?

Detecting the use of eval()

This rule detects the use of eval() with an expression, which can lead to code injection vulnerabilities. The code sample shows a scenario where user input is passed to eval(), which is flagged by the rule.

/* eslint security/detect-eval-with-expression: 'error' */

const userInput = '2 + 2';
eval(userInput);

Detecting potential XSS vulnerabilities

This rule detects the use of non-literal regular expressions, which can be a source of XSS vulnerabilities. The code sample demonstrates creating a RegExp object with user input, which is flagged by the rule.

/* eslint security/detect-non-literal-regexp: 'error' */

const userInput = '.*';
const regex = new RegExp(userInput);

Detecting potential ReDoS vulnerabilities

This rule detects potentially unsafe regular expressions that could lead to Regular Expression Denial of Service (ReDoS) attacks. The code sample shows an unsafe regex pattern that is flagged by the rule.

/* eslint security/detect-unsafe-regex: 'error' */

const unsafeRegex = /(a+)+$/;
unsafeRegex.test('aaaaaaaaaaaaaaaaaaaaaaaaaaaaa');

Other packages similar to eslint-plugin-security

eslint-plugin-no-unsanitized

eslint-plugin-no-unsanitized is an ESLint plugin that focuses on preventing the use of unsanitized methods that can lead to XSS vulnerabilities. It is similar to eslint-plugin-security in that it helps identify potential security issues, but it specifically targets unsanitized DOM manipulations.

eslint-plugin-scanjs-rules

eslint-plugin-scanjs-rules is an ESLint plugin that provides a set of security rules based on the Mozilla ScanJS project. It is similar to eslint-plugin-security in that it aims to identify security issues in JavaScript code, but it includes a different set of rules inspired by the ScanJS project.

README

eslint-plugin-security

ESLint rules for Node Security

This project will help identify potential security hotspots, but finds a lot of false positives which need triage by a human.

Installation

npm install --save-dev eslint-plugin-security

or

yarn add --dev eslint-plugin-security

Usage

Flat config (requires eslint >= v8.23.0)

Add the following to your eslint.config.js file:

const pluginSecurity = require('eslint-plugin-security');

module.exports = [pluginSecurity.configs.recommended];

eslintrc config (deprecated)

Add the following to your .eslintrc file:

module.exports = {
  extends: ['plugin:security/recommended-legacy'],
};

Developer guide

• Use GitHub pull requests.
• Conventions:
• We use our custom ESLint setup.
• Please implement a test for each new rule and use this command to be sure the new code respects the style guide and the tests keep passing:

npm run-script cont-int

Tests

npm test

Rules

⚠️ Configurations set to warn in.
✅ Set in the recommended configuration.

Name	Description	⚠️
detect-bidi-characters	Detects trojan source attacks that employ unicode bidi attacks to inject malicious code.	✅
detect-buffer-noassert	Detects calls to "buffer" with "noAssert" flag set.	✅
detect-child-process	Detects instances of "child_process" & non-literal "exec()" calls.	✅
detect-disable-mustache-escape	Detects "object.escapeMarkup = false", which can be used with some template engines to disable escaping of HTML entities.	✅
detect-eval-with-expression	Detects "eval(variable)" which can allow an attacker to run arbitrary code inside your process.	✅
detect-new-buffer	Detects instances of new Buffer(argument) where argument is any non-literal value.	✅
detect-no-csrf-before-method-override	Detects Express "csrf" middleware setup before "method-override" middleware.	✅
detect-non-literal-fs-filename	Detects variable in filename argument of "fs" calls, which might allow an attacker to access anything on your system.	✅
detect-non-literal-regexp	Detects "RegExp(variable)", which might allow an attacker to DOS your server with a long-running regular expression.	✅
detect-non-literal-require	Detects "require(variable)", which might allow an attacker to load and run arbitrary code, or access arbitrary files on disk.	✅
detect-object-injection	Detects "variable[key]" as a left- or right-hand assignment operand.	✅
detect-possible-timing-attacks	Detects insecure comparisons (==, !=, !== and ===), which check input sequentially.	✅
detect-pseudoRandomBytes	Detects if "pseudoRandomBytes()" is in use, which might not give you the randomness you need and expect.	✅
detect-unsafe-regex	Detects potentially unsafe regular expressions, which may take a very long time to run, blocking the event loop.	✅

TypeScript support

Type definitions for this package are managed by DefinitelyTyped. Use @types/eslint-plugin-security for type checking.

npm install --save-dev @types/eslint-plugin-security

# OR

yarn add --dev @types/eslint-plugin-security