logjam_agent 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 375304657bb752c670704f325f55054bf811d9c5
-  data.tar.gz: 09ab3cf2c0037d3c2f0986d9d926b342f543e7ac
+  metadata.gz: 758acadd75c92e8f90ec5048473e2f5790d708bb
+  data.tar.gz: b63d83423a36353e614eca9e0ac25716b498f327
 SHA512:
-  metadata.gz: cc70919214e1d998562108257dbb824235c71fc8a0e90c914207968cac7559f07f250205fa081757201639a8192fd4a44041b940cade6b29b1d71c857de66db4
-  data.tar.gz: f952178602f923e69cd98a9963e9a95bd4e01ed1575b520a60e0bad92e68ba97e5b3418421e171f601c1844c9dca71fde22a6cd3955e5a9fad39c1329513ba06
+  metadata.gz: aced1491d337a12c47163792ec3f0f2bc413f2fd358536fe405c39d33afe22a0417a9388160384ae091006b7b77a2c498d2db3801f8062c5885f12cffb34f0f7
+  data.tar.gz: 2833c3916bc3538c4a8d6cf49bc8d17b1711b407489e2bc7fe1204026a3b3f5ddca5155a15fb2e377eb6c1b54582d99b2efbd02fc2f34186524e14991e03165f

data/lib/logjam_agent/actionpack/lib/action_dispatch/middleware/remote_ip.rb

