wafris 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b12f70edd52fc81916790101bddabe8e450b1d97683bc115be5737e5a4d3562a
-  data.tar.gz: cf42cbb5eb83750ad066b4762e3b42fead8c02ea3f7c18b6494c0bef1b0c6a48
+  metadata.gz: 531133646bfb1df1b2b61c250179cd46de9e7986bc05075e509bededcd24bfbc
+  data.tar.gz: 4971a237b63f18b5f50d95751fd18ed51f4aa863fcd89da97be46c77176b31e8
 SHA512:
-  metadata.gz: 6839912471ef9957061996a9376119f907cf6d99f5d6d92a48c08d57a0c7f106f1d3234b9be431ad6b53b99d6e026bbc614d4fe47398738b48cf935b507b8616
-  data.tar.gz: eca82696939268ef17064912d3d072686ebd01eac5d1a7aa32e35ca2f72c8d7073176c58cc9010a4d308b2113273c43b9f9b1af8a56b5ad559cbc837b3b3092c
+  metadata.gz: 835a0b2ff984d50e6de308db53dacfba7490a7d41a5ae426b26347a23b862e05ea5f0a0250e31d66a0a952335e083ce16843476c1e98004f62131a4c7d52349c
+  data.tar.gz: 2e9df9bdf15d055730171a1da8126e59adb754ba1d033949739fc2a3e5b001c5e58144d4453a84c98922bb93faac59fc911c49f430aa95f582d9511958b02f3d

data/lib/wafris/configuration.rb

@@ -1,9 +1,7 @@
-
-require_relative 'version'
+require_relative "version"
 
 module Wafris
   class Configuration
-
     attr_accessor :api_key
     attr_accessor :db_file_path
     attr_accessor :db_file_name
@@ -21,23 +19,17 @@ module Wafris
     attr_accessor :rate_limiters
 
     def initialize
-
       # API Key - Required
-      if ENV['WAFRIS_API_KEY']
-        @api_key = ENV['WAFRIS_API_KEY']        
+      if ENV["WAFRIS_API_KEY"]
+        @api_key = ENV["WAFRIS_API_KEY"]
       else
-        unless @api_key         
-          LogSuppressor.puts_log("Firewall disabled as neither local only or API key set")        
+        unless @api_key
+          LogSuppressor.puts_log("Firewall disabled as neither local only or API key set")
         end
       end
 
       # DB FILE PATH LOCATION - Optional
-      if ENV['WAFRIS_DB_FILE_PATH']
-        @db_file_path = ENV['WAFRIS_DB_FILE_PATH']      
-      else
-        #@db_file_path = Rails.root.join('tmp', 'wafris').to_s
-        @db_file_path = './tmp/wafris'
-      end
+      @db_file_path = ENV["WAFRIS_DB_FILE_PATH"] || "./tmp/wafris"
 
       # Ensure that the db_file_path exists
       unless File.directory?(@db_file_path)
@@ -46,95 +38,61 @@ module Wafris
       end
 
       # DB FILE NAME - For local
-      if ENV['WAFRIS_DB_FILE_NAME']
-        @db_file_name = ENV['WAFRIS_DB_FILE_NAME']
-      else
-        @db_file_name = 'wafris.db'
-      end
-  
+      @db_file_name = ENV["WAFRIS_DB_FILE_NAME"] || "wafris.db"
+
       # DOWNSYNC
       # Custom Rules are checked often (default 1 minute) - Optional
-      if ENV['WAFRIS_DOWNSYNC_CUSTOM_RULES_INTERVAL']
-        @downsync_custom_rules_interval = ENV['WAFRIS_DOWNSYNC_CUSTOM_RULES_INTERVAL'].to_i
-      else
-        @downsync_custom_rules_interval = 60
-      end
-  
+      @downsync_custom_rules_interval = ENV["WAFRIS_DOWNSYNC_CUSTOM_RULES_INTERVAL"]&.to_i || 60
+
       # Data Subscriptions are checked rarely (default 1 day) - Optional
-      if ENV['WAFRIS_DOWNSYNC_DATA_SUBSCRIPTIONS_INTERVAL'] 
-        @downsync_data_subscriptions_interval = ENV['WAFRIS_DOWNSYNC_DATA_SUBSCRIPTIONS_INTERVAL'].to_i
-      else
-        @downsync_data_subscriptions_interval = 60
-      end
-  
+      @downsync_data_subscriptions_interval = ENV["WAFRIS_DOWNSYNC_DATA_SUBSCRIPTIONS_INTERVAL"]&.to_i || 60
+
       # Set Downsync URL - Optional
       # Used for both DataSubscription and CustomRules
-      if ENV['WAFRIS_DOWNSYNC_URL']
-        @downsync_url = ENV['WAFRIS_DOWNSYNC_URL']
-      else
-        @downsync_url = 'https://distributor.wafris.org/v2/downsync'
-      end
-      
+      @downsync_url = ENV["WAFRIS_DOWNSYNC_URL"] || "https://distributor.wafris.org/v2/downsync"
+
       # UPSYNC - Optional
       # Set Upsync URL
