eslint-plugin-security 1.4.0 → 1.5.0

package/rules/detect-non-literal-regexp.js

@@ -3,26 +3,32 @@
  * @author Jon Lamendola
  */
 
+'use strict';
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-
-module.exports = function(context) {
-
-        "use strict";
-
-        return {
-                "NewExpression": function(node) {
-                        if (node.callee.name === 'RegExp') {
-                                var args = node.arguments;
-                                if (args && args.length > 0 && args[0].type !== 'Literal') {
-                                        var token = context.getTokens(node)[0];
-                                        return context.report(node, 'Found non-literal argument to RegExp Constructor');
-                                }
-                        }
-
-                }
-
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Detects "RegExp(variable)", which might allow an attacker to DOS your server with a long-running regular expression.',
+      category: 'Possible Security Vulnerability',
+      recommended: true,
+      url: 'https://github.com/nodesecurity/eslint-plugin-security/blob/main/docs/regular-expression-dos-and-node.md',
+    },
+  },
+  create: function (context) {
+    return {
+      NewExpression: function (node) {
+        if (node.callee.name === 'RegExp') {
+          const args = node.arguments;
+          if (args && args.length > 0 && args[0].type !== 'Literal') {
+            return context.report(node, 'Found non-literal argument to RegExp Constructor');
+          }
         }
-}
+      },
+    };
+  },
+};

package/rules/detect-non-literal-require.js

@@ -1,29 +1,37 @@
 /**
  * Tries to detect calls to require with non-literal argument
- * @author Adam Baldwin 
+ * @author Adam Baldwin
  */
 
+'use strict';
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
-
-    "use strict";
-
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Detects "require(variable)", which might allow an attacker to load and run arbitrary code, or access arbitrary files on disk. ',
+      category: 'Possible Security Vulnerability',
+      recommended: true,
+      url: 'https://github.com/nodesecurity/eslint-plugin-security#detect-non-literal-require',
+    },
+  },
+  create: function (context) {
     return {
-        "CallExpression": function (node) {
-            if (node.callee.name === 'require') {
-                var args = node.arguments;
-                if (args && args.length > 0 && args[0].type !== 'Literal') {
-                    var token = context.getTokens(node)[0];
-                    return context.report(node, 'Found non-literal argument in require');
-                }
-            }
-
+      CallExpression: function (node) {
+        if (node.callee.name === 'require') {
+          const args = node.arguments;
+          if (
+            (args && args.length > 0 && args[0].type === 'TemplateLiteral' && args[0].expressions.length > 0) ||
+            (args[0].type !== 'TemplateLiteral' && args[0].type !== 'Literal')
+          ) {
+            return context.report(node, 'Found non-literal argument in require');
+          }
         }
-
+      },
     };
-
+  },
 };
-

package/rules/detect-object-injection.js

@@ -3,77 +3,79 @@
  * @author Jon Lamendola
  */
 