@@ -0,0 +1,181 @@
+# As the name suggests, still is a copy of the rails/actionpack remote_ip middleware
+# It's duplicated here, in case it's not already available (e.g. in older rails versions),
+# because we don't want to add actionpack as dependecy.
+#
+# see https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb
+
+require 'ipaddr'
+
+module LogjamAgent
+  module ActionDispatch
+    # This middleware calculates the IP address of the remote client that is
+    # making the request. It does this by checking various headers that could
+    # contain the address, and then picking the last-set address that is not
+    # on the list of trusted IPs. This follows the precedent set by e.g.
+    # {the Tomcat server}[https://issues.apache.org/bugzilla/show_bug.cgi?id=50453],
+    # with {reasoning explained at length}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection]
+    # by @gingerlime. A more detailed explanation of the algorithm is given
+    # at GetIp#calculate_ip.
+    #
+    # Some Rack servers concatenate repeated headers, like {HTTP RFC 2616}[http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2]
+    # requires. Some Rack servers simply drop preceding headers, and only report
+    # the value that was {given in the last header}[http://andre.arko.net/2011/12/26/repeated-headers-and-ruby-web-servers].
+    # If you are behind multiple proxy servers (like NGINX to HAProxy to Unicorn)
+    # then you should test your Rack server to make sure your data is good.
+    #
+    # IF YOU DON'T USE A PROXY, THIS MAKES YOU VULNERABLE TO IP SPOOFING.
+    # This middleware assumes that there is at least one proxy sitting around
+    # and setting headers with the client's remote IP address. If you don't use
+    # a proxy, because you are hosted on e.g. Heroku without SSL, any client can
+    # claim to have any IP address by setting the X-Forwarded-For header. If you
+    # care about that, then you need to explicitly drop or ignore those headers
+    # sometime before this middleware runs.
+    class RemoteIp
+      class IpSpoofAttackError < StandardError; end
+
+      # The default trusted IPs list simply includes IP addresses that are
+      # guaranteed by the IP specification to be private addresses. Those will
+      # not be the ultimate client IP in production, and so are discarded. See
+      # http://en.wikipedia.org/wiki/Private_network for details.
+      TRUSTED_PROXIES = [
+        "127.0.0.1",      # localhost IPv4
+        "::1",            # localhost IPv6
+        "fc00::/7",       # private IPv6 range fc00::/7
+        "10.0.0.0/8",     # private IPv4 range 10.x.x.x
+        "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
+        "192.168.0.0/16", # private IPv4 range 192.168.x.x
+      ].map { |proxy| IPAddr.new(proxy) }
+
+      attr_reader :check_ip, :proxies
+
+      # Create a new +RemoteIp+ middleware instance.
+      #
+      # The +check_ip_spoofing+ option is on by default. When on, an exception
+      # is raised if it looks like the client is trying to lie about its own IP
+      # address. It makes sense to turn off this check on sites aimed at non-IP
+      # clients (like WAP devices), or behind proxies that set headers in an
+      # incorrect or confusing way (like AWS ELB).
+      #
+      # The +custom_proxies+ argument can take an Array of string, IPAddr, or
+      # Regexp objects which will be used instead of +TRUSTED_PROXIES+. If a
+      # single string, IPAddr, or Regexp object is provided, it will be used in
+      # addition to +TRUSTED_PROXIES+. Any proxy setup will put the value you
+      # want in the middle (or at the beginning) of the X-Forwarded-For list,
+      # with your proxy servers after it. If your proxies aren't removed, pass
+      # them in via the +custom_proxies+ parameter. That way, the middleware will
+      # ignore those IP addresses, and return the one that you want.
+      def initialize(app, check_ip_spoofing = true, custom_proxies = nil)
+        @app = app
+        @check_ip = check_ip_spoofing
+        @proxies = if custom_proxies.blank?
+          TRUSTED_PROXIES
+        elsif custom_proxies.respond_to?(:any?)
+          custom_proxies
+        else
+          Array(custom_proxies) + TRUSTED_PROXIES
+        end
+      end
+
+      # Since the IP address may not be needed, we store the object here
+      # without calculating the IP to keep from slowing down the majority of
+      # requests. For those requests that do need to know the IP, the
+      # GetIp#calculate_ip method will calculate the memoized client IP address.
+      def call(env)
+        env["action_dispatch.remote_ip"] = GetIp.new(env, self)
+        @app.call(env)
+      end
+
+      # The GetIp class exists as a way to defer processing of the request data
+      # into an actual IP address. If the ActionDispatch::Request#remote_ip method
+      # is called, this class will calculate the value and then memoize it.
+      class GetIp
+        def initialize(env, middleware)
+          @env      = env
+          @check_ip = middleware.check_ip
+          @proxies  = middleware.proxies
+        end
+
+        # Sort through the various IP address headers, looking for the IP most
+        # likely to be the address of the actual remote client making this
+        # request.
+        #
+        # REMOTE_ADDR will be correct if the request is made directly against the
+        # Ruby process, on e.g. Heroku. When the request is proxied by another
+        # server like HAProxy or NGINX, the IP address that made the original
+        # request will be put in an X-Forwarded-For header. If there are multiple
+        # proxies, that header may contain a list of IPs. Other proxy services
+        # set the Client-Ip header instead, so we check that too.
+        #
+        # As discussed in {this post about Rails IP Spoofing}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection/],
+        # while the first IP in the list is likely to be the "originating" IP,
+        # it could also have been set by the client maliciously.
+        #
+        # In order to find the first address that is (probably) accurate, we
+        # take the list of IPs, remove known and trusted proxies, and then take
+        # the last address left, which was presumably set by one of those proxies.
+        def calculate_ip
+          # Set by the Rack web server, this is a single value.
+          remote_addr = ips_from('REMOTE_ADDR').last
+
+          # Could be a CSV list and/or repeated headers that were concatenated.
+          client_ips    = ips_from('HTTP_CLIENT_IP').reverse
+          forwarded_ips = ips_from('HTTP_X_FORWARDED_FOR').reverse
+
+          # +Client-Ip+ and +X-Forwarded-For+ should not, generally, both be set.
+          # If they are both set, it means that this request passed through two
+          # proxies with incompatible IP header conventions, and there is no way
+          # for us to determine which header is the right one after the fact.
+          # Since we have no idea, we give up and explode.
+          should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
+          if should_check_ip && !forwarded_ips.include?(client_ips.last)
+            # We don't know which came from the proxy, and which from the user
+            raise IpSpoofAttackError, "IP spoofing attack?! " +
+              "HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect} " +
+              "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
+          end
+
+          # We assume these things about the IP headers:
+          #
+          #   - X-Forwarded-For will be a list of IPs, one per proxy, or blank
+          #   - Client-Ip is propagated from the outermost proxy, or is blank
+          #   - REMOTE_ADDR will be the IP that made the request to Rack
+          ips = [forwarded_ips, client_ips, remote_addr].flatten.compact
+
+          # If every single IP option is in the trusted list, just return REMOTE_ADDR
+          filter_proxies(ips).first || remote_addr
+        end
+
+        # Memoizes the value returned by #calculate_ip and returns it for
+        # ActionDispatch::Request to use.
+        def to_s
+          @ip ||= calculate_ip
+        end
+
+      protected
+
+        def ips_from(header)
+          # Split the comma-separated list into an array of strings
+          ips = @env[header] ? @env[header].strip.split(/[,\s]+/) : []
+          ips.select do |ip|
+            begin
+              # Only return IPs that are valid according to the IPAddr#new method
+              range = IPAddr.new(ip).to_range
+              # we want to make sure nobody is sneaking a netmask in
+              range.begin == range.end
+            rescue ArgumentError
+              nil
+            end
+          end
+        end
+
+        def filter_proxies(ips)
+          ips.reject do |ip|
+            @proxies.any? { |proxy| proxy === ip }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/logjam_agent/middleware.rb

@@ -15,11 +15,6 @@ module LogjamAgent
     ensure
       headers = result[1]
       headers["X-Logjam-Request-Id"] = request.id