-      if ENV['WAFRIS_UPSYNC_URL']
-        @upsync_url = ENV['WAFRIS_UPSYNC_URL']
-      else
-        @upsync_url = 'https://collector.wafris.org/v2/upsync' 
-      end
-  
+      @upsync_url = ENV["WAFRIS_UPSYNC_URL"] || "https://collector.wafris.org/v2/upsync"
+
       # Set Upsync Interval - Optional
-      if ENV['WAFRIS_UPSYNC_INTERVAL']
-        @upsync_interval = ENV['WAFRIS_UPSYNC_INTERVAL'].to_i
-      else
-        @upsync_interval = 10
-      end
-    
+      @upsync_interval = ENV["WAFRIS_UPSYNC_INTERVAL"]&.to_i || 10
+
       # Set Upsync Queued Request Limit - Optional
-      if ENV['WAFRIS_UPSYNC_QUEUE_LIMIT']
-        @upsync_queue_limit = ENV['WAFRIS_UPSYNC_QUEUE_LIMIT'].to_i
-      else
-        @upsync_queue_limit = 250
-      end
-  
+      @upsync_queue_limit = ENV["WAFRIS_UPSYNC_QUEUE_LIMIT"]&.to_i || 250
+
       # Set Maximium Body Size for Requests - Optional (in Megabytes)
-      if ENV['WAFRIS_MAX_BODY_SIZE_MB'] && ENV['WAFRIS_MAX_BODY_SIZE_MB'].to_i > 0  
-        @max_body_size_mb = ENV['WAFRIS_MAX_BODY_SIZE_MB'].to_i
-      else
-        @max_body_size_mb = 10
-      end
+      @max_body_size_mb = if ENV["WAFRIS_MAX_BODY_SIZE_MB"] && ENV["WAFRIS_MAX_BODY_SIZE_MB"].to_i > 0
+                            ENV["WAFRIS_MAX_BODY_SIZE_MB"].to_i
+                          else
+                            10
+                          end
 
       # Upsync Queue Defaults
       @upsync_queue = []
       @last_upsync_timestamp = Time.now.to_i
-  
+
       # Memory structure for rate limiting
       @rate_limiters = {}
-  
+
       # Disable Upsync if Downsync API Key is invalid
       # This prevents the client from sending upsync requests
       # if the API key is known bad
-      @upsync_status = 'Disabled'
-
-      return true
-  
+      @upsync_status = "Disabled"
     end
 
     def current_config
-
       output = {}
 
       instance_variables.each do |var|
         output[var.to_s] = instance_variable_get(var)
       end
 
-      return output
-
+      output
     end
 
     def create_settings
       @version = Wafris::VERSION
     end
-
   end
 end

data/lib/wafris/log_suppressor.rb

@@ -7,19 +7,19 @@ module Wafris
     end
 
     def self.suppress_logs?
-      suppressed_environments.include?(current_environment) || 
-      (ENV['WAFRIS_LOG_LEVEL'] && ENV['WAFRIS_LOG_LEVEL'] == 'silent')
+      suppressed_environments.include?(current_environment) ||
+        (ENV["WAFRIS_LOG_LEVEL"] && ENV["WAFRIS_LOG_LEVEL"] == "silent")
     end
 
     def self.suppressed_environments
-      ['test'] + (ENV['CI'] ? ['CI'] : [])
+      ["test"] + (ENV["CI"] ? ["CI"] : [])
     end
 
     def self.current_environment
       if defined?(Rails)
         Rails.env
       else
-        ENV['RACK_ENV'] || 'development'
+        ENV["RACK_ENV"] || "development"
       end
     end
   end

data/lib/wafris/middleware.rb

@@ -9,32 +9,20 @@ module Wafris
 
     def call(env)
       request = Rack::Request.new(env)
-      wafris_request = WafrisRequest.new(request, env)
 
       treatment = Wafris.evaluate(
-        wafris_request.ip,
-        wafris_request.user_agent,
-        wafris_request.path,
-        wafris_request.parameters,
-        wafris_request.host,
-        wafris_request.request_method,
-        wafris_request.headers,
-        wafris_request.body,
-        wafris_request.request_id,
-        wafris_request.request_timestamp
+        WafrisRequest.new(request, env)
       )
 
       # These values match what the client tests expect (200, 404, 403, 500)
-      if treatment == 'Allowed' || treatment == 'Passed'
+      if treatment == "Allowed" || treatment == "Passed"
         @app.call(env)
-      elsif treatment == 'Blocked'
-        [403, { 'content-type' => 'text/plain' }, ['Blocked']]
+      elsif treatment == "Blocked"
+        [403, {"content-type" => "text/plain"}, ["Blocked"]]
       else
-        #ap request
-        [500, { 'content-type' => 'text/plain' }, ['Error']]
+        [500, {"content-type" => "text/plain"}, ["Error"]]
       end
-
-    rescue StandardError => e
+    rescue => e
       LogSuppressor.puts_log "[Wafris] Detailed Error: #{e.class} - #{e.message}"
       LogSuppressor.puts_log "[Wafris] Backtrace: #{e.backtrace.join("\n")}"
       @app.call(env)

data/lib/wafris/proxy_filter.rb

@@ -3,7 +3,7 @@
 module Wafris
   module ProxyFilter
     def self.set_filter
