mihari 5.1.4 → 5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52425b89ab9cc2d25fcfd1391661446b938b35596fb5b3a68647f90038a3f848
-  data.tar.gz: 3ae2917e1de1e89e08089e40629eb8652a173cf03dd790137b55c1eb80d35706
+  metadata.gz: 5ce7e22d3d54cc3e66fec62b494ce5f9def9107129513cd51803c71b8ae48b18
+  data.tar.gz: fd85f33a666a77a8b43d12dc3234ab2656cd843c8f7e23025c1a5f076947fbcf
 SHA512:
-  metadata.gz: f06c60e30e815c2634c6309b86b323199393d3c6b02e416244d884c60916584fdbe2250a0366ddf002957b240eadce64c2dc25b740ce80ecce126a78eab29b87
-  data.tar.gz: 2e2e71da88d3ba33b58861b97b3987fb8f64fe581cc7f15cf488227df4621ec03d3c91968e126f787c3b23c65141a81817d4b0785f5aa9065e6fcfa396a99ed5
+  metadata.gz: a17809e3c6f52e7d37f6df2fc92b0ad5a1d134556e6ef13cb64b3802074a44f2ecd0c2475ab632e5da0f57e7c68a44fca15f722f31124fbb9e8af512f46aa2ac
+  data.tar.gz: d777cac77ceeb2a98c8f37a8e001d9240403b47a1e2326a6f1bc42c3cf48e7813dd69ab2260ce5a29a34b7b9b3e0ef54fa541785f8b5dbc82b787381e549525e

data/lib/mihari/commands/web.rb

@@ -11,17 +11,21 @@ module Mihari
           method_option :threads, type: :string, default: "0:5", desc: "min:max threads to use"
           method_option :verbose, type: :boolean, default: true, desc: "Report each request"
           method_option :worker_timeout, type: :numeric, default: 60, desc: "Worker timeout value (in seconds)"
+          method_option :hide_config_values, type: :boolean, default: false,
+            desc: "Whether to hide config values or not"
+          method_option :open, type: :boolean, default: true, desc: "Whether to open the app in browser or not"
           def web
-            port = options["port"]
-            host = options["host"]
-            threads = options["threads"]
-            verbose = options["verbose"]
-            worker_timeout = options["worker_timeout"]
-
+            Mihari.config.hide_config_values = options["hide_config_values"]
             # set rack env as production
             ENV["RACK_ENV"] ||= "production"
-
-            Mihari::App.run!(port: port, host: host, threads: threads, verbose: verbose, worker_timeout: worker_timeout)
+            Mihari::App.run!(
+              port: options["port"],
+              host: options["host"],
+              threads: options["threads"],
+              verbose: options["verbose"],
+              worker_timeout: options["worker_timeout"],
+              open: options["open"]
+            )
           end
         end
       end

data/lib/mihari/entities/artifact.rb

@@ -12,11 +12,12 @@ module Mihari
       expose :data_type, documentation: { type: String, required: true }, as: :dataType
       expose :source, documentation: { type: String, required: true }
       expose :tags, documentation: { type: String, is_array: true }
-
-      expose :metadata, documentation: { type: Hash }
     end
 
     class Artifact < BaseArtifact
+      # NOTE: do not define metadata in BaseArtifact since metadata can be relatively big
+      expose :metadata, documentation: { type: Hash }
+
       expose :autonomous_system, using: Entities::AutonomousSystem,
         documentation: { type: Entities::AutonomousSystem, required: false }, as: :autonomousSystem
       expose :geolocation, using: Entities::Geolocation, documentation: { type: Entities::Geolocation, required: false }

data/lib/mihari/mixins/configurable.rb

@@ -23,7 +23,9 @@ module Mihari
         return nil if configuration_keys.empty?
 
         configuration_keys.map do |key|
-          { key: key.upcase, value: Mihari.config.send(key) }
+          value = Mihari.config.send(key)
+          value = "REDACTED" if value && Mihari.config.hide_config_values
+          { key: key.upcase, value: value }
         end
       end
 

data/lib/mihari/models/alert.rb

@@ -48,22 +48,29 @@ module Mihari
       #
       # @param [Structs::Filters::Alert::SearchFilter] filter
       #
-      # @return [Mihari::Alert]
+      # @return [Array<Integer>]
       #
-      def build_relation(filter)
+      def get_artifact_ids_by_filter(filter)
         artifact_ids = []