+'use strict';
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-var Sinks = [];
-function getSerialize (fn, decycle) {
-  var seen = [], keys = [];
-  decycle = decycle || function(key, value) {
-    return '[Circular ' + getPath(value, seen, keys) + ']'
-  };
-  return function(key, value) {
-    var ret = value;
+const getPath = (value, seen, keys) => {
+  let index = seen.indexOf(value);
+  const path = [keys[index]];
+  for (index--; index >= 0; index--) {
+    if (seen[index][path[0]] === value) {
+      value = seen[index];
+      path.unshift(keys[index]);
+    }
+  }
+  return `~${path.join('.')}`;
+};
+
+const getSerialize = (fn, decycle) => {
+  const seen = [];
+  const keys = [];
+  decycle =
+    decycle ||
+    function (key, value) {
+      return `[Circular ${getPath(value, seen, keys)}]`;
+    };
+  return function (key, value) {
+    let ret = value;
     if (typeof value === 'object' && value) {
-      if (seen.indexOf(value) !== -1)
+      if (seen.indexOf(value) !== -1) {
         ret = decycle(key, value);
-      else {
+      } else {
         seen.push(value);
         keys.push(key);
       }
     }
-    if (fn) ret = fn(key, ret);
-    return ret;
-  }
-}
-
-function getPath (value, seen, keys) {
-  var index = seen.indexOf(value);
-  var path = [ keys[index] ];
-  for (index--; index >= 0; index--) {
-    if (seen[index][ path[0] ] === value) {
-      value = seen[index];
-      path.unshift(keys[index]);
+    if (fn) {
+      ret = fn(key, ret);
     }
-  }
-  return '~' + path.join('.');
-}
+    return ret;
+  };
+};
 
-function stringify(obj, fn, spaces, decycle) {
+const stringify = (obj, fn, spaces, decycle) => {
   return JSON.stringify(obj, getSerialize(fn, decycle), spaces);
-}
-
-stringify.getSerialize = getSerialize;module.exports = function(context) {
-
-        "use strict";
-
-var isChanged = false;
-
-
-
-        return {
-            "MemberExpression": function(node) {
-
-                if (node.computed === true) {
-                    var token = context.getTokens(node)[0];
-                    if (node.property.type === 'Identifier') {
-                        if (node.parent.type === 'VariableDeclarator') {
-   context.report(node, 'Variable Assigned to Object Injection Sink');
-    
-                        } else if (node.parent.type === 'CallExpression') {
-                        //    console.log(node.parent)
-  context.report(node, 'Function Call Object Injection Sink');
-                        } else {
-                        context.report(node, 'Generic Object Injection Sink');
-    
-                        }
-
-                    }
-                }
+};
 
+stringify.getSerialize = getSerialize;
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Detects "variable[key]" as a left- or right-hand assignment operand.',
+      category: 'Possible Security Vulnerability',
+      recommended: true,
+      url: 'https://github.com/nodesecurity/eslint-plugin-security/blob/main/docs/the-dangers-of-square-bracket-notation.md',
+    },
+  },
+  create: function (context) {
+    return {
+      MemberExpression: function (node) {
+        if (node.computed === true) {
+          if (node.property.type === 'Identifier') {
+            if (node.parent.type === 'VariableDeclarator') {
+              context.report(node, 'Variable Assigned to Object Injection Sink');
+            } else if (node.parent.type === 'CallExpression') {
+              context.report(node, 'Function Call Object Injection Sink');
+            } else {
+              context.report(node, 'Generic Object Injection Sink');
             }
-
-        };
-    }
-
+          }
+        }
+      },
+    };
+  },
+};

package/rules/detect-possible-timing-attacks.js

@@ -3,58 +3,56 @@
  * @author Adam Baldwin / Jon Lamendola
  */
 
+'use strict';
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-var keywords = '((' + [
-    'password',
-    'secret',
-    'api',
-    'apiKey',
-    'token',
-    'auth',
-    'pass',
-    'hash'
-].join(')|(') + '))';
-
-var re = new RegExp('^' + keywords + '$', 'im');
+const keywords = `((${['password', 'secret', 'api', 'apiKey', 'token', 'auth', 'pass', 'hash'].join(')|(')}))`;
 
-function containsKeyword (node) {
-    if (node.type === 'Identifier') {
-        if (re.test(node.name))
-            return true;
-        }
-        return
-}
+const re = new RegExp(`^${keywords}$`, 'im');
 