-      user_defined_proxies = ENV['TRUSTED_PROXY_RANGES'].split(',') if ENV['TRUSTED_PROXY_RANGES']
+      user_defined_proxies = ENV["TRUSTED_PROXY_RANGES"].split(",") if ENV["TRUSTED_PROXY_RANGES"]
 
       valid_ipv4_octet = /\.(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])/
 
@@ -21,4 +21,4 @@ module Wafris
       Rack::Request.ip_filter = lambda { |ip| trusted_proxies.match?(ip) }
     end
   end
-end
+end

data/lib/wafris/railtie.rb

@@ -2,7 +2,7 @@
 
 module Wafris
   class Railtie < ::Rails::Railtie
-    initializer 'wafris.middleware' do |app|
+    initializer "wafris.middleware" do |app|
       app.middleware.use(Wafris::Middleware)
     end
   end

data/lib/wafris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wafris
-  VERSION = "2.0.3"
+  VERSION = "2.0.4"
 end

data/lib/wafris/wafris_request.rb

@@ -2,7 +2,7 @@
 
 module Wafris
   class WafrisRequest
-    attr_reader :ip, :user_agent, :path, :parameters, :host, :request_method,
+    attr_reader :ip, :user_agent, :path, :parameters, :host, :method,
                 :headers, :body, :request_id, :request_timestamp
 
     def initialize(request, env)
@@ -11,25 +11,43 @@ module Wafris
       @path = encode_to_utf8(request.path)
       @parameters = encode_to_utf8(Rack::Utils.build_query(request.params))
       @host = encode_to_utf8(request.host.to_s)
-      @request_method = encode_to_utf8(request.request_method)
+      @method = encode_to_utf8(request.request_method)
       @headers = extract_headers(env)
-      @body = encode_to_utf8(request.body&.string)
-      @request_id = env.fetch('action_dispatch.request_id', SecureRandom.uuid.to_s)
+      @request_id = env.fetch("action_dispatch.request_id", SecureRandom.uuid.to_s)
       @request_timestamp = Time.now.utc.to_i
+
+      @body = encode_to_utf8(request.body&.read)
+      request.body&.rewind
+    end
+
+    def data(treatment:, category:, rule:)
+      {
+        ip: @ip,
+        user_agent: @user_agent,
+        path: @path,
+        parameter: @parameters,
+        host: @host,
+        method: @method,
+        request_id: @request_id,
+        timestamp: @request_timestamp,
+        treatment: treatment,
+        category: category,
+        rule: rule
+      }
     end
 
     private
 
     def extract_headers(env)
       env.each_with_object({}) do |(k, v), h|
-        h[k] = encode_to_utf8(v) if k.start_with?('HTTP_')
+        h[k] = encode_to_utf8(v) if k.start_with?("HTTP_")
       end
     end
 
     def encode_to_utf8(value)
-      return '' if value.nil?
+      return "" if value.nil?
 
-      value&.dup&.force_encoding('UTF-8')
+      value&.dup&.force_encoding("UTF-8")
     end
   end
 end

data/lib/wafris.rb

@@ -1,45 +1,41 @@
 # frozen_string_literal: true
 
-require 'rails'
-require 'sqlite3'
-require 'ipaddr'
-require 'httparty'
-require 'awesome_print'
+require "rails"
+require "sqlite3"
+require "ipaddr"
+require "httparty"
+require "awesome_print"
 
-require 'wafris/configuration'
-require 'wafris/middleware'
-require 'wafris/log_suppressor'
-require 'wafris/proxy_filter'
-require 'wafris/ip_resolver'
-require 'wafris/wafris_request'
+require "wafris/configuration"
+require "wafris/middleware"
+require "wafris/log_suppressor"
+require "wafris/proxy_filter"
+require "wafris/ip_resolver"
+require "wafris/wafris_request"
 
-require 'wafris/railtie' if defined?(Rails::Railtie)
+require "wafris/railtie" if defined?(Rails::Railtie)
 
 module Wafris
   class << self
     attr_accessor :configuration
 
     def configure
-      begin
-        self.configuration ||= Wafris::Configuration.new      
-        yield(configuration)
-        
-        LogSuppressor.puts_log("[Wafris] Configuration settings created.")
-        configuration.create_settings
-
-      rescue StandardError => e
-        puts "[Wafris] firewall disabled due to: #{e.message}. Cannot connect via Wafris.configure. Please check your configuration settings. More info can be found at: https://github.com/Wafris/wafris-rb"
-      end 
+      self.configuration ||= Wafris::Configuration.new
+      yield(configuration)
 
+      LogSuppressor.puts_log("[Wafris] Configuration settings created.")
+      configuration.create_settings
+    rescue => e
+      puts "[Wafris] firewall disabled due to: #{e.message}. Cannot connect via Wafris.configure. Please check your configuration settings. More info can be found at: https://github.com/Wafris/wafris-rb"
     end
 
     def zero_pad(number, length)
       number.to_s.rjust(length, "0")
     end
-  
+
     def ip_to_decimal_lexical_string(ip)
       num = 0
-  
+
       if ip.include?(":")
         ip = IPAddr.new(ip).to_string
         hex = ip.delete(":")
@@ -52,41 +48,39 @@ module Wafris
           num = num * 256 + chunk.to_i
         end
       end
-  
+
       str = num.to_s
       zero_pad(str, 39)
     end