-        artifact = Artifact.includes(:autonomous_system, :dns_records, :reverse_dns_names)
-        artifact = artifact.where(data: filter.artifact_data) if filter.artifact_data
-        artifact = artifact.where(autonomous_system: { asn: filter.asn }) if filter.asn
-        artifact = artifact.where(dns_records: { value: filter.dns_record }) if filter.dns_record
-        artifact = artifact.where(reverse_dns_names: { name: filter.reverse_dns_name }) if filter.reverse_dns_name
-        # get artifact ids if there is any valid filter for artifact
-        if filter.valid_artifact_filters?
+
+        if filter.artifact_data
+          artifact = Artifact.where(data: filter.artifact_data)
           artifact_ids = artifact.pluck(:id)
           # set invalid ID if nothing is matched with the filters
           artifact_ids = [-1] if artifact_ids.empty?
         end
 
+        artifact_ids
+      end
+
+      #
+      # @param [Structs::Filters::Alert::SearchFilter] filter
+      #
+      # @return [Mihari::Alert]
+      #
+      def build_relation(filter)
+        artifact_ids = get_artifact_ids_by_filter(filter)
+
         relation = self
         relation = relation.includes(:artifacts, :tags)
 
@@ -71,9 +78,6 @@ module Mihari
         relation = relation.where(tags: { name: filter.tag_name }) if filter.tag_name
 
         relation = relation.where(rule_id: filter.rule_id) if filter.rule_id
-        relation = relation.where(title: filter.title) if filter.title
-
-        relation = relation.where("description LIKE ?", "%#{filter.description}%") if filter.description
 
         relation = relation.where("alerts.created_at >= ?", filter.from_at) if filter.from_at
         relation = relation.where("alerts.created_at <= ?", filter.to_at) if filter.to_at

data/lib/mihari/models/rule.rb

@@ -67,8 +67,7 @@ module Mihari
 
         relation = relation.where(alerts: { tags: { name: filter.tag_name } }) if filter.tag_name
 
-        relation = relation.where(title: filter.title) if filter.title
-
+        relation = relation.where("rules.title LIKE ?", "%#{filter.title}%") if filter.title
         relation = relation.where("rules.description LIKE ?", "%#{filter.description}%") if filter.description
 
         relation = relation.where("rules.created_at >= ?", filter.from_at) if filter.from_at

data/lib/mihari/schemas/rule.rb

@@ -33,6 +33,7 @@ module Mihari
       optional(:falsepositives).value(array[:string]).default([])
 
       optional(:artifact_lifetime).value(:integer)
+      optional(:artifact_ttl).value(:integer)
 
       before(:key_coercer) do |result|
         # it looks like that dry-schema v1.9.1 has an issue with setting an array of schemas as a default value

data/lib/mihari/structs/filters.rb

@@ -6,19 +6,10 @@ module Mihari
       module Alert
         class SearchFilter < Dry::Struct
           attribute? :artifact_data, Types::String.optional
-          attribute? :description, Types::String.optional
           attribute? :rule_id, Types::String.optional
           attribute? :tag_name, Types::String.optional
-          attribute? :title, Types::String.optional
           attribute? :from_at, Types::DateTime.optional
           attribute? :to_at, Types::DateTime.optional
-          attribute? :asn, Types::Int.optional
-          attribute? :dns_record, Types::String.optional
-          attribute? :reverse_dns_name, Types::String.optional
-
-          def valid_artifact_filters?
-            !(artifact_data || asn || dns_record || reverse_dns_name).nil?
-          end
         end
 
         class SearchFilterWithPagination < SearchFilter
@@ -28,15 +19,10 @@ module Mihari
           def without_pagination
             SearchFilter.new(
               artifact_data: artifact_data,
-              description: description,
               from_at: from_at,
               rule_id: rule_id,
               tag_name: tag_name,
-              title: title,
-              to_at: to_at,
-              asn: asn,
-              dns_record: dns_record,
-              reverse_dns_name: reverse_dns_name
+              to_at: to_at
             )
           end
         end

data/lib/mihari/structs/rule.rb

@@ -133,7 +133,7 @@ module Mihari
       # @return [Integer, nil]
       #
       def artifact_lifetime
-        @artifact_lifetime ||= data[:artifact_lifetime]
+        @artifact_lifetime ||= data[:artifact_lifetime] || data[:artifact_ttl]
       end
 
       #

data/lib/mihari/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mihari
-  VERSION = "5.1.4"
+  VERSION = "5.2.1"
 end

data/lib/mihari/web/app.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require "launchy"
+
 require "rack"
-require "rack/contrib"
-require "rack/handler/puma"
+require "rackup"
 require "rack/cors"
 
+require "rack/handler/puma"
+
 require "grape-swagger"
 require "grape-swagger-entity"
 
@@ -18,7 +20,7 @@ module Mihari
   class App
     def initialize
       @filenames = ["", ".html", "index.html", "/index.html"]
-      @rack_static = ::Rack::Static.new(
+      @rack_static = Rack::Static.new(
         -> { [404, {}, []] },
         root: File.expand_path("./public", __dir__),
         urls: ["/"]
@@ -42,7 +44,7 @@ module Mihari
         end.to_app
       end
 
-      def run!(port: 9292, host: "localhost", threads: "0:5", verbose: false, worker_timeout: 60)
+      def run!(port: 9292, host: "localhost", threads: "0:5", verbose: false, worker_timeout: 60, open: true)
         url = "http://#{host}:#{port}"
 
         # set maximum number of threads to use as PARALLEL_PROCESSOR_COUNT (if it is not set)
@@ -50,15 +52,15 @@ module Mihari
         # TODO: is this the best way?
         _min_thread, max_thread = threads.split(":")
         ENV["PARALLEL_PROCESSOR_COUNT"] = max_thread if ENV["PARALLEL_PROCESSOR_COUNT"].nil?
-        Rack::Handler::Puma.run(
+        Rackup::Handler::Puma.run(
           instance,
           Port: port,
           Host: host,
           Threads: threads,
           Verbose: verbose,
           worker_timeout: worker_timeout
-        ) do |_launcher|
-          Launchy.open(url) if ENV["RACK_ENV"] != "development"
+        ) do |_|
+          Launchy.open(url) if ENV["RACK_ENV"] != "development" && open
         rescue Launchy::CommandNotFoundError
           # ref. https://github.com/ninoseki/mihari/issues/477
           # do nothing

data/lib/mihari/web/endpoints/alerts.rb

@@ -11,48 +11,35 @@ module Mihari
           summary: "Search alerts"
         }
         params do
-          optional :page, type: Integer
+          optional :page, type: Integer, default: 1
+          optional :limit, type: Integer, default: 10
 
           optional :artifact, type: String
-          optional :description, type: String
           optional :rule_id, type: String
           optional :tag, type: String
-          optional :title, type: String
 
           optional :fromAt, type: DateTime
           optional :toAt, type: DateTime
-
-          optional :asn, type: Integer
-          optional :dnsRecord, type: String
-          optional :reverseDnsName, type: String
         end
         get "/" do
           filter = params.to_h.to_snake_keys
 
-          # set page & limit
-          page = filter["page"] || 1
-          filter["page"] = page.to_i
-
-          limit = 10
-          filter["limit"] = 10
-
           # normalize keys
           filter["artifact_data"] = filter["artifact"]
           filter["tag_name"] = filter["tag"]
-
           # symbolize hash keys
           filter = filter.to_h.symbolize_keys
 
-          search_filter_with_pagenation = Structs::Filters::Alert::SearchFilterWithPagination.new(**filter)
-          alerts = Mihari::Alert.search(search_filter_with_pagenation)
-          total = Mihari::Alert.count(search_filter_with_pagenation.without_pagination)
+          search_filter_with_pagination = Structs::Filters::Alert::SearchFilterWithPagination.new(**filter)
+          alerts = Mihari::Alert.search(search_filter_with_pagination)
+          total = Mihari::Alert.count(search_filter_with_pagination.without_pagination)
 
           present(
             {
               alerts: alerts,
               total: total,
-              current_page: page,
-              page_size: limit
+              current_page: filter[:page].to_i,
+              page_size: filter[:limit].to_i
             },
             with: Entities::AlertsWithPagination
           )

data/lib/mihari/web/endpoints/rules.rb

@@ -21,7 +21,8 @@ module Mihari
           summary: "Search rules"
         }
         params do
-          optional :page, type: Integer
+          optional :page, type: Integer, default: 1
+          optional :limit, type: Integer, default: 10
 
           optional :title, type: String
           optional :description, type: String
@@ -33,16 +34,8 @@ module Mihari
         get "/" do
           filter = params.to_h.to_snake_keys
 
-          # set page & limit
-          page = filter["page"] || 1
-          filter["page"] = page.to_i
-
-          limit = 10
-          filter["limit"] = 10
-
           # normalize keys
           filter["tag_name"] = filter["tag"]
-
           # symbolize hash keys
           filter = filter.to_h.symbolize_keys
 
@@ -53,8 +46,8 @@ module Mihari
           present(
             { rules: rules,
               total: total,
-              current_page: page,
-              page_size: limit },
+              current_page: filter[:page].to_i,
+              page_size: filter[:limit].to_i },
             with: Entities::RulesWithPagination
           )
         end