mihari 5.2.1 → 5.2.3

data/lib/mihari/structs/greynoise.rb

@@ -10,6 +10,27 @@ module Mihari
         attribute :country_code, Types::String
         attribute :asn, Types::String
 
+        #
+        # @return [String]
+        #
+        def country
+          attributes[:country]
+        end
+
+        #
+        # @return [String]
+        #
+        def country_code
+          attributes[:country_code]
+        end
+
+        #
+        # @return [String]
+        #
+        def asn
+          attributes[:asn]
+        end
+
         #
         # @return [Mihari::AutonomousSystem]
         #
@@ -27,13 +48,20 @@ module Mihari
           )
         end
 
-        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
 
@@ -43,27 +71,52 @@ module Mihari
         attribute :metadata_, Types::Hash
 
         #
-        # @param [String] source
+        # @return [String]
+        #
+        def ip
+          attributes[:ip]
+        end
+
+        #
+        # @return [Metadata]
+        #
+        def metadata
+          attributes[:metadata]
+        end
+
+        #
+        # @return [Hash]
+        #
+        def metadata_
+          attributes[:metadata_]
+        end
+
         #
         # @return [Mihari::Artifact]
         #
-        def to_artifact(source = "GreyNoise")
+        def to_artifact
           Mihari::Artifact.new(
             data: ip,
-            source: source,
             metadata: metadata_,
             autonomous_system: metadata.to_as,
             geolocation: metadata.to_geolocation
           )
         end
 
-        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
 
@@ -75,23 +128,63 @@ module Mihari
         attribute :query, Types::String
 
         #
-        # @param [String] source
+        # @return [Boolean]
+        #
+        def complete
+          attributes[:complete]
+        end
+
+        #
+        # @return [Integer]
+        #
+        def count
+          attributes[:count]
+        end
+
+        #
+        # @return [Array<Datum>]
+        #
+        def data
+          attributes[:data]
+        end
+
+        #
+        # @return [String]
+        #
+        def message
+          attributes[:message]
+        end
+
+        #
+        # @return [String]
+        #
+        def query
+          attributes[:query]
+        end
+
         #
         # @return [Array<Mihari::Artifact>]
         #
-        def to_artifacts(source = "GreyNoise")
-          data.map { |datum| datum.to_artifact(source) }
+        def to_artifacts
+          data.map { |datum| datum.to_artifact }
         end
 
-        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/ipinfo.rb

@@ -10,9 +10,49 @@ module Mihari
         attribute :country_code, Types::String.optional
         attribute :asn, Types::Integer.optional
 
+        #
+        # @return [String]
+        #
+        def ip
+          attributes[:ip]
+        end
+
+        #
+        # @return [String, nil]
+        #
+        def hostname
+          attributes[:hostname]
+        end
+
+        #
+        # @return [String, nil]
+        #
+        def loc
+          attributes[:loc]
+        end
+
+        #
+        # @return [String, nil]
+        #
+        def country_code
+          attributes[:country_code]
+        end
+
+        #
+        # @return [Integer, nil]
+        #
+        def asn
+          attributes[:asn]
+        end
+
         class << self
           include Mixins::AutonomousSystem
 
+          #
+          # @param [Hash] d
+          #
+          # @return [Response]
+          #
           def from_dynamic!(d)
             d = d.deep_stringify_keys
             d = Types::Hash[d]

data/lib/mihari/structs/onyphe.rb

@@ -12,14 +12,39 @@ module Mihari
         attribute :metadata, Types::Hash
 
         #
-        # @param [String] source
+        # @return [String]
+        #
+        def asn
+          attributes[:asn]
+        end
+
+        #
+        # @return [String, nil]
+        #
+        def country_code
+          attributes[:country_code]
+        end
+
+        #
+        # @return [String]
+        #
+        def ip
+          attributes[:ip]
+        end
+
+        #
+        # @return [Hash]
+        #
+        def metadata
+          attributes[:metadata]
+        end
+
         #
         # @return [Mihari::Artifact]
         #
-        def to_artifact(source = "Onyphe")
+        def to_artifact
           Mihari::Artifact.new(
             data: ip,
-            source: source,
             metadata: metadata,
             autonomous_system: to_as,
             geolocation: to_geolocation
@@ -45,15 +70,22 @@ module Mihari
           Mihari::AutonomousSystem.new(asn: normalize_asn(asn))
         end
 
-        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
 
@@ -67,25 +99,79 @@ module Mihari
         attribute :total, Types::Int
 
         #
-        # @param [String] source
+        # @return [Integer]
+        #
+        def count
+          attributes[:count]
+        end
+
+        #
+        # @return [Integer]
+        #
+        def error
+          attributes[:error]
+        end
+
+        #
+        # @return [Integer]
+        #
+        def max_page
+          attributes[:max_page]
+        end
+
+        #
+        # @return [Integer]
+        #
+        def page
+          attributes[:page]
+        end
+
+        #
+        # @return [Array<Result>]
+        #
+        def results
+          attributes[:results]
+        end
+
+        #
+        # @return [String]
+        #
+        def status
+          attributes[:status]
+        end
+
+        #
+        # @return [Integer]
+        #
+        def total
+          attributes[:total]
+        end
+
         #
         # @return [Array<Mihari::Artifact>]
         #
-        def to_artifacts(source = "Onyphe")
-          results.map { |result| result.to_artifact(source) }
+        def to_artifacts
+          results.map(&:to_artifact)
         end
 
-        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

@@ -10,6 +10,8 @@ require "yaml"
 module Mihari
   module Structs
     class Rule
+      include Mixins::FalsePositive
+
       # @return [Hash]
       attr_reader :data
 
@@ -109,10 +111,10 @@ module Mihari
       end
 
       #
-      # @return [Array<String>]
+      # @return [Array<String, RegExp>]
       #
       def falsepositives
-        @falsepositives ||= data[:falsepositives]
+        @falsepositives ||= data[:falsepositives].map { |fp| normalize_falsepositive fp }
       end
 
       #