ddtrace 0.53.0 → 1.0.0.beta1

data/lib/datadog/appsec/contrib/rack/reactive/request.rb

@@ -0,0 +1,85 @@
+require 'datadog/appsec/contrib/rack/request'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Rack
+        module Reactive
+          # Dispatch data from a Rack request to the WAF context
+          module Request
+            def self.publish(op, request)
+              catch(:block) do
+                op.publish('request.query', Rack::Request.query(request))
+                op.publish('request.headers', Rack::Request.headers(request))
+                op.publish('request.uri.raw', Rack::Request.url(request))
+                op.publish('request.cookies', Rack::Request.cookies(request))
+                # op.publish('request.body.raw', Rack::Request.body(request))
+                # TODO: op.publish('request.path_params', { k: v }) # route params only?
+                # TODO: op.publish('request.path', request.script_name + request.path) # unused for now
+
+                nil
+              end
+            end
+
+            # rubocop:disable Metrics/MethodLength
+            def self.subscribe(op, waf_context)
+              addresses = [
+                'request.headers',
+                'request.uri.raw',
+                'request.query',
+                'request.cookies',
+                # 'request.body.raw',
+                # TODO: 'request.path_params',
+              ]
+
+              op.subscribe(*addresses) do |*values|
+                Datadog.logger.debug { "reacted to #{addresses.inspect}: #{values.inspect}" }
+                headers = values[0]
+                headers_no_cookies = headers.dup.tap { |h| h.delete('cookie') }
+                uri_raw = values[1]
+                query = values[2]
+                cookies = values[3]
+                # body = values[4]
+
+                waf_args = {
+                  'server.request.cookies' => cookies,
+                  # 'server.request.body.raw' => body,
+                  'server.request.query' => query,
+                  'server.request.uri.raw' => uri_raw,
+                  'server.request.headers' => headers,
+                  'server.request.headers.no_cookies' => headers_no_cookies,
+                  # TODO: 'server.request.path_params' => path_params,
+                }
+
+                waf_timeout = Datadog::AppSec.settings.waf_timeout
+                action, result = waf_context.run(waf_args, waf_timeout)
+
+                # TODO: encapsulate return array in a type
+                case action
+                when :monitor
+                  Datadog.logger.debug { "WAF: #{result.inspect}" }
+                  yield [action, result, false]
+                when :block
+                  Datadog.logger.debug { "WAF: #{result.inspect}" }
+                  yield [action, result, true]
+                  throw(:block, [action, result, true])
+                when :good
+                  Datadog.logger.debug { "WAF OK: #{result.inspect}" }
+                when :timeout
+                  Datadog.logger.debug { "WAF TIMEOUT: #{result.inspect}" }
+                when :invalid_call
+                  Datadog.logger.debug { "WAF CALL ERROR: #{result.inspect}" }
+                when :invalid_rule, :invalid_flow, :no_rule
+                  Datadog.logger.debug { "WAF RULE ERROR: #{result.inspect}" }
+                else
+                  Datadog.logger.debug { "WAF UNKNOWN: #{action.inspect} #{result.inspect}" }
+                end
+              end
+            end
+            # rubocop:enable Metrics/MethodLength
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rack/reactive/response.rb

@@ -0,0 +1,62 @@
+require 'datadog/appsec/contrib/rack/response'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Rack
+        module Reactive
+          # Dispatch data from a Rack response to the WAF context
+          module Response
+            def self.publish(op, response)
+              catch(:block) do
+                op.publish('response.status', Rack::Response.status(response))
+
+                nil
+              end
+            end
+
+            def self.subscribe(op, waf_context)
+              addresses = [
+                'response.status',
+              ]
+
+              op.subscribe(*addresses) do |*values|
+                Datadog.logger.debug { "reacted to #{addresses.inspect}: #{values.inspect}" }
+
+                response_status = values[0]
+
+                waf_args = {
+                  'server.response.status' => response_status.to_s,
+                }
+
+                waf_timeout = Datadog::AppSec.settings.waf_timeout
+                action, result = waf_context.run(waf_args, waf_timeout)
+
+                # TODO: encapsulate return array in a type
+                case action
+                when :monitor
+                  Datadog.logger.debug { "WAF: #{result.inspect}" }
+                  yield [action, result, false]
+                when :block
+                  Datadog.logger.debug { "WAF: #{result.inspect}" }
+                  yield [action, result, true]
+                  throw(:block, [action, result, true])
+                when :good
+                  Datadog.logger.debug { "WAF OK: #{result.inspect}" }
+                when :timeout
+                  Datadog.logger.debug { "WAF TIMEOUT: #{result.inspect}" }
+                when :invalid_call
+                  Datadog.logger.debug { "WAF CALL ERROR: #{result.inspect}" }
+                when :invalid_rule, :invalid_flow, :no_rule
+                  Datadog.logger.debug { "WAF RULE ERROR: #{result.inspect}" }
+                else
+                  Datadog.logger.debug { "WAF UNKNOWN: #{action.inspect} #{result.inspect}" }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rack/request.rb

