Ruby: add regex injection query

Author: nickrolfe

ruby/ql/lib/codeql/ruby/frameworks/StandardLibrary.qll

@@ -2,6 +2,7 @@ private import codeql.ruby.AST
 private import codeql.ruby.Concepts
 private import codeql.ruby.DataFlow
 private import codeql.ruby.ApiGraphs
+private import codeql.ruby.dataflow.FlowSummary
 
 /**
  * The `Kernel` module is included by the `Object` class, so its methods are available
@@ -335,3 +336,18 @@ class ModuleEvalCallCodeExecution extends CodeExecution::Range, DataFlow::CallNo
 
   override DataFlow::Node getCode() { result = this.getArgument(0) }
 }
+
+/** Flow summary for `Regexp.escape`. */
+class RegexpEscapeSummary extends SummarizedCallable {
+  RegexpEscapeSummary() { this = "Regexp.escape" }
+
+  override MethodCall getACall() {
+    result = API::getTopLevelMember("Regexp").getAMethodCall("escape").asExpr().getExpr()
+  }
+
+  override predicate propagatesFlowExt(string input, string output, boolean preservesValue) {
+    input = "Argument[0]" and
+    output = "ReturnValue" and
+    preservesValue = false
+  }
+}

ruby/ql/lib/codeql/ruby/regexp/RegExpInjectionCustomizations.qll

@@ -0,0 +1,73 @@
+private import ruby
+private import codeql.ruby.DataFlow
+private import codeql.ruby.Concepts
+private import codeql.ruby.Frameworks
+private import codeql.ruby.dataflow.RemoteFlowSources
+private import codeql.ruby.dataflow.BarrierGuards
+private import codeql.ruby.ApiGraphs
+
+/**
+ * Provides default sources, sinks and sanitizers for detecting
+ * regexp injection vulnerabilities, as well as extension points for
+ * adding your own.
+ */
+module RegExpInjection {
+  /**
+   * A data flow source for regexp injection vulnerabilities.
+   */
+  abstract class Source extends DataFlow::Node { }
+
+  /**
+   * A data flow sink for regexp injection vulnerabilities.
+   */
+  abstract class Sink extends DataFlow::Node { }
+
+  /**
+   * A sanitizer guard for regexp injection vulnerabilities.
+   */
+  abstract class SanitizerGuard extends DataFlow::BarrierGuard { }
+
+  /**
+   * A data flow sanitized for regexp injection vulnerabilities.
+   */
+  abstract class Sanitizer extends DataFlow::Node { }
+
+  /**
+   * A source of remote user input, considered as a flow source.
+   */
+  class RemoteFlowSourceAsSource extends Source, RemoteFlowSource { }
+
+  /** A regexp literal, considered as a flow sink. */
+  class RegExpLiteralAsSink extends Sink {
+    RegExpLiteralAsSink() { this.asExpr().getExpr() instanceof RegExpLiteral }
+  }
+
+  /**
+   * The first argument of a call to `Regexp.new`, considered as a flow sink.
+   */
+  class ConstructedRegExpAsSink extends Sink {
+    ConstructedRegExpAsSink() {
+      this =
+        API::getTopLevelMember("Regexp").getAnInstantiation().(DataFlow::CallNode).getArgument(0)
+    }
+  }
+
+  /**
+   * A comparison with a constant string, considered as a sanitizer-guard.
+   */
+  class StringConstCompareAsSanitizerGuard extends SanitizerGuard, StringConstCompare { }
+
+  /**
+   * An inclusion check against an array of constant strings, considered as a
+   * sanitizer-guard.
+   */
+  class StringConstArrayInclusionCallAsSanitizerGuard extends SanitizerGuard,
+    StringConstArrayInclusionCall { }
+
+  /**
+   * A call to `Regexp.escape`, considered as a sanitizer.
+   */
+  class RegexpEscapeSanitization extends Sanitizer {
+    RegexpEscapeSanitization() { this = API::getTopLevelMember("Regexp").getAMethodCall("escape") }
+  }
+}

ruby/ql/lib/codeql/ruby/regexp/RegExpInjectionQuery.qll