-  
+
     def ip_in_cidr_range(ip_address, table_name, db_connection)
       lexical_address = ip_to_decimal_lexical_string(ip_address)
       higher_value = db_connection.get_first_value("SELECT * FROM #{table_name} WHERE member > ? ORDER BY member ASC", [lexical_address])
       lower_value = db_connection.get_first_value("SELECT * FROM #{table_name} WHERE member < ? ORDER BY member DESC", [lexical_address])
-  
+
       if higher_value.nil? || lower_value.nil?
-        return nil
-      else 
+        nil
+      else
         higher_compare = higher_value.split("-").last
         lower_compare = lower_value.split("-").last
-    
+
         if higher_compare == lower_compare
-          return lower_compare
-        else
-          return nil
+          lower_compare
         end
       end
     end
-  
+
     def get_country_code(ip, db_connection)
-      country_code = ip_in_cidr_range(ip, 'country_ip_ranges', db_connection)
-  
+      country_code = ip_in_cidr_range(ip, "country_ip_ranges", db_connection)
+
       if country_code
-        country_code = country_code.split("_").first.split("G").last
-        return country_code
-      else 
-        return "ZZ"
-      end 
+        country_code.split("_").first.split("G").last
+
+      else
+        "ZZ"
+      end
     end
-  
+
     def substring_match(request_property, table_name, db_connection)
       result = db_connection.execute("SELECT entries FROM #{table_name}")
       result.flatten.each do |entry|
@@ -94,30 +88,28 @@ module Wafris
           return entry
         end
       end
-      return false
+      false
     end
-  
+
     def exact_match(request_property, table_name, db_connection)
       result = db_connection.execute("SELECT entries FROM #{table_name} WHERE entries = ?", [request_property])
-      return result.any?
+      result.any?
     end
-  
+
     def check_rate_limit(ip, path, method, db_connection)
-  
       # Correctly format the SQL query with placeholders
       limiters = db_connection.execute("SELECT * FROM blocked_rate_limits WHERE path = ? AND method = ?", [path, method])
-    
+
       # If no rate limiters are matched
-      if limiters.empty?        
+      if limiters.empty?
         return false
-      end 
-  
+      end
+
       current_timestamp = Time.now.to_i
-  
+
       # If any rate limiters are matched
       # This implementation will block the request on any of the rate limiters
       limiters.each do |limiter|
-  
         # Limiter array mapping
         # 0: id
         # 1: path
@@ -125,99 +117,89 @@ module Wafris
         # 3: interval
         # 4: max_count
         # 5: rule_id
-  
+
         interval = limiter[3]
-        max_count = limiter[4]      
+        max_count = limiter[4]
         rule_id = limiter[5]
-  
+
         # Expire old timestamps
         @configuration.rate_limiters.each do |ip, timestamps|
           # Removes timestamps older than the interval
-  
+
           @configuration.rate_limiters[ip] = timestamps.select { |timestamp| timestamp > current_timestamp - interval }
-          
+
           # Remove the IP if there are no more timestamps for the IP
           @configuration.rate_limiters.delete(ip) if @configuration.rate_limiters[ip].empty?
         end
-  
-        # Check if the IP+Method is rate limited 
-  
+
+        # Check if the IP+Method is rate limited
+
         if @configuration.rate_limiters[ip] && @configuration.rate_limiters[ip].length >= max_count
           # Request is rate limited
-  
-          
+
           return rule_id
-  
+
         else
           # Request is not rate limited, so add the current timestamp
           if @configuration.rate_limiters[ip]
-            @configuration.rate_limiters[ip] << current_timestamp              
-          else 
+            @configuration.rate_limiters[ip] << current_timestamp
+          else
             @configuration.rate_limiters[ip] = [current_timestamp]
           end
-  
+
           return false
         end
-  
       end
-  
     end
-  
+
     def send_upsync_requests(requests_array)
-      begin
-        headers = {'Content-Type' => 'application/json'}
+      headers = { "Content-Type" => "application/json" }
 
-        if Rails && Rails.application
-          framework = "Rails v#{Rails::VERSION::STRING}"
-        else
-          framework = "Rack v#{Rack::VERSION::STRING}"
-        end
+      framework = defined?(Rails) ? "Rails v#{Rails::VERSION::STRING}" : "Rack v#{Rack.release}"
 
-        body = {
-          meta: {
-            version: Wafris::VERSION,
-            client: 'wafris-rb',
-            framework: framework
-          },
-          batch: requests_array
-        }.to_json
+      body = {
+        meta: {
+          version: Wafris::VERSION,
+          client: "wafris-rb",
+          framework: framework
+        },
+        batch: requests_array
+      }.to_json
 
-        url_and_api_key = @configuration.upsync_url + '/' + @configuration.api_key
+      url_and_api_key = @configuration.upsync_url + "/" + @configuration.api_key
 
-        response = HTTParty.post(url_and_api_key, 
-                                 :body => body, 
-                                 :headers => headers, 
-                                 :timeout => 300)
+      response = HTTParty.post(
+        url_and_api_key,
+        body: body,
+        headers: headers,
+        timeout: 10
+      )
 