@@ -0,0 +1,43 @@
+module Datadog
+  module AppSec
+    module Contrib
+      module Rack
+        # Normalized extration of data from Rack::Request
+        module Request
+          def self.query(request)
+            request.query_string.split('&').map { |e| e.split('=').map { |s| CGI.unescape(s) } }
+          end
+
+          # Rack < 2.0 does not have :each_header
+          # TODO: We need access to Rack here. We must make sure we are able to load AppSec without Rack,
+          # TODO: while still ensure correctness in ths code path.
+          if defined?(::Rack) && ::Rack::Request.instance_methods.include?(:each_header)
+            def self.headers(request)
+              request.each_header.each_with_object({}) do |(k, v), h|
+                h[k.gsub(/^HTTP_/, '').downcase.tr('_', '-')] = v if k =~ /^HTTP_/
+              end
+            end
+          else
+            def self.headers(request)
+              request.env.each_with_object({}) do |(k, v), h|
+                h[k.gsub(/^HTTP_/, '').downcase.tr('_', '-')] = v if k =~ /^HTTP_/
+              end
+            end
+          end
+
+          def self.body(request)
+            request.body.read.tap { request.body.rewind }
+          end
+
+          def self.url(request)
+            request.url
+          end
+
+          def self.cookies(request)
+            request.cookies
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rack/request_middleware.rb