@@ -0,0 +1,29 @@
+/**
+ * Provides a taint-tracking configuration for detecting regexp injection vulnerabilities.
+ *
+ * Note, for performance reasons: only import this file if `Configuration` is needed,
+ * otherwise `RegExpInjectionCustomizations` should be imported instead.
+ */
+
+import codeql.ruby.DataFlow::DataFlow::PathGraph
+import codeql.ruby.DataFlow
+import codeql.ruby.TaintTracking
+import RegExpInjectionCustomizations
+import codeql.ruby.dataflow.BarrierGuards
+
+/**
+ * A taint-tracking configuration for detecting regexp injection vulnerabilities.
+ */
+class Configuration extends TaintTracking::Configuration {
+  Configuration() { this = "RegExpInjection" }
+
+  override predicate isSource(DataFlow::Node source) { source instanceof RegExpInjection::Source }
+
+  override predicate isSink(DataFlow::Node sink) { sink instanceof RegExpInjection::Sink }
+
+  override predicate isSanitizerGuard(DataFlow::BarrierGuard guard) {
+    guard instanceof RegExpInjection::SanitizerGuard
+  }
+
+  override predicate isSanitizer(DataFlow::Node node) { node instanceof RegExpInjection::Sanitizer }
+}

ruby/ql/src/queries/security/cwe-1333/RegExpInjection.qhelp

@@ -0,0 +1,68 @@
+<!DOCTYPE qhelp PUBLIC
+  "-//Semmle//qhelp//EN"
+  "qhelp.dtd">
+<qhelp>
+
+<overview>
+<p>
+Constructing a regular expression with unsanitized user input is dangerous,
+since a malicious user may be able to modify the meaning of the expression. In
+particular, such a user may be able to provide a regular expression fragment
+that takes exponential time in the worst case, and use that to perform a Denial
+of Service attack.
+</p>
+</overview>
+
+<recommendation>
+<p>
+Before embedding user input into a regular expression, use a sanitization
+function such as <code>Regexp.escape</code> to escape meta-characters that have
+special meaning.
+</p>
+</recommendation>
+
+<example>
+<p>
+The following examples construct regular expressions from an HTTP request
+parameter without sanitizing it first:
+</p>
+<sample language="ruby">
+class UsersController < ActionController::Base
+  def first_example
+    # BAD: Unsanitized user input is used to construct a regular expression
+    regex = /#{ params[:key] }/
+  end
+
+  def second_example
+    # BAD: Unsanitized user input is used to construct a regular expression
+    regex = Regexp.new(params[:key])
+  end
+end
+</sample>
+<p>
+Instead, the request parameter should be sanitized first. This ensures that the
+user cannot insert characters that have special meanings in regular expressions.
+</p>
+<sample language="ruby">
+class UsersController < ActionController::Base
+  def example
+    # GOOD: User input is sanitized before constructing the regular expression
+    regex = Regexp.new(Regex.escape(params[:key]))
+  end
+end
+</sample>
+</example>
+
+<references>
+<li>
+OWASP:
+<a href="https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS">Regular expression Denial of Service - ReDoS</a>.
+</li>
+<li>
+Wikipedia: <a href="https://en.wikipedia.org/wiki/ReDoS">ReDoS</a>.
+</li>
+<li>
+Ruby: <a href="https://ruby-doc.org/core-3.0.2/Regexp.html#method-c-escape">Regexp.escape</a>.
+</li>
+</references>
+</qhelp>

ruby/ql/src/queries/security/cwe-1333/RegExpInjection.ql

@@ -0,0 +1,26 @@
+/**
+ * @name Regular expression injection
+ * @description User input should not be used in regular expressions without
+ *              first being escaped. Otherwise, a malicious user may be able to
+ *              inject an expression that could require exponential time on
+ *              certain inputs.
+ * @kind path-problem
+ * @problem.severity error
+ * @security-severity 7.5
+ * @precision high
+ * @id rb/regexp-injection
+ * @tags security
+ *       external/cwe/cwe-1333
+ *       external/cwe/cwe-730
+ *       external/cwe/cwe-400
+ */
+
+import ruby
+import DataFlow::PathGraph
+import codeql.ruby.DataFlow
+import codeql.ruby.regexp.RegExpInjectionQuery
+
+from Configuration cfg, DataFlow::PathNode source, DataFlow::PathNode sink
+where cfg.hasFlowPath(source, sink)
+select sink.getNode(), source, sink, "This regular expression is constructed from a $@.",
+  source.getNode(), "user-provided value"

