aikido-zen 1.0.1.beta.4-x86_64-linux-musl → 1.0.1.beta.5-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e645ab4d18aeda13f265ca896f40b593f5eadca5a4db9efc72b290fc13e2ca75
-  data.tar.gz: 7451c8794cc035c7d7741b2564e037328699fd1165cbb7beb49704c2d9e39e6d
+  metadata.gz: a8cb66439e682a571b15c7405fef28a3b27a90b248419b3c2c905bdd9e0244b2
+  data.tar.gz: 9bcaf684b0fe2a6ce1e24a1601353dcf8a94150a375ece69ad6129109df33a98
 SHA512:
-  metadata.gz: 6fac2cae1aa40652da7b7487d0dbc714d08fb5eb60143b7ca748f467842280863c6f4d8f8d0d5f5f6b7f5456684fbbfbca33915a1840e2a26cab9899cfc7f73f
-  data.tar.gz: 5f9d94f00a4b48e5d97bbf2d0cc178a7e202d9a3fc9dea019f0d4fc54451f42a2a5e0a53e748306ff4e92aec6906870967e5ef59c656c31142d0155715b059a2
+  metadata.gz: 77073b3af1244161c7241eda17b77905c12a3835239313b06512116bff1a24223f8098079a6671d8941df1dd0da36a3e050be93054165f4378629a6e1156cc27
+  data.tar.gz: de9918d2afc2498c5ffb9312a54d8c7cf6f6a0b653a539c40b2c3e287852b259c085d5f9aac854957729efe9d5cc23891f807ee3f8178b229a2cbbe9315fe765

data/lib/aikido/zen/sinks/async_http.rb

@@ -7,14 +7,6 @@ module Aikido::Zen
   module Sinks
     module Async
       module HTTP