-      # this cookie is intended for JS code, which can't read it from response headers.
-      # it's superior to returning it with the html body, because that makes caching hard.
-      if set_request_id_cookie?(request, env)
-        ::Rack::Utils.set_cookie_header!(headers, "X-Logjam-Request-Id", {:value => request.id, :path => "/"})
-      end
       unless (request_action = request.fields[:action]).blank?
         headers["X-Logjam-Request-Action"] = request_action
       end
@@ -42,9 +37,5 @@ module LogjamAgent
     def finish_request(env)
       LogjamAgent.finish_request(env["time_bandits.metrics"])
     end
-
-    def set_request_id_cookie?(request, env)
-      !(request.ignored? || env["HTTP_X_REQUESTED_WITH"] == "XMLHttpRequest")
-    end
   end
 end

data/lib/logjam_agent/rack/logger.rb

@@ -77,7 +77,7 @@ module LogjamAgent
 
         logjam_request.start_time = start_time
         logjam_fields = logjam_request.fields
-        ip = LogjamAgent.ip_obfuscator(request.ip)
+        ip = LogjamAgent.ip_obfuscator(env["action_dispatch.remote_ip"])
         logjam_fields.merge!(:ip => ip, :host => @hostname)
         logjam_fields.merge!(extract_request_info(request))
 

data/lib/logjam_agent/railtie.rb

@@ -48,6 +48,14 @@ module LogjamAgent
       app.config.middleware.swap("TimeBandits::Rack::Logger", "LogjamAgent::Rack::Logger")
       app.config.middleware.insert_before("LogjamAgent::Rack::Logger", "LogjamAgent::Middleware")
 
+      if defined?(::ActionDispatch::RemoteIp)
+        app.config.middleware.delete ::ActionDispatch::RemoteIp
+        app.config.middleware.insert_before LogjamAgent::Middleware, ::ActionDispatch::RemoteIp, app.config.action_dispatch.ip_spoofing_check, app.config.action_dispatch.trusted_proxies
+      else
+        require 'logjam_agent/actionpack/lib/action_dispatch/middleware/remote_ip'
+        app.config.middleware.insert_before LogjamAgent::Middleware, LogjamAgent::ActionDispatch::RemoteIp
+      end
+
       # install a default error handler for forwarding errors
       log_dir = File.dirname(logjam_log_path(app))
       begin
@@ -79,38 +87,6 @@ module LogjamAgent
           end
         end
       end
-
-      # patch rack so that the ip method returns the same result as rails remote_ip (modulo exceptions)
-      app.config.after_initialize do
-        if app.config.action_dispatch.trusted_proxies
-          trusted_proxies = /^127\.0\.0\.1$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|^::1$|^fd[0-9a-f]{2}:.+|^localhost$/i
-          trusted_proxies = Regexp.union(trusted_proxies, app.config.action_dispatch.trusted_proxies)
-          ::Rack::Request.class_eval <<-"EVA"
-            def trusted_proxy?(ip)
-              ip =~ #{trusted_proxies.inspect}
-            end
-          EVA
-        end
-
-        ::Rack::Request.class_eval <<-EVA
-          def ip
-            remote_addrs = @env['REMOTE_ADDR'] ? @env['REMOTE_ADDR'].split(/[,\s]+/) : []
-            remote_addrs.reject! { |addr| trusted_proxy?(addr) }
-
-            return remote_addrs.first if remote_addrs.any?
-
-            forwarded_ips = @env['HTTP_X_FORWARDED_FOR'] ? @env['HTTP_X_FORWARDED_FOR'].strip.split(/[,\s]+/) : []
-
-            if client_ip = @env['HTTP_TRUE_CLIENT_IP'] || @env['HTTP_CLIENT_IP']
-              # If forwarded_ips doesn't include the client_ip, it might be an
-              # ip spoofing attempt, so we ignore HTTP_CLIENT_IP
-              return client_ip if forwarded_ips.include?(client_ip)
-            end
-
-            return forwarded_ips.reject { |ip| trusted_proxy?(ip) }.last || @env["REMOTE_ADDR"]
-          end
-        EVA
-      end
     end
 
     # avoid garbled tempfile information in the logs

data/lib/logjam_agent/version.rb

@@ -1,3 +1,3 @@
 module LogjamAgent
-  VERSION = "0.18.0"
+  VERSION = "0.19.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logjam_agent
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Stefan Kaes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-25 00:00:00.000000000 Z
+date: 2016-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -120,6 +120,7 @@ files:
 - README.md
 - Rakefile
 - lib/logjam_agent.rb
+- lib/logjam_agent/actionpack/lib/action_dispatch/middleware/remote_ip.rb
 - lib/logjam_agent/amqp_forwarder.rb
 - lib/logjam_agent/buffered_logger.rb
 - lib/logjam_agent/forwarders.rb