-        if response.code == 200          
-          @configuration.upsync_status = 'Complete'
-        else
-          LogSuppressor.puts_log("Upsync Error. HTTP Response: #{response.code}")          
-        end    
-      rescue HTTParty::Error => e
-        LogSuppressor.puts_log("Upsync Error. Failed to send upsync requests: #{e.message}")
+      if response.code == 200
+        @configuration.upsync_status = "Complete"
+      else
+        LogSuppressor.puts_log("Upsync Error. HTTP Response: #{response.code}")
       end
-      return true
+    rescue HTTParty::Error => e
+      LogSuppressor.puts_log("Upsync Error. Failed to send upsync requests: #{e.message}")
     end
-  
-    # This method is used to queue upsync requests. It takes in several parameters including 
-    # ip, user_agent, path, parameters, host, method, treatment, category, and rule. 
+
+    # This method is used to queue upsync requests. It takes in several parameters including:
     #
-    # The 'treatment' parameter represents the action taken on the request, which can be 
+    # The 'treatment' parameter represents the action taken on the request, which can be
     # 'Allowed', 'Blocked', or 'Passed'.
     #
-    # The 'category' parameter represents the category of the rule that was matched, such as 
+    # The 'category' parameter represents the category of the rule that was matched, such as
     # 'blocked_ip', 'allowed_cidr', etc.
     #
-    # The 'rule' parameter represents the specific rule that was matched within the category 
+    # The 'rule' parameter represents the specific rule that was matched within the category
     # ex: '192.23.5.4', 'SemRush', etc.
-    def queue_upsync_request(ip, user_agent, path, parameters, host, method, treatment, category, rule, request_id, request_timestamp)
-      if @configuration.upsync_status != 'Disabled' || @configuration.upsync_status != 'Uploading'
-        @configuration.upsync_status = 'Uploading'
+    def queue_upsync_request(request, treatment, category, rule)
+      if @configuration.upsync_status != "Disabled" || @configuration.upsync_status != "Uploading"
+        @configuration.upsync_status = "Uploading"
 
         # Add request to the queue
-        request = [ip, user_agent, path, parameters, host, method, treatment, category, rule, request_id, request_timestamp]
-        @configuration.upsync_queue << request
+        @configuration.upsync_queue << request.data(treatment: treatment, category: category, rule: rule)
 
         # If the queue is full, send the requests to the upsync server
         if @configuration.upsync_queue.length >= @configuration.upsync_queue_limit || (Time.now.to_i - @configuration.last_upsync_timestamp) >= @configuration.upsync_interval
@@ -228,7 +210,7 @@ module Wafris
           send_upsync_requests(requests_array)
         end
 
-        @configuration.upsync_status = 'Enabled'
+        @configuration.upsync_status = "Enabled"
         # Return the treatment - used to return 403 or 200
 
         message = "Request #{treatment}"
@@ -236,103 +218,97 @@ module Wafris
         message += " | Rule: #{rule}" unless rule.blank?
         LogSuppressor.puts_log(message)
 
-        return treatment
+        treatment
       else
-        @configuration.upsync_status = 'Enabled'        
-        return "Passed"
+        @configuration.upsync_status = "Enabled"
+        "Passed"
       end
-  
     end
-  
+
     # Pulls the latest rules from the server
     def downsync_db(db_rule_category, current_filename = nil)
-  
       lockfile_path = "#{@configuration.db_file_path}/#{db_rule_category}.lockfile"
-  
+
       # Ensure the directory exists before attempting to open the lockfile
       FileUtils.mkdir_p(@configuration.db_file_path) unless Dir.exist?(@configuration.db_file_path)
 
       # Attempt to create a lockfile with exclusive access; skip if it exists
       begin
-        lockfile = File.open(lockfile_path, File::RDWR|File::CREAT|File::EXCL)
+        lockfile = File.open(lockfile_path, File::RDWR | File::CREAT | File::EXCL)
       rescue Errno::EEXIST
         LogSuppressor.puts_log("[Wafris][Downsync] Lockfile already exists, skipping downsync.")
         return
       rescue Exception => e
         LogSuppressor.puts_log("[Wafris][Downsync] Error creating lockfile: #{e.message}")
       end
-  
+
       begin
         # Actual Downsync operations
         filename = ""
-  
-        if Rails && Rails.application
-          framework = "Rails v#{Rails::VERSION::STRING}"
-        else
-          framework = "Rack v#{Rack::VERSION::STRING}"
-        end
+
+        framework = defined?(Rails) ? "Rails v#{Rails::VERSION::STRING}" : "Rack v#{Rack.release}"
 
         data = {
           client_db: current_filename,
           process_id: Process.pid,
           hostname: Socket.gethostname,
           version: Wafris::VERSION,
-          client: 'wafris-rb',
+          client: "wafris-rb",
           framework: framework
         }
 
         # Check server for new rules including process id
-        #puts "Downloading from #{@configuration.downsync_url}/#{db_rule_category}/#{@configuration.api_key}?current_version=#{current_filename}&process_id=#{Process.pid}"
+        # puts "Downloading from #{@configuration.downsync_url}/#{db_rule_category}/#{@configuration.api_key}?current_version=#{current_filename}&process_id=#{Process.pid}"
         uri = "#{@configuration.downsync_url}/#{db_rule_category}/#{@configuration.api_key}?#{data.to_query}"
-    
+
         response = HTTParty.get(
           uri,
           follow_redirects: true,   # Enable following redirects
           max_redirects: 2          # Maximum number of redirects to follow
         )