-        def self.load_sinks!
-          if Aikido::Zen.satisfy "async-http", ">= 0.70.0"
-            require "async/http"
-
-            ::Async::HTTP::Client.prepend(Async::HTTP::ClientExtensions)
-          end
-        end
-
         SINK = Sinks.add("async-http", scanners: [
           Scanners::SSRFScanner,
           OutboundConnectionMonitor
@@ -30,48 +22,54 @@ module Aikido::Zen
           end
         end
 
-        module ClientExtensions
-          extend Sinks::DSL
+        def self.load_sinks!
+          if Aikido::Zen.satisfy "async-http", ">= 0.70.0"
+            require "async/http"
 
-          sink_around :call do |super_call, request|
-            uri = URI(format("%<scheme>s://%<authority>s%<path>s", {
-              scheme: request.scheme || scheme,
-              authority: request.authority || authority,
-              path: request.path
-            }))
+            ::Async::HTTP::Client.class_eval do
+              extend Sinks::DSL
 
-            wrapped_request = Scanners::SSRFScanner::Request.new(
-              verb: request.method,
-              uri: uri,
-              headers: request.headers.to_h,
-              header_normalizer: ->(value) { Array(value).join(", ") }
-            )
+              sink_around :call do |original_call, request|
+                uri = URI(format("%<scheme>s://%<authority>s%<path>s", {
+                  scheme: request.scheme || scheme,
+                  authority: request.authority || authority,
+                  path: request.path
+                }))
 
-            # Store the request information so the DNS sinks can pick it up.
-            context = Aikido::Zen.current_context
-            if context
-              prev_request = context["ssrf.request"]
-              context["ssrf.request"] = wrapped_request
-            end
+                wrapped_request = Scanners::SSRFScanner::Request.new(
+                  verb: request.method,
+                  uri: uri,
+                  headers: request.headers.to_h,
+                  header_normalizer: ->(value) { Array(value).join(", ") }
+                )
 
-            connection = OutboundConnection.from_uri(uri)
+                # Store the request information so the DNS sinks can pick it up.
+                context = Aikido::Zen.current_context
+                if context
+                  prev_request = context["ssrf.request"]
+                  context["ssrf.request"] = wrapped_request
+                end
 
-            Helpers.scan(wrapped_request, connection, "request")
+                connection = OutboundConnection.from_uri(uri)
 
-            response = super_call.call
+                Helpers.scan(wrapped_request, connection, "request")
 
-            Scanners::SSRFScanner.track_redirects(
-              request: wrapped_request,
-              response: Scanners::SSRFScanner::Response.new(
-                status: response.status,
-                headers: response.headers.to_h,
-                header_normalizer: ->(value) { Array(value).join(", ") }
-              )
-            )
+                response = original_call.call
+
+                Scanners::SSRFScanner.track_redirects(
+                  request: wrapped_request,
+                  response: Scanners::SSRFScanner::Response.new(
+                    status: response.status,
+                    headers: response.headers.to_h,
+                    header_normalizer: ->(value) { Array(value).join(", ") }
+                  )
+                )
 
-            response
-          ensure
-            context["ssrf.request"] = prev_request if context
+                response
+              ensure
+                context["ssrf.request"] = prev_request if context
+              end
+            end
           end
         end
       end

data/lib/aikido/zen/sinks/curb.rb

@@ -6,14 +6,6 @@ require_relative "../outbound_connection_monitor"
 module Aikido::Zen
   module Sinks
     module Curl
-      def self.load_sinks!
-        if Aikido::Zen.satisfy "curb", ">= 0.2.3"
-          require "curb"
-
-          ::Curl::Easy.prepend(Curl::EasyExtensions)
-        end
-      end
-
       SINK = Sinks.add("curb", scanners: [
         Scanners::SSRFScanner,
         OutboundConnectionMonitor
@@ -53,59 +45,65 @@ module Aikido::Zen
         end
       end
 
-      module EasyExtensions
-        extend Sinks::DSL
-
-        sink_around :perform do |super_call|
-          wrapped_request = Helpers.wrap_request(self)
-
-          # Store the request information so the DNS sinks can pick it up.
-          context = Aikido::Zen.current_context
-          if context
-            prev_request = context["ssrf.request"]
-            context["ssrf.request"] = wrapped_request
-          end
-
-          connection = OutboundConnection.from_uri(URI(url))
-
-          Helpers.scan(wrapped_request, connection, "request")
-
-          response = super_call.call
-
-          Scanners::SSRFScanner.track_redirects(
-            request: wrapped_request,
-            response: Helpers.wrap_response(self)
-          )
+      def self.load_sinks!
+        if Aikido::Zen.satisfy "curb", ">= 0.2.3"
+          require "curb"
 
-          # When libcurl has follow_location set, it will handle redirections
-          # internally, and expose the "last_effective_url" as the URI that was
-          # last requested in the redirect chain.
-          #
-          # In this case, we can't actually stop the request from happening, but
-          # we can scan again (now that we know another request happened), to
-          # stop the response from being exposed to the user. This downgrades
-          # the SSRF into a blind SSRF, which is better than doing nothing.
-          if url != last_effective_url
-            last_effective_request = Helpers.wrap_request(self, url: last_effective_url)
-
-            # Code coverage is disabled here because the else clause is a no-op,
-            # so there is nothing to cover.
-            # :nocov:
-            if context
-              context["ssrf.request"] = last_effective_request
-            else
-              # empty
+          ::Curl::Easy.class_eval do
+            extend Sinks::DSL
+
+            sink_around :perform do |original_call|
+              wrapped_request = Helpers.wrap_request(self)
+
+              # Store the request information so the DNS sinks can pick it up.
+              context = Aikido::Zen.current_context
+              if context
+                prev_request = context["ssrf.request"]
+                context["ssrf.request"] = wrapped_request
+              end
+
+              connection = OutboundConnection.from_uri(URI(url))
+
+              Helpers.scan(wrapped_request, connection, "request")
+
+              response = original_call.call
+
+              Scanners::SSRFScanner.track_redirects(
+                request: wrapped_request,
+                response: Helpers.wrap_response(self)
+              )
+
+              # When libcurl has follow_location set, it will handle redirections
+              # internally, and expose the "last_effective_url" as the URI that was
+              # last requested in the redirect chain.
+              #
+              # In this case, we can't actually stop the request from happening, but
+              # we can scan again (now that we know another request happened), to
+              # stop the response from being exposed to the user. This downgrades
+              # the SSRF into a blind SSRF, which is better than doing nothing.
+              if url != last_effective_url
+                last_effective_request = Helpers.wrap_request(self, url: last_effective_url)
+
+                # Code coverage is disabled here because the else clause is a no-op,
+                # so there is nothing to cover.
+                # :nocov:
+                if context
+                  context["ssrf.request"] = last_effective_request
+                else
+                  # empty
+                end
+                # :nocov:
+
+                connection = OutboundConnection.from_uri(URI(last_effective_url))
+
+                Helpers.scan(last_effective_request, connection, "request")
+              end
+
+              response
+            ensure
+              context["ssrf.request"] = prev_request if context
             end
-            # :nocov:
-
-            connection = OutboundConnection.from_uri(URI(last_effective_url))
-
-            Helpers.scan(last_effective_request, connection, "request")
           end
-
-          response
-        ensure
-          context["ssrf.request"] = prev_request if context
         end
       end
     end

data/lib/aikido/zen/sinks/em_http.rb

@@ -7,19 +7,6 @@ module Aikido::Zen
   module Sinks
     module EventMachine
       module HttpRequest
-        def self.load_sinks!
-          if Aikido::Zen.satisfy "em-http-request", ">= 1.0"
-            require "em-http-request"
-
-            ::EventMachine::HttpRequest.use(EventMachine::HttpRequest::Middleware)
-
-            # NOTE: We can't use middleware to intercept requests as we want to ensure any
-            # modifications to the request from user-supplied middleware are already applied
-            # before we scan the request.
-            ::EventMachine::HttpClient.prepend(EventMachine::HttpRequest::HttpClientExtensions)
-          end
-        end
-
         SINK = Sinks.add("em-http-request", scanners: [
           Scanners::SSRFScanner,
           OutboundConnectionMonitor
@@ -35,26 +22,37 @@ module Aikido::Zen
           end
         end
 
-        module HttpClientExtensions
-          extend Sinks::DSL
+        def self.load_sinks!
+          if Aikido::Zen.satisfy "em-http-request", ">= 1.0"
+            require "em-http-request"
 
-          sink_before :send_request do
-            wrapped_request = Scanners::SSRFScanner::Request.new(
-              verb: req.method.to_s,
-              uri: URI(req.uri),
-              headers: req.headers
-            )
+            ::EventMachine::HttpRequest.use(EventMachine::HttpRequest::Middleware)
 
-            # Store the request information so the DNS sinks can pick it up.
-            context = Aikido::Zen.current_context
-            context["ssrf.request"] = wrapped_request if context
+            # NOTE: We can't use middleware to intercept requests as we want to ensure any
+            # modifications to the request from user-supplied middleware are already applied
+            # before we scan the request.
+            ::EventMachine::HttpClient.class_eval do
+              extend Sinks::DSL
 
-            connection = OutboundConnection.new(
-              host: req.host,
-              port: req.port
-            )
+              sink_before :send_request do
+                wrapped_request = Scanners::SSRFScanner::Request.new(
+                  verb: req.method.to_s,
+                  uri: URI(req.uri),
+                  headers: req.headers
+                )
+
+                # Store the request information so the DNS sinks can pick it up.
+                context = Aikido::Zen.current_context
+                context["ssrf.request"] = wrapped_request if context
+
+                connection = OutboundConnection.new(
+                  host: req.host,
+                  port: req.port
+                )
 
-            Helpers.scan(wrapped_request, connection, "request")
+                Helpers.scan(wrapped_request, connection, "request")
+              end
+            end
           end
         end
 

data/lib/aikido/zen/sinks/excon.rb

@@ -6,15 +6,6 @@ require_relative "../outbound_connection_monitor"
 module Aikido::Zen
   module Sinks
     module Excon
-      def self.load_sinks!
-        if Aikido::Zen.satisfy "excon", ">= 0.50.0"
-          require "excon"
-
-          ::Excon::Connection.prepend(ConnectionExtensions)
-          ::Excon::Middleware::RedirectFollower.prepend(RedirectFollowerExtensions)
-        end
-      end
-
       SINK = Sinks.add("excon", scanners: [
         Scanners::SSRFScanner,
         OutboundConnectionMonitor
@@ -46,72 +37,78 @@ module Aikido::Zen
         end
       end
 
-      module ConnectionExtensions
-        extend Sinks::DSL
+      def self.load_sinks!
+        if Aikido::Zen.satisfy "excon", ">= 0.50.0"
+          require "excon"
+
+          ::Excon::Connection.class_eval do
+            extend Sinks::DSL
 
-        sink_around :request do |super_call, params = {}|
-          request = Helpers.build_request(@data, params)
+            sink_around :request do |original_call, params = {}|
+              request = Helpers.build_request(@data, params)
 
-          # Store the request information so the DNS sinks can pick it up.
-          context = Aikido::Zen.current_context
-          if context
-            prev_request = context["ssrf.request"]
-            context["ssrf.request"] = request
-          end
+              # Store the request information so the DNS sinks can pick it up.
+              context = Aikido::Zen.current_context
+              if context
+                prev_request = context["ssrf.request"]
+                context["ssrf.request"] = request
+              end
 
-          connection = OutboundConnection.from_uri(request.uri)
+              connection = OutboundConnection.from_uri(request.uri)
 
-          Helpers.scan(request, connection, "request")
+              Helpers.scan(request, connection, "request")
 
-          response = super_call.call
+              response = original_call.call
 
-          Scanners::SSRFScanner.track_redirects(
-            request: request,
-            response: Scanners::SSRFScanner::Response.new(
-              status: response.status,
-              headers: response.headers.to_h
-            )
-          )
+              Scanners::SSRFScanner.track_redirects(
+                request: request,
+                response: Scanners::SSRFScanner::Response.new(
+                  status: response.status,
+                  headers: response.headers.to_h
+                )
+              )
 
-          response
-        rescue Sinks::DSL::PresafeError => err
-          outer_cause = err.cause
-          case outer_cause
-          when ::Excon::Error::Socket
-            inner_cause = outer_cause.cause
-            # Excon wraps errors inside the lower level layer. This only happens
-            # to our scanning exceptions when a request is using RedirectFollower,
-            # so we unwrap them when it happens so host apps can handle errors
-            # consistently.
-            raise inner_cause if inner_cause.is_a?(Aikido::Zen::UnderAttackError)
+              response
+            rescue Sinks::DSL::PresafeError => err
+              outer_cause = err.cause
+              case outer_cause
+              when ::Excon::Error::Socket
+                inner_cause = outer_cause.cause
+                # Excon wraps errors inside the lower level layer. This only happens
+                # to our scanning exceptions when a request is using RedirectFollower,
+                # so we unwrap them when it happens so host apps can handle errors
+                # consistently.
+                raise inner_cause if inner_cause.is_a?(Aikido::Zen::UnderAttackError)
+              end
+              raise
+            ensure
+              context["ssrf.request"] = prev_request if context
+            end
           end
-          raise
-        ensure
-          context["ssrf.request"] = prev_request if context
-        end
-      end
 
-      module RedirectFollowerExtensions
-        extend Sinks::DSL
-
-        sink_before :response_call do |datum|
-          response = datum[:response]
-
-          # Code coverage is disabled here because the else clause is a no-op,
-          # so there is nothing to cover.
-          # :nocov:
-          if !response.nil?
-            Scanners::SSRFScanner.track_redirects(
-              request: Helpers.build_request(datum, {}),
-              response: Scanners::SSRFScanner::Response.new(
-                status: response[:status],
-                headers: response[:headers]
-              )
-            )
-          else
-            # empty
+          ::Excon::Middleware::RedirectFollower.class_eval do
+            extend Sinks::DSL
+
+            sink_before :response_call do |datum|
+              response = datum[:response]
+
+              # Code coverage is disabled here because the else clause is a no-op,
+              # so there is nothing to cover.
+              # :nocov:
+              if !response.nil?
+                Scanners::SSRFScanner.track_redirects(
+                  request: Helpers.build_request(datum, {}),
+                  response: Scanners::SSRFScanner::Response.new(
+                    status: response[:status],
+                    headers: response[:headers]
+                  )
+                )
+              else
+                # empty
+              end
+              # :nocov:
+            end
           end
-          # :nocov:
         end
       end
     end

data/lib/aikido/zen/sinks/file.rb

@@ -3,18 +3,6 @@
 module Aikido::Zen
   module Sinks
     module File
-      def self.load_sinks!
-        # Create a copy of the original method for internal use only to prevent
-        # recursion in PathTraversalScanner.
-        #
-        # IMPORTANT: The alias must be created before the method is overridden,
-        # when the extensions are prepended.
-        ::File.singleton_class.alias_method(:expand_path__internal_for_aikido_zen, :expand_path)
-
-        ::File.singleton_class.prepend(FileClassExtensions)
-        ::File.prepend(FileExtensions)
-      end
-
       SINK = Sinks.add("File", scanners: [Scanners::PathTraversalScanner])
 
       module Helpers
@@ -26,87 +14,95 @@ module Aikido::Zen
         end
       end
 
-      module FileClassExtensions
-        extend Sinks::DSL
+      def self.load_sinks!
+        ::File.singleton_class.class_eval do
+          extend Sinks::DSL
 
-        sink_before :open do |path|
-          Helpers.scan(path, "open")
-        end
+          # Create a copy of the original method for internal use only to prevent
+          # recursion in PathTraversalScanner.
+          #
+          # IMPORTANT: The alias must be created before the method is overridden.
+          alias_method :expand_path__internal_for_aikido_zen, :expand_path
 
-        sink_before :read do |path|
-          Helpers.scan(path, "read")
-        end
+          sink_before :open do |path|
+            Helpers.scan(path, "open")
+          end
 
-        sink_before :write do |path|
-          Helpers.scan(path, "write")
-        end
+          sink_before :read do |path|
+            Helpers.scan(path, "read")
+          end
 
-        sink_before :truncate do |file_name|
-          Helpers.scan(file_name, "truncate")
-        end
+          sink_before :write do |path|
+            Helpers.scan(path, "write")
+          end
 
-        sink_before :rename do |old_name, new_name|
-          Helpers.scan(old_name, "rename")
-          Helpers.scan(new_name, "rename")
-        end
+          sink_before :truncate do |file_name|
+            Helpers.scan(file_name, "truncate")
+          end
 
-        sink_before :unlink do |*file_names|
-          file_names.each do |file_name|
-            Helpers.scan(file_name, "unlink")
+          sink_before :rename do |old_name, new_name|
+            Helpers.scan(old_name, "rename")
+            Helpers.scan(new_name, "rename")
           end
-        end
 
-        sink_before :delete do |*file_names|
-          file_names.each do |file_name|
-            Helpers.scan(file_name, "delete")
+          sink_before :unlink do |*file_names|
+            file_names.each do |file_name|
+              Helpers.scan(file_name, "unlink")
+            end
           end
-        end
 
-        sink_before :symlink do |old_name, new_name|
-          Helpers.scan(old_name, "symlink")
-          Helpers.scan(new_name, "symlink")
-        end
+          sink_before :delete do |*file_names|
+            file_names.each do |file_name|
+              Helpers.scan(file_name, "delete")
+            end
+          end
 
-        sink_before :chmod do |_mode_int, *file_names|
-          file_names.each do |file_name|
-            Helpers.scan(file_name, "chmod")
+          sink_before :symlink do |old_name, new_name|
+            Helpers.scan(old_name, "symlink")
+            Helpers.scan(new_name, "symlink")
           end
-        end
 
-        sink_before :chown do |_owner_int, group_int, *file_names|
-          file_names.each do |file_name|
-            Helpers.scan(file_name, "chown")
+          sink_before :chmod do |_mode_int, *file_names|
+            file_names.each do |file_name|
+              Helpers.scan(file_name, "chmod")
+            end
           end
-        end
 
-        sink_before :utime do |_atime, _mtime, *file_names|
-          file_names.each do |file_name|
-            Helpers.scan(file_name, "utime")
+          sink_before :chown do |_owner_int, group_int, *file_names|
+            file_names.each do |file_name|
+              Helpers.scan(file_name, "chown")
+            end
           end
-        end
 
-        sink_after :join do |result|
-          Helpers.scan(result, "join")
-        end
+          sink_before :utime do |_atime, _mtime, *file_names|
+            file_names.each do |file_name|
+              Helpers.scan(file_name, "utime")
+            end
+          end
 
-        sink_before :expand_path do |file_name|
-          Helpers.scan(file_name, "expand_path")
-        end
+          sink_after :join do |result|
+            Helpers.scan(result, "join")
+          end
 
-        sink_before :realpath do |file_name|
-          Helpers.scan(file_name, "realpath")
-        end
+          sink_before :expand_path do |file_name|
+            Helpers.scan(file_name, "expand_path")
+          end
+
+          sink_before :realpath do |file_name|
+            Helpers.scan(file_name, "realpath")
+          end
 
-        sink_before :realdirpath do |file_name|
-          Helpers.scan(file_name, "realdirpath")
+          sink_before :realdirpath do |file_name|
+            Helpers.scan(file_name, "realdirpath")
+          end
         end
-      end
 
-      module FileExtensions
-        extend Sinks::DSL
+        ::File.class_eval do
+          extend Sinks::DSL
 
-        sink_before :initialize do |path|
-          Helpers.scan(path, "new")
+          sink_before :initialize do |path|
+            Helpers.scan(path, "new")
+          end
         end
       end
     end