mihari 5.2.2 → 5.2.4

data/lib/mihari/structs/config.rb

@@ -36,32 +36,57 @@ module Mihari
         attributes[:values]
       end
 
-      #
-      # @param [Class<Mihari::Analyzers::Base>, Class<Mihari::Emitters::Base>] klass
-      #
-      # @return [Mihari::Structs::Config, nil] config
-      #
-      def self.from_class(klass)
-        return nil if klass == Mihari::Analyzers::Rule
+      class << self
+        #
+        # Get a type of a class
+        #
+        # @param [Class<Mihari::Analyzers::Base>, Class<Mihari::Emitters::Base>, Class<Mihari::Enrichers::Base>] klass
+        #
+        # @return [String, nil]
+        #
+        def get_type(klass)
+          return "Analyzer" if klass.ancestors.include?(Mihari::Analyzers::Base)
+          return "Emitter" if klass.ancestors.include?(Mihari::Emitters::Base)
+          return "Enricher" if klass.ancestors.include?(Mihari::Enrichers::Base)
 
-        name = klass.to_s.split("::").last.to_s
+          nil
+        end
 
-        is_analyzer = klass.ancestors.include?(Mihari::Analyzers::Base)
-        is_emitter = klass.ancestors.include?(Mihari::Emitters::Base)
-        is_enricher = klass.ancestors.include?(Mihari::Enrichers::Base)
+        #
+        # Get a dummy instance
+        #
+        # @param [Class<Mihari::Analyzers::Base>, Class<Mihari::Emitters::Base>, Class<Mihari::Enrichers::Base>] klass
+        #
+        # @return [Mihari::Analyzers::Base, Mihari::Emitter::Base, Mihari::Enricher::Base] dummy
+        #
+        def get_dummy(klass)
+          type = get_type(klass)
+          is_analyzer = type == "Analyzer"
+          is_analyzer ? klass.new("dummy") : klass.new(artifacts: [], rule: nil)
+        end
 
-        type = "Analyzer"
-        type = "Emitter" if is_emitter
-        type = "Enricher" if is_enricher
+        #
+        # @param [Class<Mihari::Analyzers::Base>, Class<Mihari::Emitters::Base>, Class<Mihari::Enrichers::Base>] klass
+        #
+        # @return [Mihari::Structs::Config, nil] config
+        #
+        def from_class(klass)
+          return nil if klass == Mihari::Analyzers::Rule
 
-        begin
-          instance = is_analyzer ? klass.new("dummy") : klass.new
-          is_configured = instance.configured?
-          values = instance.configuration_values
+          type = get_type(klass)
+          return nil if type.nil?
 
-          new(name: name, values: values, is_configured: is_configured, type: type)
-        rescue ArgumentError => _e
-          nil
+          begin
+            instance = get_dummy(klass)
+            new(
+              name: klass.to_s.split("::").last.to_s,
+              values: instance.configuration_values,
+              is_configured: instance.configured?,
+              type: type
+            )
+          rescue ArgumentError
+            nil
+          end
         end
       end
     end

data/lib/mihari/structs/google_public_dns.rb

@@ -37,19 +37,21 @@ module Mihari
           attributes[:resource_type]
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Answer]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          resource_type = INT_TYPE_TO_TYPE[d.fetch("type")]
-          new(
-            name: d.fetch("name"),
-            data: d.fetch("data"),
-            resource_type: resource_type
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Answer]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            resource_type = INT_TYPE_TO_TYPE[d.fetch("type")]
+            new(
+              name: d.fetch("name"),
+              data: d.fetch("data"),
+              resource_type: resource_type
+            )
+          end
         end
       end
 
@@ -63,16 +65,18 @@ module Mihari
           attributes[:answers]
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Response]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            answers: d.fetch("Answer", []).map { |x| Answer.from_dynamic!(x) }
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Response]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              answers: d.fetch("Answer", []).map { |x| Answer.from_dynamic!(x) }
+            )
+          end
         end
       end
     end

data/lib/mihari/structs/greynoise.rb