@@ -0,0 +1,98 @@
+# typed: ignore
+
+require 'datadog/appsec/instrumentation/gateway'
+require 'datadog/appsec/assets'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Rack
+        # Topmost Rack middleware for AppSec
+        # This should be inserted just below Datadog::Tracing::Contrib::Rack::TraceMiddleware
+        class RequestMiddleware
+          def initialize(app, opt = {})
+            @app = app
+
+            # TODO: move to integration? (may be too early)
+            require_libddwaf
+
+            libddwaf_spec = Gem.loaded_specs['libddwaf']
+            libddwaf_platform = libddwaf_spec ? libddwaf_spec.platform.to_s : 'unknown'
+            ruby_platforms = Gem.platforms.map(&:to_s)
+
+            if libddwaf_required?
+              Datadog.logger.debug { "libddwaf platform: #{libddwaf_platform}" }
+              Datadog::AppSec::WAF.logger = Datadog.logger if Datadog.logger.debug? && Datadog::AppSec.settings.waf_debug
+              @waf = Datadog::AppSec::WAF::Handle.new(waf_rules)
+            else
+              Datadog.logger.warn do
+                "libddwaf failed to load, installed platform: #{libddwaf_platform} ruby platforms: #{ruby_platforms}"
+              end
+              Datadog.logger.warn { 'AppSec is disabled' }
+            end
+          end
+
+          def waf_rules
+            ruleset_setting = Datadog::AppSec.settings.ruleset
+            case ruleset_setting
+            when :recommended, :risky, :strict
+              @waf_rules ||= JSON.parse(Datadog::AppSec::Assets.waf_rules(ruleset_setting))
+            when String
+              # TODO: handle file missing
+              filename = ruleset_setting
+              ruleset = File.read(filename)
+              @waf_rules ||= JSON.parse(ruleset)
+            else
+              # TODO: use a proper exception class
+              raise "unsupported value for :ruleset: #{ruleset_setting.inspect}"
+            end
+          end
+
+          def call(env)
+            return @app.call(env) unless libddwaf_required?
+
+            # TODO: handle exceptions, except for @app.call
+
+            context = Datadog::AppSec::WAF::Context.new(@waf)
+
+            env['datadog.waf.context'] = context
+            request = ::Rack::Request.new(env)
+
+            request_return, request_response = Instrumentation.gateway.push('rack.request', request) do
+              @app.call(env)
+            end
+
+            if request_response && request_response.any? { |action, _event| action == :block }
+              request_return = [403, { 'Content-Type' => 'text/html' }, [Datadog::AppSec::Assets.blocked]]
+            end
+
+            response = ::Rack::Response.new(request_return[2], request_return[0], request_return[1])
+            response.instance_eval do
+              @waf_context = context
+            end
+
+            _, response_response = Instrumentation.gateway.push('rack.response', response)
+
+            request_response.each { |_, e| e.merge!(response: response) } if request_response
+            response_response.each { |_, e| e.merge!(request: request) } if response_response
+            both_response = (request_response || []) + (response_response || [])
+
+            AppSec::Event.record(*both_response.map { |_action, event| event }) if both_response.any?
+
+            request_return
+          end
+
+          def libddwaf_required?
+            defined?(Datadog::AppSec::WAF)
+          end
+
+          def require_libddwaf
+            require 'libddwaf'
+          rescue LoadError => e
+            Datadog.logger.warn { "LoadError: libddwaf failed to load: #{e.message}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rack/response.rb

@@ -0,0 +1,22 @@
+module Datadog
+  module AppSec
+    module Contrib
+      module Rack
+        # Normalized extration of data from Rack::Response
+        module Response
+          def self.headers(response)
+            response.headers.each_with_object({}) { |(k, v), h| h[k.downcase] = v }
+          end
+
+          def self.cookies(response)
+            response.cookies
+          end
+
+          def self.status(response)
+            response.status
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rails/configuration/settings.rb

@@ -0,0 +1,20 @@
+require 'datadog/appsec/contrib/configuration/settings'
+require 'datadog/appsec/contrib/rails/ext'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Rails
+        module Configuration
+          # Custom settings for the Rack integration
+          class Settings < Datadog::AppSec::Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rails/ext.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module AppSec
+    module Contrib
+      module Rails
+        # Rack integration constants
+        module Ext
+          APP = 'rails'.freeze
+          ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rails/framework.rb

@@ -0,0 +1,28 @@
+module Datadog
+  module AppSec
+    module Contrib
+      module Rails
+        # Rails specific framework tie
+        module Framework
+          def self.setup
+            Datadog::AppSec.configure do |datadog_config|
+              rails_config = config_with_defaults(datadog_config)
+              activate_rack!(datadog_config, rails_config)
+            end
+          end
+
+          def self.config_with_defaults(datadog_config)
+            datadog_config[:rails]
+          end
+
+          # Apply relevant configuration from Sinatra to Rack
+          def self.activate_rack!(datadog_config, sinatra_config)
+            datadog_config.instrument(
+              :rack,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rails/integration.rb

@@ -0,0 +1,48 @@
+# typed: ignore
+
+require 'datadog/appsec/contrib/integration'
+
+require 'datadog/appsec/contrib/rails/configuration/settings'
+require 'datadog/appsec/contrib/rails/patcher'
+require 'datadog/appsec/contrib/rails/request_middleware'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Rails
+        # Description of Rails integration
+        class Integration
+          include Datadog::AppSec::Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2.0')
+
+          register_as :rails, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['rails'] && Gem.loaded_specs['rails'].version
+          end
+
+          def self.loaded?
+            !defined?(::Rails).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def self.auto_instrument?
+            true
+          end
+
+          def default_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rails/patcher.rb

@@ -0,0 +1,125 @@
+# typed: ignore
+
+require 'datadog/core/utils/only_once'
+
+require 'datadog/appsec/contrib/patcher'
+require 'datadog/appsec/contrib/rails/integration'
+require 'datadog/appsec/contrib/rails/framework'
+require 'datadog/appsec/contrib/rack/request_middleware'
+
+require 'datadog/tracing/contrib/rack/middlewares'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Rails
+        # Patcher for AppSec on Rails
+        module Patcher
+          include Datadog::AppSec::Contrib::Patcher
+
+          BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Core::Utils::OnlyOnce.new }
+          AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Core::Utils::OnlyOnce.new }
+
+          module_function
+
+          def patched?
+            Patcher.instance_variable_get(:@patched)
+          end
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            patch_before_intialize
+            patch_after_intialize
+
+            Patcher.instance_variable_set(:@patched, true)
+          end
+
+          def patch_before_intialize
+            ::ActiveSupport.on_load(:before_initialize) do
+              Datadog::AppSec::Contrib::Rails::Patcher.before_intialize(self)
+            end
+          end
+
+          def before_intialize(app)
+            BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
+              # Middleware must be added before the application is initialized.
+              # Otherwise the middleware stack will be frozen.
+              # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
+              add_middleware(app) if Datadog.configuration[:rails][:middleware]
+            end
+          end
+
+          def add_middleware(app)
+            # Add trace middleware
+            if include_middleware?(Datadog::Tracing::Contrib::Rack::TraceMiddleware, app)
+              app.middleware.insert_after(Datadog::Tracing::Contrib::Rack::TraceMiddleware,
+                                          Datadog::AppSec::Contrib::Rack::RequestMiddleware)
+            else
+              app.middleware.insert_before(0, Datadog::AppSec::Contrib::Rack::RequestMiddleware)
+            end
+          end
+
+          def include_middleware?(middleware, app)
+            found = false
+
+            # find tracer middleware reference in Rails::Configuration::MiddlewareStackProxy
+            app.middleware.instance_variable_get(:@operations).each do |operation|
+              args = case operation
+                     when Array
+                       # rails 5.2
+                       _op, args = operation
+                       args
+                     when Proc
+                       if operation.binding.local_variables.include?(:args)
+                         # rails 6.0, 6.1
+                         operation.binding.local_variable_get(:args)
+                       else
+                         # rails 7.0 uses ... to pass args
+                         args_getter = Class.new do
+                           def method_missing(_op, *args) # rubocop:disable Style/MissingRespondToMissing
+                             args
+                           end
+                         end.new
+                         operation.call(args_getter)
+                       end
+                     else
+                       # unknown, pass through
+                       []
+                     end
+
+              found = true if args.include?(middleware)
+            end
+
+            found
+          end
+
+          def inspect_middlewares(app)
+            Datadog.logger.debug { 'Rails middlewares: ' << app.middleware.map(&:inspect).inspect }
+          end
+
+          def patch_after_intialize
+            ::ActiveSupport.on_load(:after_initialize) do
+              Datadog::AppSec::Contrib::Rails::Patcher.after_intialize(self)
+            end
+          end
+
+          def after_intialize(app)
+            AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
+              # Finish configuring the tracer after the application is initialized.
+              # We need to wait for some things, like application name, middleware stack, etc.
+              setup_security
+              inspect_middlewares(app)
+            end
+          end
+
+          def setup_security
+            Datadog::AppSec::Contrib::Rails::Framework.setup
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/rails/request_middleware.rb