-  
+
         # TODO: What to do if timeout
-        # TODO: What to do if error        
+        # TODO: What to do if error
 
         if response.code == 401
-          @configuration.upsync_status = 'Disabled'
+          @configuration.upsync_status = "Disabled"
           LogSuppressor.puts_log("[Wafris][Downsync] Unauthorized: Bad or missing API key")
           LogSuppressor.puts_log("[Wafris][Downsync] API Key: #{@configuration.api_key}")
           filename = current_filename
-          
+
         elsif response.code == 304
-          @configuration.upsync_status = 'Enabled'
+          @configuration.upsync_status = "Enabled"
           LogSuppressor.puts_log("[Wafris][Downsync] No new rules to download")
-    
+
           filename = current_filename
-          
+
         elsif response.code == 200
-          @configuration.upsync_status = 'Enabled'
-  
+          @configuration.upsync_status = "Enabled"
+
           if current_filename
             old_file_name = current_filename
           end
-    
-          # Extract the filename from the response        
-          content_disposition = response.headers['content-disposition']          
-          filename = content_disposition.split('filename=')[1].strip
-    
-          # Save the body of the response to a new SQLite file      
-          File.open(@configuration.db_file_path + "/" + filename, 'wb') { |file| file.write(response.body) }
-          
+
+          # Extract the filename from the response
+          content_disposition = response.headers["content-disposition"]
+          filename = content_disposition.split("filename=")[1].strip
+
+          # Save the body of the response to a new SQLite file
+          File.binwrite(@configuration.db_file_path + "/" + filename, response.body)
+
           # Write the filename into the db_category.modfile
-          File.open("#{@configuration.db_file_path}/#{db_rule_category}.modfile", 'w') { |file| file.write(filename) }
-    
+          File.write("#{@configuration.db_file_path}/#{db_rule_category}.modfile", filename)
+
           # Sanity check that the downloaded db file has tables
           # not empty or corrupted
-          db = SQLite3::Database.new @configuration.db_file_path + "/" + filename          
+          db = SQLite3::Database.new @configuration.db_file_path + "/" + filename
           if db.execute("SELECT name FROM sqlite_master WHERE type='table';").any?
-              # Remove the old database file      
-              if old_file_name                 
-                if File.exist?(@configuration.db_file_path + "/" + old_file_name)
-                File.delete(@configuration.db_file_path + "/" + old_file_name) 
-                end
+            # Remove the old database file
+            if old_file_name
+              if File.exist?(@configuration.db_file_path + "/" + old_file_name)
+                File.delete(@configuration.db_file_path + "/" + old_file_name)
               end
+            end
 
           # DB file is bad or empty so keep using whatever we have now
           else
@@ -340,210 +316,163 @@ module Wafris
             LogSuppressor.puts_log("[Wafris][Downsync] DB Error - No tables exist in the db file #{@configuration.db_file_path}/#{filename}")
           end
 
-          
         end
-    
-      rescue Exception => e
+      rescue => e
         LogSuppressor.puts_log("[Wafris][Downsync] Error downloading rules: #{e.message}")
-  
+
       # This gets set even if the API key is bad or other issues
       # to prevent hammering the distribution server on every request
       ensure
-    
         # Reset the modified time of the modfile
         unless File.exist?("#{@configuration.db_file_path}/#{db_rule_category}.modfile")
-          File.new("#{@configuration.db_file_path}/#{db_rule_category}.modfile", 'w')
+          File.new("#{@configuration.db_file_path}/#{db_rule_category}.modfile", "w")
         end
-  
+
         # Set the modified time of the modfile to the current time
         File.utime(Time.now, Time.now, "#{@configuration.db_file_path}/#{db_rule_category}.modfile")
-    
+
         # Ensure the lockfile is removed after operations
         lockfile.close
         File.delete(lockfile_path)
       end
-  
-      return filename
-  
+
+      filename
     end
-  
-    # Returns the current database file, 
+
+    # Returns the current database file,
     # if the file is older than the interval, it will download the latest db
     # if the file doesn't exist, it will download the latest db
     # if the lockfile exists, it will return the current db
     def current_db(db_rule_category)
-        
-      if db_rule_category == 'custom_rules'
-        interval = @configuration.downsync_custom_rules_interval
-      else 
-        interval = @configuration.downsync_data_subscriptions_interval
-      end 
-  
+      interval = if db_rule_category == "custom_rules"
+                   @configuration.downsync_custom_rules_interval
+                 else
+                   @configuration.downsync_data_subscriptions_interval
+                 end
+
       # Checks for existing current modfile, which contains the current db filename
       if File.exist?("#{@configuration.db_file_path}/#{db_rule_category}.modfile")
-  
+
         LogSuppressor.puts_log("[Wafris][Downsync] Modfile exists, skipping downsync")
 
         # Get last Modified Time and current database file name
         last_db_synctime = File.mtime("#{@configuration.db_file_path}/#{db_rule_category}.modfile").to_i
         returned_db = File.read("#{@configuration.db_file_path}/#{db_rule_category}.modfile").strip
-  
+
         LogSuppressor.puts_log("[Wafris][Downsync] Modfile Last Modified Time: #{last_db_synctime}")