-module.exports = function(context) {
-
-    "use strict";
+const containsKeyword = (node) => {
+  if (node.type === 'Identifier') {
+    if (re.test(node.name)) {
+      return true;
+    }
+  }
+  return;
+};
 
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Detects insecure comparisons (`==`, `!=`, `!==` and `===`), which check input sequentially.',
+      category: 'Possible Security Vulnerability',
+      recommended: true,
+      url: 'https://github.com/nodesecurity/eslint-plugin-security#detect-possible-timing-attacks'
+    }
+  },
+  create: function (context) {
     return {
-        "IfStatement": function(node) {
-            if (node.test && node.test.type === 'BinaryExpression') {
-                if (node.test.operator === '==' || node.test.operator === '===' || node.test.operator === '!=' || node.test.operator === '!==') {
-
-                    var token = context.getTokens(node)[0];
-
-                    if (node.test.left) {
-                    var left = containsKeyword(node.test.left);
-                        if (left) {
-                            return context.report(node, "Potential timing attack, left side: " + left);
-                        }
-                    }
+      IfStatement: function (node) {
+        if (node.test && node.test.type === 'BinaryExpression') {
+          if (node.test.operator === '==' || node.test.operator === '===' || node.test.operator === '!=' || node.test.operator === '!==') {
+            if (node.test.left) {
+              const left = containsKeyword(node.test.left);
+              if (left) {
+                return context.report(node, `Potential timing attack, left side: ${left}`);
+              }
+            }
 
-                    if (node.test.right) {
-                    var right = containsKeyword(node.test.right);
-                        if (right) {
-                            return context.report(node, "Potential timing attack, right side: " + right);
-                        }
-                    }
-                }
+            if (node.test.right) {
+              const right = containsKeyword(node.test.right);
+              if (right) {
+                return context.report(node, `Potential timing attack, right side: ${right}`);
+              }
             }
+          }
         }
+      }
     };
-
+  }
 };

package/rules/detect-pseudoRandomBytes.js

@@ -3,22 +3,29 @@
  * @author Adam Baldwin
  */
 
+'use strict';
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
-
-    "use strict";
-
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Detects if "pseudoRandomBytes()" is in use, which might not give you the randomness you need and expect.',
+      category: 'Possible Security Vulnerability',
+      recommended: true,
+      url: 'https://github.com/nodesecurity/eslint-plugin-security#detect-pseudorandombytes',
+    },
+  },
+  create: function (context) {
     return {
-        "MemberExpression": function (node) {
-            if (node.property.name === 'pseudoRandomBytes') {
-                var token = context.getTokens(node)[0];
-                return context.report(node, 'Found crypto.pseudoRandomBytes which does not produce cryptographically strong numbers');
-            }
+      MemberExpression: function (node) {
+        if (node.property.name === 'pseudoRandomBytes') {
+          return context.report(node, 'Found crypto.pseudoRandomBytes which does not produce cryptographically strong numbers');
         }
-
+      },
     };
-
+  },
 };

package/rules/detect-unsafe-regex.js

@@ -1,37 +1,50 @@
-var safe = require('safe-regex');
 /**
  * Check if the regex is evil or not using the safe-regex module
  * @author Adam Baldwin
  */
 
+'use strict';
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const safe = require('safe-regex');
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
-
-    "use strict";
-
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Locates potentially unsafe regular expressions, which may take a very long time to run, blocking the event loop.',
+      category: 'Possible Security Vulnerability',
+      recommended: true,
+      url: 'https://github.com/nodesecurity/eslint-plugin-security/blob/main/docs/regular-expression-dos-and-node.md'
+    }
+  },
+  create: function (context) {
     return {
-        "Literal": function(node) {
-            var token = context.getTokens(node)[0],
-                nodeType = token.type,
-                nodeValue = token.value;
+      Literal: function (node) {
+        const token = context.getTokens(node)[0];
+        const nodeType = token.type;
+        const nodeValue = token.value;
 
-            if (nodeType === "RegularExpression") {
-                if (!safe(nodeValue)) {
-                    context.report(node, "Unsafe Regular Expression");
-                }
-            }
-        },
-        "NewExpression": function(node) {
-            if (node.callee.name == "RegExp" && node.arguments && node.arguments.length > 0 && node.arguments[0].type == "Literal") {
-                if (!safe(node.arguments[0].value)) {
-                    context.report(node, "Unsafe Regular Expression (new RegExp)");
-                }
-            }
+        if (nodeType === 'RegularExpression') {
+          if (!safe(nodeValue)) {
+            context.report(node, 'Unsafe Regular Expression');
+          }
+        }
+      },
+      NewExpression: function (node) {
+        if (node.callee.name === 'RegExp' && node.arguments && node.arguments.length > 0 && node.arguments[0].type === 'Literal') {
+          if (!safe(node.arguments[0].value)) {
+            context.report(node, 'Unsafe Regular Expression (new RegExp)');
+          }
         }
+      }
     };
-
+  }
 };