@@ -48,18 +48,20 @@ module Mihari
           )
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Metadata]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            country: d.fetch("country"),
-            country_code: d.fetch("country_code"),
-            asn: d.fetch("asn")
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Metadata]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              country: d.fetch("country"),
+              country_code: d.fetch("country_code"),
+              asn: d.fetch("asn")
+            )
+          end
         end
       end
 
@@ -101,18 +103,20 @@ module Mihari
           )
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Datum]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            ip: d.fetch("ip"),
-            metadata: Metadata.from_dynamic!(d.fetch("metadata")),
-            metadata_: d
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Datum]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              ip: d.fetch("ip"),
+              metadata: Metadata.from_dynamic!(d.fetch("metadata")),
+              metadata_: d
+            )
+          end
         end
       end
 
@@ -165,20 +169,22 @@ module Mihari
           data.map { |datum| datum.to_artifact }
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Response]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            complete: d.fetch("complete"),
-            count: d.fetch("count"),
-            data: d.fetch("data").map { |x| Datum.from_dynamic!(x) },
-            message: d.fetch("message"),
-            query: d.fetch("query")
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Response]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              complete: d.fetch("complete"),
+              count: d.fetch("count"),
+              data: d.fetch("data").map { |x| Datum.from_dynamic!(x) },
+              message: d.fetch("message"),
+              query: d.fetch("query")
+            )
+          end
         end
       end
     end

data/lib/mihari/structs/onyphe.rb

@@ -70,20 +70,22 @@ module Mihari
           Mihari::AutonomousSystem.new(asn: normalize_asn(asn))
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Result]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            asn: d.fetch("asn"),
-            ip: d.fetch("ip"),
-            # Onyphe's country = 2-letter country code
-            country_code: d["country"],
-            metadata: d
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Result]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              asn: d.fetch("asn"),
+              ip: d.fetch("ip"),
+              # Onyphe's country = 2-letter country code
+              country_code: d["country"],
+              metadata: d
+            )
+          end
         end
       end
 
@@ -152,22 +154,24 @@ module Mihari
           results.map(&:to_artifact)
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Response]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            count: d.fetch("count"),
-            error: d.fetch("error"),
-            max_page: d.fetch("max_page"),
-            page: d.fetch("page").to_i,
-            results: d.fetch("results").map { |x| Result.from_dynamic!(x) },
-            status: d.fetch("status"),
-            total: d.fetch("total")
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Response]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              count: d.fetch("count"),
+              error: d.fetch("error"),
+              max_page: d.fetch("max_page"),
+              page: d.fetch("page").to_i,
+              results: d.fetch("results").map { |x| Result.from_dynamic!(x) },
+              status: d.fetch("status"),
+              total: d.fetch("total")
+            )
+          end
         end
       end
     end

data/lib/mihari/structs/rule.rb

@@ -162,7 +162,7 @@ module Mihari
       # @return [Mihari::Analyzers::Rule]
       #
       def analyzer
-        Mihari::Analyzers::Rule.new(rule: self)
+        Mihari::Analyzers::Rule.new(self)
       end
 
       class << self

data/lib/mihari/structs/shodan.rb

@@ -33,17 +33,19 @@ module Mihari
           )
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Location]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            country_code: d["country_code"],
-            country_name: d["country_name"]
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Location]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              country_code: d["country_code"],
+              country_name: d["country_name"]
+            )
+          end
         end
       end
 