-        LogSuppressor.puts_log("[Wafris][Downsync] DB in Modfile: #{returned_db}")        
+        LogSuppressor.puts_log("[Wafris][Downsync] DB in Modfile: #{returned_db}")
 
-        # Check if the db file is older than the interval      
+        # Check if the db file is older than the interval
         if (Time.now.to_i - last_db_synctime) > interval
-  
+
           LogSuppressor.puts_log("[Wafris][Downsync] DB is older than the interval")
 
           # Make sure that another process isn't already downloading the rules
           if !File.exist?("#{@configuration.db_file_path}/#{db_rule_category}.lockfile")
-            returned_db = downsync_db(db_rule_category, returned_db)        
+            returned_db = downsync_db(db_rule_category, returned_db)
           end
-  
-          return returned_db
-  
+
+          returned_db
+
         # Current db is up to date
-        else 
-  
+        else
+
           LogSuppressor.puts_log("[Wafris][Downsync] DB is up to date")
 
           returned_db = File.read("#{@configuration.db_file_path}/#{db_rule_category}.modfile").strip
-  
+
           # If the modfile is empty (no db file name), return nil
           # this can happen if the the api key is bad
-          if returned_db == ''
-            return ''
+          if returned_db == ""
+            ""
           else
-            return returned_db
+            returned_db
           end
-  
+
         end
-  
+
       # No modfile exists, so download the latest db
-      else 
-  
+      else
+
         LogSuppressor.puts_log("[Wafris][Downsync] No modfile exists, downloading latest db")
 
         # Make sure that another process isn't already downloading the rules
         if File.exist?("#{@configuration.db_file_path}/#{db_rule_category}.lockfile")
           LogSuppressor.puts_log("[Wafris][Downsync] Lockfile exists, skipping downsync")
           # Lockfile exists, but no modfile with a db filename
-          return nil
+          nil
         else
-  
+
           LogSuppressor.puts_log("[Wafris][Downsync] No modfile exists, downloading latest db")
           # No modfile exists, so download the latest db
           returned_db = downsync_db(db_rule_category, nil)
-  
+
           if returned_db.nil?
-            return nil
-          else 
-            return returned_db
+            nil
+          else
+            returned_db
           end
-  
         end
-  
-      end 
-  
+      end
     end
-  
+
     # This is the main loop that evaluates the request
     # as well as sorts out when downsync and upsync should be called
-    def evaluate(ip, user_agent, path, parameters, host, method, _headers, _body, request_id, request_timestamp)
+    def evaluate(request)
       @configuration ||= Wafris::Configuration.new
 
-      if @configuration.api_key.nil?
-        return "Passed"
-      else
-        rules_db_filename = current_db('custom_rules')
-        data_subscriptions_db_filename = current_db('data_subscriptions')
+      return "Passed" if @configuration.api_key.nil?
 
-        if rules_db_filename.to_s.strip != '' && data_subscriptions_db_filename.strip.to_s.strip != ''
+      rules_db_filename = current_db("custom_rules")
+      data_subscriptions_db_filename = current_db("data_subscriptions")
 
-          rules_db = SQLite3::Database.new "#{@configuration.db_file_path}/#{rules_db_filename}"
-          data_subscriptions_db =
-            SQLite3::Database.new "#{@configuration.db_file_path}/#{data_subscriptions_db_filename}"
+      # Checks to see if the filenames are present before loading the db
+      if rules_db_filename.to_s.strip != "" && data_subscriptions_db_filename.strip.to_s.strip != ""
 
-          # Allowed IPs
-          if exact_match(ip, 'allowed_ips', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Allowed', 'ai',
-                                        ip, request_id, request_timestamp)
-          end
+        rules_db = SQLite3::Database.new "#{@configuration.db_file_path}/#{rules_db_filename}"
+        data_subscriptions_db =
+          SQLite3::Database.new "#{@configuration.db_file_path}/#{data_subscriptions_db_filename}"
 