@@ -0,0 +1,18 @@
+module Datadog
+  module AppSec
+    module Contrib
+      module Rails
+        # Rack middleware for AppSec on Rails
+        class RequestMiddleware
+          def initialize(app, opt = {})
+            @app = app
+          end
+
+          def call(env)
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/sinatra/configuration/settings.rb

@@ -0,0 +1,20 @@
+require 'datadog/appsec/contrib/configuration/settings'
+require 'datadog/appsec/contrib/sinatra/ext'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Sinatra
+        module Configuration
+          # Custom settings for the Rack integration
+          class Settings < Datadog::AppSec::Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/sinatra/ext.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module AppSec
+    module Contrib
+      module Sinatra
+        # Sinatra integration constants
+        module Ext
+          APP = 'sinatra'.freeze
+          ENV_ENABLED = 'DD_TRACE_SINATRA_ENABLED'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/sinatra/framework.rb

@@ -0,0 +1,32 @@
+module Datadog
+  module AppSec
+    module Contrib
+      # Instrument Sinatra.
+      module Sinatra
+        # Sinatra framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          # Configure Rack from Sinatra, but only if Rack has not been configured manually beforehand
+          def self.setup
+            Datadog::AppSec.configure do |datadog_config|
+              sinatra_config = config_with_defaults(datadog_config)
+              activate_rack!(datadog_config, sinatra_config)
+            end
+          end
+
+          def self.config_with_defaults(datadog_config)
+            datadog_config[:sinatra]
+          end
+
+          # Apply relevant configuration from Sinatra to Rack
+          def self.activate_rack!(datadog_config, sinatra_config)
+            datadog_config.instrument(
+              :rack,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/contrib/sinatra/integration.rb

@@ -0,0 +1,48 @@
+# typed: ignore
+
+require 'datadog/appsec/contrib/integration'
+
+require 'datadog/appsec/contrib/sinatra/configuration/settings'
+require 'datadog/appsec/contrib/sinatra/patcher'
+require 'datadog/appsec/contrib/sinatra/request_middleware'
+
+module Datadog
+  module AppSec
+    module Contrib
+      module Sinatra
+        # Description of Sinatra integration
+        class Integration
+          include Datadog::AppSec::Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.4.0')
+
+          register_as :sinatra
+
+          def self.version
+            Gem.loaded_specs['sinatra'] && Gem.loaded_specs['sinatra'].version
+          end
+
+          def self.loaded?
+            !defined?(::Sinatra).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def self.auto_instrument?
+            true
+          end
+
+          def default_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end