-

package/test/detect-buffer-noassert.js

@@ -4,27 +4,27 @@ const RuleTester = require('eslint').RuleTester;
 const tester = new RuleTester();
 
 const ruleName = 'detect-buffer-noassert';
-const Rule = require(`../rules/${ruleName}`);
+const rule = require(`../rules/${ruleName}`);
 
-const invalid = 'a.readUInt8(0, true);';
+const allMethodNames = [...rule.meta.__methodsToCheck.read, ...rule.meta.__methodsToCheck.write];
 
-
-tester.run(ruleName, Rule, {
-  valid: [{ code: 'a.readUInt8(0);' }],
+tester.run(ruleName, rule, {
+  valid: [...allMethodNames.map((methodName) => `a.${methodName}(0)`), ...allMethodNames.map((methodName) => `a.${methodName}(0, false)`)],
   invalid: [
-    {
-      code: invalid,
-      errors: [{ message: 'Found Buffer.readUInt8 with noAssert flag set true' }]
-    }
-  ]
-});
+    ...rule.meta.__methodsToCheck.read.map((methodName) => ({
+      code: `a.${methodName}(0, true)`,
+      errors: [{ message: `Found Buffer.${methodName} with noAssert flag set true` }],
+    })),
 
-tester.run(`${ruleName} (false)`, Rule, {
-  valid: [{ code: 'a.readUInt8(0, false);' }],
-  invalid: [
+    ...rule.meta.__methodsToCheck.write.map((methodName) => ({
+      code: `a.${methodName}(0, 0, true)`,
+      errors: [{ message: `Found Buffer.${methodName} with noAssert flag set true` }],
+    })),
+
+    // hard-coded test to ensure #63 is fixed
     {
-      code: invalid,
-      errors: [{ message: 'Found Buffer.readUInt8 with noAssert flag set true' }]
-    }
-  ]
+      code: 'a.readDoubleLE(0, true);',
+      errors: [{ message: 'Found Buffer.readDoubleLE with noAssert flag set true' }],
+    },
+  ],
 });

package/test/detect-child-process.js

@@ -4,32 +4,22 @@ const RuleTester = require('eslint').RuleTester;
 const tester = new RuleTester();
 
 const ruleName = 'detect-child-process';
-const Rule = require(`../rules/${ruleName}`);
+const rule = require(`../rules/${ruleName}`);
 
-const valid = 'child_process.exec(\'ls\')';
-const invalidRequire = 'require(\'child_process\')';
-const invalidExec = 'var child = require(\'child_process\'); child.exec(com)';
-
-
-tester.run(`${ruleName} (require("child_process"))`, Rule, {
-  valid: [{ code: valid }],
+tester.run(ruleName, rule, {
+  valid: ["child_process.exec('ls')"],
   invalid: [
     {
-      code: invalidRequire,
-      errors: [{ message: 'Found require("child_process")' }]
-    }
-  ]
-});
-
-
-tester.run(`${ruleName} (child_process.exec() wih non literal 1st arg.)`, Rule, {
-  valid: [{ code: valid }],
-  invalid: [
+      code: "require('child_process')",
+      errors: [{ message: 'Found require("child_process")' }],
+    },
+    {
+      code: "var child = require('child_process'); child.exec(com)",
+      errors: [{ message: 'Found require("child_process")' }, { message: 'Found child_process.exec() with non Literal first argument' }],
+    },
     {
-      code: invalidExec,
-      errors: [
-        { message: 'Found require("child_process")' },
-        { message: 'Found child_process.exec() with non Literal first argument' }]
-    }
-  ]
+      code: "var child = require('child_process'); child.exec()",
+      errors: [{ message: 'Found require("child_process")' }],
+    },
+  ],
 });

package/test/detect-disable-mustache-escape.js

@@ -5,7 +5,6 @@ const tester = new RuleTester();
 
 const ruleName = 'detect-disable-mustache-escape';
 
-
 tester.run(ruleName, require(`../rules/${ruleName}`), {
   valid: [{ code: 'escapeMarkup = false' }],
   invalid: [

package/test/detect-eval-with-expression.js

@@ -5,7 +5,6 @@ const tester = new RuleTester();
 
 const ruleName = 'detect-eval-with-expression';
 
-
 tester.run(ruleName, require(`../rules/${ruleName}`), {
   valid: [{ code: 'eval(\'alert()\')' }],
   invalid: [

package/test/detect-new-buffer.js

@@ -6,7 +6,6 @@ const tester = new RuleTester();
 const ruleName = 'detect-new-buffer';
 const invalid = 'var a = new Buffer(c)';
 
-
 tester.run(ruleName, require(`../rules/${ruleName}`), {
   valid: [{ code: 'var a = new Buffer(\'test\')' }],
   invalid: [

package/test/detect-no-csrf-before-method-override.js

@@ -5,7 +5,6 @@ const tester = new RuleTester();
 
 const ruleName = 'detect-no-csrf-before-method-override';
 
-
 tester.run(ruleName, require(`../rules/${ruleName}`), {
   valid: [{ code: 'express.methodOverride();express.csrf()' }],
   invalid: [

package/test/detect-non-literal-fs-filename.js

@@ -7,7 +7,6 @@ const invalid = 'var a = fs.open(c)';
 
 const ruleName = 'detect-non-literal-fs-filename';
 
-
 tester.run(ruleName, require(`../rules/${ruleName}`), {
   valid: [{ code: 'var a = fs.open(\'test\')' }],
   invalid: [

package/test/detect-non-literal-regexp.js

@@ -6,7 +6,6 @@ const tester = new RuleTester();
 const ruleName = 'detect-non-literal-regexp';
 const invalid = 'var a = new RegExp(c, \'i\')';
 
-
 tester.run(ruleName, require(`../rules/${ruleName}`), {
   valid: [{ code: 'var a = new RegExp(\'ab+c\', \'i\')' }],
   invalid: [

package/test/detect-non-literal-require.js

@@ -1,17 +1,20 @@
 'use strict';
 
 const RuleTester = require('eslint').RuleTester;
-const tester = new RuleTester();
 
-const ruleName = 'detect-non-literal-require';
-const invalid = 'var a = require(c)';
+const tester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
+const ruleName = 'detect-non-literal-require';
 
 tester.run(ruleName, require(`../rules/${ruleName}`), {
-  valid: [{ code: 'var a = require(\'b\')' }],
+  valid: [{ code: 'var a = require(\'b\')' }, { code: 'var a = require(`b`)' }],
   invalid: [
     {
-      code: invalid,
+      code: 'var a = require(c)',
+      errors: [{ message: 'Found non-literal argument in require' }]
+    },
+    {
+      code: 'var a = require(`${c}`)',
       errors: [{ message: 'Found non-literal argument in require' }]
     }
   ]

package/test/detect-object-injection.js

@@ -12,7 +12,6 @@ const valid = 'var a = {};';
 // const invalidFunction = "TODO";
 const invalidGeneric = 'var a = {}; a[b] = 4';
 
-
 // TODO
 // tester.run(`${ruleName} (Variable Assigned to)`, Rule, {
 //   valid: [{ code: valid }],
@@ -35,7 +34,6 @@ const invalidGeneric = 'var a = {}; a[b] = 4';
 //   ]
 // });
 
-
 tester.run(`${ruleName} (Generic)`, Rule, {
   valid: [{ code: valid }],
   invalid: [