-          # Allowed CIDR Ranges
-          if ip_in_cidr_range(ip, 'allowed_cidr_ranges', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Allowed', 'ac', ip, request_id, request_timestamp)
-          end
+        ip = request.ip
+        return queue_upsync_request(request, "Allowed", "ai", ip) if exact_match(ip, "allowed_ips", rules_db)
+        return queue_upsync_request(request, "Allowed", "ac", ip) if ip_in_cidr_range(ip, "allowed_cidr_ranges", rules_db)
+        return queue_upsync_request(request, "Blocked", "bi", ip) if exact_match(ip, "blocked_ips", rules_db)
+        return queue_upsync_request(request, "Blocked", "bc", ip) if ip_in_cidr_range(ip, "blocked_cidr_ranges", rules_db)
 
-          # Blocked IPs
-          if exact_match(ip, 'blocked_ips', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bi', ip, request_id, request_timestamp)
-          end
+        country_code = get_country_code(ip, data_subscriptions_db)
+        return queue_upsync_request(request, "Blocked", "bs", "G_#{country_code}") if exact_match(country_code, "blocked_country_codes", rules_db)
 
-          # Blocked CIDR Ranges
-          if ip_in_cidr_range(ip, 'blocked_cidr_ranges', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bc', ip, request_id, request_timestamp)
-          end
+        # Blocked Reputation IP Ranges
+        return queue_upsync_request(request, "Blocked", "bs", "R") if ip_in_cidr_range(ip, "reputation_ip_ranges", data_subscriptions_db)
 
-          # Blocked Country Codes
-          country_code = get_country_code(ip, data_subscriptions_db)      
-          if exact_match(country_code, 'blocked_country_codes', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bs', "G_#{country_code}", request_id, request_timestamp)
-          end 
+        user_agent_match = substring_match(request.user_agent, "blocked_user_agents", rules_db)
+        return queue_upsync_request(request, "Blocked", "bu", user_agent_match) if user_agent_match
 
-          # Blocked Reputation IP Ranges
-          if ip_in_cidr_range(ip, 'reputation_ip_ranges', data_subscriptions_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bs', "R", request_id, request_timestamp)
-          end
+        path_match = substring_match(request.path, "blocked_paths", rules_db)
+        return queue_upsync_request(request, "Blocked", "bp", path_match) if path_match
 
-          # Blocked User Agents
-          user_agent_match = substring_match(user_agent, 'blocked_user_agents', rules_db)
-          if user_agent_match
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bu', user_agent_match, request_id, request_timestamp)
-          end
+        parameters_match = substring_match(request.parameters, "blocked_parameters", rules_db)
+        return queue_upsync_request(request, "Blocked", "ba", parameters_match) if parameters_match
 
-          # Blocked Paths
-          path_match = substring_match(path, 'blocked_paths', rules_db)
-          if path_match
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bp', path_match, request_id, request_timestamp)
-          end
-  
-          # Blocked Parameters
-          parameters_match = substring_match(parameters, 'blocked_parameters', rules_db)
-          if parameters_match
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'ba', parameters_match, request_id, request_timestamp)
-          end
-  
-          # Blocked Hosts
-          if exact_match(host, 'blocked_hosts', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bh', host, request_id, request_timestamp)
-          end
-  
-          # Blocked Methods
-          if exact_match(method, 'blocked_methods', rules_db)
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'bm', method, request_id, request_timestamp)
-          end
-  
-          # Rate Limiting
-          rule_id = check_rate_limit(ip, path, method, rules_db)
-          if rule_id
-            return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Blocked', 'brl', rule_id, request_id, request_timestamp)
-          end
-  
+        return queue_upsync_request(request, "Blocked", "bh", request.host) if exact_match(request.host, "blocked_hosts", rules_db)
+
+        return queue_upsync_request(request, "Blocked", "bm", request.method) if exact_match(request.method, "blocked_methods", rules_db)
+
+        # Rate Limiting
+        rule_id = check_rate_limit(ip, request.path, request.method, rules_db)
+        if rule_id
+          return queue_upsync_request(request, "Blocked", "brl", rule_id)
         end
-  
-        # Passed if no allow or block rules matched
-        return queue_upsync_request(ip, user_agent, path, parameters, host, method, 'Passed', 'passed', '-', request_id, request_timestamp)
+      end
 
-      end # end api_key.nil?
-    end # end evaluate
-  
-    def debug(api_key)
+      # Passed if no allow or block rules matched
+      queue_upsync_request(request, "Passed", "passed", "-")
+    end
 
-      if ENV['WAFRIS_API_KEY']
+    def debug(api_key)
+      if ENV["WAFRIS_API_KEY"]
         puts "Wafris API Key environment variable is set."
-        puts " - API Key: #{ENV['WAFRIS_API_KEY']}"
+        puts " - API Key: #{ENV["WAFRIS_API_KEY"]}"
       else
         puts "Wafris API Key environment variable is not set."
       end
@@ -573,7 +502,7 @@ module Wafris
       if File.exist?(settings.db_file_path + "/" + "custom_rules.modfile")
         puts "Custom Rules Modfile: #{settings.db_file_path}/custom_rules.modfile exists"
         puts " - Last Modified Time: #{File.mtime(settings.db_file_path + "/" + "custom_rules.modfile")}"
-        puts " - Contents: #{File.open(settings.db_file_path + "/" + "custom_rules.modfile", 'r').read}"
+        puts " - Contents: #{File.read(settings.db_file_path + "/" + "custom_rules.modfile")}"
       else
         puts "Custom Rules Modfile: #{settings.db_file_path}/custom_rules.modfile does not exist."
       end
@@ -590,15 +519,12 @@ module Wafris
       if File.exist?(settings.db_file_path + "/" + "data_subscriptions.modfile")
         puts "Data Subscriptions Modfile: #{settings.db_file_path}/data_subscriptions.modfile exists"
         puts " - Last Modified Time: #{File.mtime(settings.db_file_path + "/" + "data_subscriptions.modfile")}"
-        puts " - Contents: #{File.open(settings.db_file_path + "/" + "data_subscriptions.modfile", 'r').read}"
+        puts " - Contents: #{File.read(settings.db_file_path + "/" + "data_subscriptions.modfile")}"
       else
         puts "Data Subscriptions Modfile: #{settings.db_file_path}/data_subscriptions.modfile does not exist."
       end
 
-
-
-      return true
+      true
     end
-  
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wafris
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Michael Buckbee
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -26,7 +26,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: awesome_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ipaddr
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -54,7 +54,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: ipaddr
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -68,7 +68,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,6 +95,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.5
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement