mihari 5.2.1 → 5.2.2

data/lib/mihari/structs/censys.rb

@@ -8,6 +8,13 @@ module Mihari
 
         attribute :asn, Types::Int
 
+        #
+        # @return [Integer]
+        #
+        def asn
+          attributes[:asn]
+        end
+
         #
         # @return [Mihari::AutonomousSystem]
         #
@@ -15,6 +22,11 @@ module Mihari
           Mihari::AutonomousSystem.new(asn: normalize_asn(asn))
         end
 
+        #
+        # @param [Hash] d
+        #
+        # @return [AutonomousSystem]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -27,6 +39,20 @@ module Mihari
         attribute :country, Types::String.optional
         attribute :country_code, Types::String.optional
 
+        #
+        # @return [String, nil]
+        #
+        def country
+          attributes[:country]
+        end
+
+        #
+        # @return [String, nil]
+        #
+        def country_code
+          attributes[:country_code]
+        end
+
         #
         # @return [Mihari::Geolocation] <description>
         #
@@ -41,6 +67,11 @@ module Mihari
           )
         end
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Location]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -53,6 +84,13 @@ module Mihari
       class Service < Dry::Struct
         attribute :port, Types::Integer
 
+        #
+        # @return [Integer]
+        #
+        def port
+          attributes[:port]
+        end
+
         #
         # @return [Mihari::Port]
         #
@@ -60,6 +98,11 @@ module Mihari
           Port.new(port: port)
         end
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Service]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -75,6 +118,41 @@ module Mihari
         attribute :metadata, Types::Hash
         attribute :services, Types.Array(Service)
 
+        #
+        # @return [String]
+        #
+        def ip
+          attributes[:ip]
+        end
+
+        #
+        # @return [Location]
+        #
+        def location
+          attributes[:location]
+        end
+
+        #
+        # @return [AutonomousSystem]
+        #
+        def autonomous_system
+          attributes[:autonomous_system]
+        end
+
+        #
+        # @return [Hash]
+        #
+        def metadata
+          attributes[:metadata]
+        end
+
+        #
+        # @return [Array<Service>]
+        #
+        def services
+          attributes[:services]
+        end
+
         #
         # @return [Array<Mihari::Port>]
         #
@@ -82,15 +160,12 @@ module Mihari
           services.map(&:to_port)
         end
 
-        #
-        # @param [String] source
         #
         # @return [Mihari::Artifact]
         #
-        def to_artifact(source = "Censys")
+        def to_artifact
           Artifact.new(
             data: ip,
-            source: source,
             metadata: metadata,
             autonomous_system: autonomous_system.to_as,
             geolocation: location.to_geolocation,
@@ -98,6 +173,11 @@ module Mihari
           )
         end
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Hit]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -111,14 +191,33 @@ module Mihari
       end
 
       class Links < Dry::Struct
-        attribute :next, Types::String
-        attribute :prev, Types::String
+        attribute :next, Types::String.optional
+        attribute :prev, Types::String.optional
+
+        #
+        # @return [String, nil]
+        #
+        def next
+          attributes[:next]
+        end
 
+        #
+        # @return [String, nil]
+        #
+        def prev
+          attributes[:prev]
+        end
+
+        #
+        # @param [Hash] d
+        #
+        # @return [Links]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
-            next: d.fetch("next"),
-            prev: d.fetch("prev")
+            next: d["next"],
+            prev: d["prev"]
           )
         end
       end
@@ -130,14 +229,45 @@ module Mihari
         attribute :links, Links
 
         #
-        # @param [String] source
+        # @return [String]
+        #
+        def query
+          attributes[:query]
+        end
+
+        #
+        # @return [Integer]
+        #
+        def total
+          attributes[:total]
+        end
+
+        #
+        # @return [Array<Hit>]
+        #
+        def hits
+          attributes[:hits]
+        end
+
+        #
+        # @return [Links]
+        #
+        def links
+          attributes[:links]
+        end
+
         #
         # @return [Array<Mihari::Artifact>]
         #
-        def to_artifacts(source = "Censys")
-          hits.map { |hit| hit.to_artifact(source) }
+        def to_artifacts
+          hits.map { |hit| hit.to_artifact }
         end
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Result]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -154,6 +284,32 @@ module Mihari
         attribute :status, Types::String
         attribute :result, Result
 
+        #
+        # @return [Integer]
+        #
+        def code
+          attributes[:code]
+        end
+
+        #
+        # @return [String]
+        #
+        def status
+          attributes[:status]
+        end
+
+        #
+        # @return [Result]
+        #
+        def result
+          attributes[:result]
+        end
+
+        #
+        # @param [Hash] d
+        #
+        # @return [Response]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(

data/lib/mihari/structs/config.rb

@@ -8,6 +8,34 @@ module Mihari
       attribute :is_configured, Types::Bool
       attribute :values, Types.Array(Types::Hash).optional
 
+      #
+      # @return [String]
+      #
+      def name
+        attributes[:name]
+      end
+
+      #
+      # @return [String]
+      #
+      def type
+        attributes[:type]
+      end
+
+      #
+      # @return [Boolean]
+      #
+      def is_configured
+        attributes[:is_configured]
+      end
+
+      #
+      # @return [Array<Hash>]
+      #
+      def values
+        attributes[:values]
+      end
+
       #
       # @param [Class<Mihari::Analyzers::Base>, Class<Mihari::Emitters::Base>] klass
       #

data/lib/mihari/structs/google_public_dns.rb

@@ -9,13 +9,39 @@ module Mihari
         5 => "CNAME",
         16 => "TXT",
         28 => "AAAA"
-      }
+      }.freeze
 
       class Answer < Dry::Struct
         attribute :name, Types::String
         attribute :data, Types::String
         attribute :resource_type, Types::String
 
+        #
+        # @return [String]
+        #
+        def name
+          attributes[:name]
+        end
+
+        #
+        # @return [String]
+        #
+        def data
+          attributes[:data]
+        end
+
+        #
+        # @return [String]
+        #
+        def resource_type
+          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")]
@@ -30,6 +56,18 @@ module Mihari
       class Response < Dry::Struct
         attribute :answers, Types.Array(Answer)
 
+        #
+        # @return [Array<Answer>]
+        #
+        def answers
+          attributes[:answers]
+        end
+
+        #
+        # @param [Hash] d
+        #
+        # @return [Response]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(

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,6 +48,11 @@ module Mihari
           )
         end
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Metadata]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -43,20 +69,43 @@ 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
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Datum]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(
@@ -75,14 +124,52 @@ 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
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Response]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(

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,6 +70,11 @@ 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(
@@ -67,14 +97,66 @@ 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
 
+        #
+        # @param [Hash] d
+        #
+        # @return [Response]
+        #
         def self.from_dynamic!(d)
           d = Types::Hash[d]
           new(

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
 
       #