@@ -109,30 +111,32 @@ module Mihari
           Mihari::AutonomousSystem.new(asn: normalize_asn(asn))
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Match]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-
-          # hostnames should be an array of string but sometimes Shodan returns a string
-          # e.g. "hostnames": "set(['149.28.146.131.vultr.com', 'rebs.ga'])",
-          # https://github.com/ninoseki/mihari/issues/424
-          # so use an empty array if hostnames is a string
-          hostnames = d.fetch("hostnames")
-          hostnames = [] if hostnames.is_a?(String)
-
-          new(
-            asn: d["asn"],
-            hostnames: hostnames,
-            location: Location.from_dynamic!(d.fetch("location")),
-            domains: d.fetch("domains"),
-            ip_str: d.fetch("ip_str"),
-            port: d.fetch("port"),
-            metadata: d
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Match]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+
+            # hostnames should be an array of string but sometimes Shodan returns a string
+            # e.g. "hostnames": "set(['149.28.146.131.vultr.com', 'rebs.ga'])",
+            # https://github.com/ninoseki/mihari/issues/424
+            # so use an empty array if hostnames is a string
+            hostnames = d.fetch("hostnames")
+            hostnames = [] if hostnames.is_a?(String)
+
+            new(
+              asn: d["asn"],
+              hostnames: hostnames,
+              location: Location.from_dynamic!(d.fetch("location")),
+              domains: d.fetch("domains"),
+              ip_str: d.fetch("ip_str"),
+              port: d.fetch("port"),
+              metadata: d
+            )
+          end
         end
       end
 
@@ -211,17 +215,19 @@ module Mihari
           end
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Result]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            matches: d.fetch("matches", []).map { |x| Match.from_dynamic!(x) },
-            total: d.fetch("total")
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Result]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              matches: d.fetch("matches", []).map { |x| Match.from_dynamic!(x) },
+              total: d.fetch("total")
+            )
+          end
         end
       end
 
@@ -275,30 +281,32 @@ module Mihari
           attributes[:vulns]
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [InternetDBResponse]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            ip: d.fetch("ip"),
-            ports: d.fetch("ports"),
-            cpes: d.fetch("cpes"),
-            hostnames: d.fetch("hostnames"),
-            tags: d.fetch("tags"),
-            vulns: d.fetch("vulns")
-          )
-        end
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [InternetDBResponse]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              ip: d.fetch("ip"),
+              ports: d.fetch("ports"),
+              cpes: d.fetch("cpes"),
+              hostnames: d.fetch("hostnames"),
+              tags: d.fetch("tags"),
+              vulns: d.fetch("vulns")
+            )
+          end
 
-        #
-        # @param [String] json
-        #
-        # @return [InternetDBResponse]
-        #
-        def self.from_json!(json)
-          from_dynamic!(JSON.parse(json))
+          #
+          # @param [String] json
+          #
+          # @return [InternetDBResponse]
+          #
+          def from_json!(json)
+            from_dynamic!(JSON.parse(json))
+          end
         end
       end
     end

data/lib/mihari/structs/urlscan.rb

@@ -29,18 +29,20 @@ module Mihari
           attributes[:url]
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Page]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            domain: d["domain"],
-            ip: d["ip"],
-            url: d.fetch("url")
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Page]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              domain: d["domain"],
+              ip: d["ip"],
+              url: d.fetch("url")
+            )
+          end
         end
       end
 
@@ -88,19 +90,21 @@ module Mihari
           end
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Result]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            page: Page.from_dynamic!(d.fetch("page")),
-            id: d.fetch("_id"),
-            sort: d.fetch("sort"),
-            metadata: d
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Result]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              page: Page.from_dynamic!(d.fetch("page")),
+              id: d.fetch("_id"),
+              sort: d.fetch("sort"),
+              metadata: d
+            )
+          end
         end
       end
 
@@ -129,17 +133,19 @@ module Mihari
           results.map(&:to_artifacts).flatten
         end
 
-        #
-        # @param [Hash] d
-        #
-        # @return [Response]
-        #
-        def self.from_dynamic!(d)
-          d = Types::Hash[d]
-          new(
-            results: d.fetch("results").map { |x| Result.from_dynamic!(x) },
-            has_more: d.fetch("has_more")
-          )
+        class << self
+          #
+          # @param [Hash] d
+          #
+          # @return [Response]
+          #
+          def from_dynamic!(d)
+            d = Types::Hash[d]
+            new(
+              results: d.fetch("results").map { |x| Result.from_dynamic!(x) },
+              has_more: d.fetch("has_more")
+            )
+          end
         end
       end
     end