ruby/ql/test/query-tests/security/cwe-1333-regexp-injection/RegExpInjection.expected

@@ -0,0 +1,20 @@
+edges
+| RegExpInjection.rb:4:12:4:17 | call to params :  | RegExpInjection.rb:5:13:5:21 | /#{...}/ |
+| RegExpInjection.rb:10:12:10:17 | call to params :  | RegExpInjection.rb:11:13:11:27 | /foo#{...}bar/ |
+| RegExpInjection.rb:16:12:16:17 | call to params :  | RegExpInjection.rb:17:24:17:27 | name |
+| RegExpInjection.rb:22:12:22:17 | call to params :  | RegExpInjection.rb:23:24:23:33 | ... + ... |
+nodes
+| RegExpInjection.rb:4:12:4:17 | call to params :  | semmle.label | call to params :  |
+| RegExpInjection.rb:5:13:5:21 | /#{...}/ | semmle.label | /#{...}/ |
+| RegExpInjection.rb:10:12:10:17 | call to params :  | semmle.label | call to params :  |
+| RegExpInjection.rb:11:13:11:27 | /foo#{...}bar/ | semmle.label | /foo#{...}bar/ |
+| RegExpInjection.rb:16:12:16:17 | call to params :  | semmle.label | call to params :  |
+| RegExpInjection.rb:17:24:17:27 | name | semmle.label | name |
+| RegExpInjection.rb:22:12:22:17 | call to params :  | semmle.label | call to params :  |
+| RegExpInjection.rb:23:24:23:33 | ... + ... | semmle.label | ... + ... |
+subpaths
+#select
+| RegExpInjection.rb:5:13:5:21 | /#{...}/ | RegExpInjection.rb:4:12:4:17 | call to params :  | RegExpInjection.rb:5:13:5:21 | /#{...}/ | This regular expression is constructed from a $@. | RegExpInjection.rb:4:12:4:17 | call to params | user-provided value |
+| RegExpInjection.rb:11:13:11:27 | /foo#{...}bar/ | RegExpInjection.rb:10:12:10:17 | call to params :  | RegExpInjection.rb:11:13:11:27 | /foo#{...}bar/ | This regular expression is constructed from a $@. | RegExpInjection.rb:10:12:10:17 | call to params | user-provided value |
+| RegExpInjection.rb:17:24:17:27 | name | RegExpInjection.rb:16:12:16:17 | call to params :  | RegExpInjection.rb:17:24:17:27 | name | This regular expression is constructed from a $@. | RegExpInjection.rb:16:12:16:17 | call to params | user-provided value |
+| RegExpInjection.rb:23:24:23:33 | ... + ... | RegExpInjection.rb:22:12:22:17 | call to params :  | RegExpInjection.rb:23:24:23:33 | ... + ... | This regular expression is constructed from a $@. | RegExpInjection.rb:22:12:22:17 | call to params | user-provided value |

ruby/ql/test/query-tests/security/cwe-1333-regexp-injection/RegExpInjection.qlref

@@ -0,0 +1 @@
+queries/security/cwe-1333/RegExpInjection.ql

ruby/ql/test/query-tests/security/cwe-1333-regexp-injection/RegExpInjection.rb

@@ -0,0 +1,45 @@
+class FooController < ActionController::Base
+  # BAD
+  def route0
+    name = params[:name]
+    regex = /#{name}/
+  end
+
+  # BAD
+  def route1
+    name = params[:name]
+    regex = /foo#{name}bar/
+  end
+
+  # BAD
+  def route2
+    name = params[:name]
+    regex = Regexp.new(name)
+  end
+
+  # BAD
+  def route3
+    name = params[:name]
+    regex = Regexp.new("@" + name)
+  end
+
+  # GOOD - string is compared against a constant string
+  def route4
+    name = params[:name]
+    regex = Regexp.new("@" + name) if name == "foo"
+  end
+
+  # GOOD - string is compared against a constant string array
+  def route5
+    name = params[:name]
+    if ["John", "Paul", "George", "Ringo"].include?(name)
+      regex = /@#{name}/
+    end
+  end
+
+  # GOOD - string is explicitly escaped
+  def route6
+    name = params[:name]
+    regex = Regexp.new(Regexp.escape(name))
+  end
+end