censys 1.0.36

data/lib/censys/models/cvss_components.rb

@@ -0,0 +1,409 @@
+=begin
+#Censys Platform API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 1.0.36
+Contact: support@censys.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.16.0-SNAPSHOT
+
+=end
+
+require 'date'
+require 'time'
+
+module CensysApi
+  class CVSSComponents
+    # Indicates conditions beyond the attacker’s control that must exist in order to exploit the vulnerability. The Attack Complexity metric is scored as either Low or High. There are two possible values: Low (L) – There are no specific pre-conditions required for exploitation, High (H) – The attacker must complete some number of preparatory steps in order to get access.
+    attr_accessor :attack_complexity
+
+    # Indicates the level of access required for an attacker to exploit the vulnerability. The Attack Vector metric is scored in one of four levels: Network (N) – Vulnerabilities with this rating are remotely exploitable, from one or more hops away, up to, and including, remote exploitation over the Internet, Adjacent (A) – A vulnerability with this rating requires network adjacency for exploitation. The attack must be launched from the same physical or logical network, Local (L) – Vulnerabilities with this rating are not exploitable over a network, Physical (P) – An attacker must physically interact with the target system.
+    attr_accessor :attack_vector
+
+    # If an attack renders information unavailable, such as when a system crashes or through a DDoS attack, availability is negatively impacted. Availability has three possible values: None (N) – There is no loss of availability, Low (L) – Availability might be intermittently limited, or performance might be negatively impacted, as a result of a successful attack, High (H) – There is a complete loss of availability of the impacted system or information.
+    attr_accessor :availability
+
+    # Refers to the disclosure of sensitive information to authorized and unauthorized users, with the goal being that only authorized users are able to access the target data. Confidentiality has three potential values: High (H) – The attacker has full access to all resources in the impacted system, including highly sensitive information such as encryption keys, Low (L) – The attacker has partial access to information, with no control over what, specifically, they are able to access, None (N) – No data is accessible to unauthorized users as a result of the exploit.
+    attr_accessor :confidentiality
+
+    # Refers to whether the protected information has been tampered with or changed in any way. If there is no way for an attacker to alter the accuracy or completeness of the information, integrity has been maintained. Integrity has three values: None (N) – There is no loss of the integrity of any information, Low (L) – A limited amount of information might be tampered with or modified, but there is no serious impact on the protected system, High (H) – The attacker can modify any/all information on the target system, resulting in a complete loss of integrity.
+    attr_accessor :integrity
+
+    # Describes the level of privileges or access an attacker must have before successful exploitation. There are three possible values: None (N) – There is no privilege or special access required to conduct the attack, Low (L) – The attacker requires basic, “user” level privileges to leverage the exploit, High (H) – Administrative or similar access privileges are required for successful attack.
+    attr_accessor :privileges_required
+
+    # Determines whether a vulnerability in one system or component can impact another system or component. If a vulnerability in a vulnerable component can affect a component which is in a different security scope than the vulnerable component, a scope change occurs. Scope has two possible ratings: Changed (C) – An exploited vulnerability can have a carry over impact on another system, Unchanged (U) – The exploited vulnerability is limited in damage to only the local security authority.
+    attr_accessor :scope
+
+    # Describes whether a user, other than the attacker, is required to do anything or participate in exploitation of the vulnerability. User interaction has two possible values: None (N) – No user interaction is required, Required (R) – A user must complete some steps for the exploit to succeed. For example, a user might be required to install some software.
+    attr_accessor :user_interaction
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'attack_complexity' => :'attack_complexity',
+        :'attack_vector' => :'attack_vector',
+        :'availability' => :'availability',
+        :'confidentiality' => :'confidentiality',
+        :'integrity' => :'integrity',
+        :'privileges_required' => :'privileges_required',
+        :'scope' => :'scope',
+        :'user_interaction' => :'user_interaction'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'attack_complexity' => :'String',
+        :'attack_vector' => :'String',
+        :'availability' => :'String',
+        :'confidentiality' => :'String',
+        :'integrity' => :'String',
+        :'privileges_required' => :'String',
+        :'scope' => :'String',
+        :'user_interaction' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `CensysApi::CVSSComponents` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `CensysApi::CVSSComponents`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'attack_complexity')
+        self.attack_complexity = attributes[:'attack_complexity']
+      end
+
+      if attributes.key?(:'attack_vector')
+        self.attack_vector = attributes[:'attack_vector']
+      end
+
+      if attributes.key?(:'availability')
+        self.availability = attributes[:'availability']
+      end
+
+      if attributes.key?(:'confidentiality')
+        self.confidentiality = attributes[:'confidentiality']
+      end
+
+      if attributes.key?(:'integrity')
+        self.integrity = attributes[:'integrity']
+      end
+
+      if attributes.key?(:'privileges_required')
+        self.privileges_required = attributes[:'privileges_required']
+      end
+
+      if attributes.key?(:'scope')
+        self.scope = attributes[:'scope']
+      end
+
+      if attributes.key?(:'user_interaction')
+        self.user_interaction = attributes[:'user_interaction']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      attack_complexity_validator = EnumAttributeValidator.new('String', ["", "low", "high"])
+      return false unless attack_complexity_validator.valid?(@attack_complexity)
+      attack_vector_validator = EnumAttributeValidator.new('String', ["", "network", "adjacent", "local", "physical"])
+      return false unless attack_vector_validator.valid?(@attack_vector)
+      availability_validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      return false unless availability_validator.valid?(@availability)
+      confidentiality_validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      return false unless confidentiality_validator.valid?(@confidentiality)
+      integrity_validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      return false unless integrity_validator.valid?(@integrity)
+      privileges_required_validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      return false unless privileges_required_validator.valid?(@privileges_required)
+      scope_validator = EnumAttributeValidator.new('String', ["", "unchanged", "changed"])
+      return false unless scope_validator.valid?(@scope)
+      user_interaction_validator = EnumAttributeValidator.new('String', ["", "none", "required"])
+      return false unless user_interaction_validator.valid?(@user_interaction)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] attack_complexity Object to be assigned
+    def attack_complexity=(attack_complexity)
+      validator = EnumAttributeValidator.new('String', ["", "low", "high"])
+      unless validator.valid?(attack_complexity)
+        fail ArgumentError, "invalid value for \"attack_complexity\", must be one of #{validator.allowable_values}."
+      end
+      @attack_complexity = attack_complexity
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] attack_vector Object to be assigned
+    def attack_vector=(attack_vector)
+      validator = EnumAttributeValidator.new('String', ["", "network", "adjacent", "local", "physical"])
+      unless validator.valid?(attack_vector)
+        fail ArgumentError, "invalid value for \"attack_vector\", must be one of #{validator.allowable_values}."
+      end
+      @attack_vector = attack_vector
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] availability Object to be assigned
+    def availability=(availability)
+      validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      unless validator.valid?(availability)
+        fail ArgumentError, "invalid value for \"availability\", must be one of #{validator.allowable_values}."
+      end
+      @availability = availability
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] confidentiality Object to be assigned
+    def confidentiality=(confidentiality)
+      validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      unless validator.valid?(confidentiality)
+        fail ArgumentError, "invalid value for \"confidentiality\", must be one of #{validator.allowable_values}."
+      end
+      @confidentiality = confidentiality
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] integrity Object to be assigned
+    def integrity=(integrity)
+      validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      unless validator.valid?(integrity)
+        fail ArgumentError, "invalid value for \"integrity\", must be one of #{validator.allowable_values}."
+      end
+      @integrity = integrity
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] privileges_required Object to be assigned
+    def privileges_required=(privileges_required)
+      validator = EnumAttributeValidator.new('String', ["", "none", "low", "high"])
+      unless validator.valid?(privileges_required)
+        fail ArgumentError, "invalid value for \"privileges_required\", must be one of #{validator.allowable_values}."
+      end
+      @privileges_required = privileges_required
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] scope Object to be assigned
+    def scope=(scope)
+      validator = EnumAttributeValidator.new('String', ["", "unchanged", "changed"])
+      unless validator.valid?(scope)
+        fail ArgumentError, "invalid value for \"scope\", must be one of #{validator.allowable_values}."
+      end
+      @scope = scope
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] user_interaction Object to be assigned
+    def user_interaction=(user_interaction)
+      validator = EnumAttributeValidator.new('String', ["", "none", "required"])
+      unless validator.valid?(user_interaction)
+        fail ArgumentError, "invalid value for \"user_interaction\", must be one of #{validator.allowable_values}."
+      end
+      @user_interaction = user_interaction
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          attack_complexity == o.attack_complexity &&
+          attack_vector == o.attack_vector &&
+          availability == o.availability &&
+          confidentiality == o.confidentiality &&
+          integrity == o.integrity &&
+          privileges_required == o.privileges_required &&
+          scope == o.scope &&
+          user_interaction == o.user_interaction
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [attack_complexity, attack_vector, availability, confidentiality, integrity, privileges_required, scope, user_interaction].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = CensysApi.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/censys/models/cvssv4.rb

@@ -0,0 +1,241 @@
+=begin
+#Censys Platform API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 1.0.36
+Contact: support@censys.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.16.0-SNAPSHOT
+
+=end
+
+require 'date'
+require 'time'
+
+module CensysApi
+  class CVSSv4
+    # These metrics contribute to how a CVE is scored.
+    attr_accessor :components
+
+    # Score of the vulnerability; 0.1 is the lowest, 10 is the maximum
+    attr_accessor :score
+
+    # The path, method, or scenario used to exploit the vulnerability. Each section represents components that contribute to the overall CVSS score.
+    attr_accessor :vector
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'components' => :'components',
+        :'score' => :'score',
+        :'vector' => :'vector'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'components' => :'CVSSv4Components',
+        :'score' => :'Float',
+        :'vector' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `CensysApi::CVSSv4` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `CensysApi::CVSSv4`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'components')
+        self.components = attributes[:'components']
+      end
+
+      if attributes.key?(:'score')
+        self.score = attributes[:'score']
+      end
+
+      if attributes.key?(:'vector')
+        self.vector = attributes[:'vector']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          components == o.components &&
+          score == o.score &&
+          vector == o.vector
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [components, score, vector].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = CensysApi.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end