netsnmp 0.1.3 → 0.1.4

data/lib/netsnmp/encryption/aes.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module NETSNMP
   module Encryption
     class AES
@@ -7,7 +8,7 @@ module NETSNMP
         @local = local
       end
 
-      def encrypt(decrypted_data, engine_boots: , engine_time: )
+      def encrypt(decrypted_data, engine_boots:, engine_time:)
         cipher = OpenSSL::Cipher::AES128.new(:CFB)
 
         iv, salt = generate_encryption_key(engine_boots, engine_time)
@@ -24,12 +25,11 @@ module NETSNMP
         NETSNMP.debug { "encrypted:\n#{Hexdump.dump(encrypted_data)}" }
 
         [encrypted_data, salt]
-
       end
 
-      def decrypt(encrypted_data, salt: , engine_boots: , engine_time: )
-        raise Error, "invalid priv salt received" unless salt.length % 8 == 0
-        raise Error, "invalid encrypted PDU received" unless encrypted_data.length % 8 == 0
+      def decrypt(encrypted_data, salt:, engine_boots:, engine_time:)
+        raise Error, "invalid priv salt received" unless (salt.length % 8).zero?
+        raise Error, "invalid encrypted PDU received" unless (encrypted_data.length % 8).zero?
 
         cipher = OpenSSL::Cipher::AES128.new(:CFB)
         cipher.padding = 0
@@ -40,13 +40,14 @@ module NETSNMP
         cipher.key = des_key
         cipher.iv = iv
         decrypted_data = cipher.update(encrypted_data) + cipher.final
-        NETSNMP.debug {"decrypted:\n#{Hexdump.dump(decrypted_data)}" }
+        NETSNMP.debug { "decrypted:\n#{Hexdump.dump(decrypted_data)}" }
 
         hlen, bodylen = OpenSSL::ASN1.traverse(decrypted_data) { |_, _, x, y, *| break x, y }
-        decrypted_data.byteslice(0, hlen+bodylen)
+        decrypted_data.byteslice(0, hlen + bodylen)
       end
 
       private
+
       # 8.1.1.1
       def generate_encryption_key(boots, time)
         salt = [0xff & (@local >> 56),
@@ -62,23 +63,22 @@ module NETSNMP
         iv = generate_decryption_key(boots, time, salt)
 
         [iv, salt]
-       end
-
-       def generate_decryption_key(boots, time, salt)
-         [0xff & (boots >> 24),
-          0xff & (boots >> 16),
-          0xff & (boots >> 8),
-          0xff &  boots,
-          0xff & (time >> 24),
-          0xff & (time >> 16),
-          0xff & (time >> 8),
-          0xff &  time].pack("c*") + salt
-       end
-
-      def des_key 
-        @priv_key[0,16]
       end
 
+      def generate_decryption_key(boots, time, salt)
+        [0xff & (boots >> 24),
+         0xff & (boots >> 16),
+         0xff & (boots >> 8),
+         0xff &  boots,
+         0xff & (time >> 24),
+         0xff & (time >> 16),
+         0xff & (time >> 8),
+         0xff &  time].pack("c*") + salt
+      end
+
+      def des_key
+        @priv_key[0, 16]
+      end
     end
   end
 end

data/lib/netsnmp/encryption/des.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module NETSNMP
   module Encryption
     using StringExtensions
@@ -9,8 +10,7 @@ module NETSNMP
         @local = local
       end
 
-
-      def encrypt(decrypted_data, engine_boots: , engine_time: nil)
+      def encrypt(decrypted_data, engine_boots:, **)
         cipher = OpenSSL::Cipher::DES.new(:CBC)
 
         iv, salt = generate_encryption_key(engine_boots)
@@ -23,15 +23,14 @@ module NETSNMP
           decrypted_data << ("\x00" * (8 - diff))
         end
 
-
         encrypted_data = cipher.update(decrypted_data) + cipher.final
-        NETSNMP.debug {"encrypted:\n#{Hexdump.dump(encrypted_data)}" }
+        NETSNMP.debug { "encrypted:\n#{Hexdump.dump(encrypted_data)}" }
         [encrypted_data, salt]
       end
 
-      def decrypt(encrypted_data, salt: , engine_boots: nil, engine_time: nil)
-        raise Error, "invalid priv salt received" unless salt.length % 8 == 0
-        raise Error, "invalid encrypted PDU received" unless encrypted_data.length % 8 == 0
+      def decrypt(encrypted_data, salt:, **)
+        raise Error, "invalid priv salt received" unless (salt.length % 8).zero?
+        raise Error, "invalid encrypted PDU received" unless (encrypted_data.length % 8).zero?
 
         cipher = OpenSSL::Cipher::DES.new(:CBC)
         cipher.padding = 0
@@ -42,17 +41,17 @@ module NETSNMP
         cipher.key = des_key
         cipher.iv = iv
         decrypted_data = cipher.update(encrypted_data) + cipher.final
-        NETSNMP.debug {"decrypted:\n#{Hexdump.dump(decrypted_data)}" }
+        NETSNMP.debug { "decrypted:\n#{Hexdump.dump(decrypted_data)}" }
 
         hlen, bodylen = OpenSSL::ASN1.traverse(decrypted_data) { |_, _, x, y, *| break x, y }
-        decrypted_data.byteslice(0, hlen+bodylen)
+        decrypted_data.byteslice(0, hlen + bodylen)
       end
 
-
       private
+
       # 8.1.1.1
       def generate_encryption_key(boots)
-        pre_iv = @priv_key[8,8]
+        pre_iv = @priv_key[8, 8]
         salt = [0xff & (boots >> 24),
                 0xff & (boots >> 16),
                 0xff & (boots >> 8),
@@ -61,19 +60,19 @@ module NETSNMP
                 0xff & (@local >> 16),
                 0xff & (@local >> 8),
                 0xff &  @local].pack("c*")
-         @local = @local == 0xffffffff ? 0 : @local + 1
+        @local = @local == 0xffffffff ? 0 : @local + 1
 
-         iv = pre_iv.xor(salt)
-         [iv, salt]
-       end
+        iv = pre_iv.xor(salt)
+        [iv, salt]
+      end
 
-       def generate_decryption_key(salt)
-         pre_iv = @priv_key[8,8]
-         pre_iv.xor(salt)
-       end
+      def generate_decryption_key(salt)
+        pre_iv = @priv_key[8, 8]
+        pre_iv.xor(salt)
+      end
 
-      def des_key 
-        @priv_key[0,8]
+      def des_key
+        @priv_key[0, 8]
       end
     end
   end

data/lib/netsnmp/encryption/none.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
+
 module NETSNMP
   module Encryption
     class None
-
-      def initialize(*)
-      end
+      def initialize(*); end
 
       def encrypt(pdu)
         pdu.send(:to_asn)
       end
+
       def decrypt(stream, *)
         stream
       end

data/lib/netsnmp/errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module NETSNMP
   Error = Class.new(StandardError)
   ConnectionFailed = Class.new(Error)

data/lib/netsnmp/message.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
+
 module NETSNMP
   # Factory for the SNMP v3 Message format
   module Message
-    extend self
+    module_function
+
     AUTHNONE               = OpenSSL::ASN1::OctetString.new("\x00" * 12)
     PRIVNONE               = OpenSSL::ASN1::OctetString.new("")
     MSG_MAX_SIZE       = OpenSSL::ASN1::Integer.new(65507)
-    MSG_SECURITY_MODEL = OpenSSL::ASN1::Integer.new(3)           # usmSecurityModel
+    MSG_SECURITY_MODEL = OpenSSL::ASN1::Integer.new(3) # usmSecurityModel
     MSG_VERSION        = OpenSSL::ASN1::Integer.new(3)
     MSG_REPORTABLE     = 4
 
@@ -15,25 +17,25 @@ module NETSNMP
     #
     # @return [NETSNMP::ScopedPDU] the decoded PDU
     #
-    def decode(stream, security_parameters: )
+    def decode(stream, security_parameters:)
       asn_tree = OpenSSL::ASN1.decode(stream)
-      version, headers, sec_params, pdu_payload = asn_tree.value
+      _version, _headers, sec_params, pdu_payload = asn_tree.value
 
       sec_params_asn = OpenSSL::ASN1.decode(sec_params.value).value
 
-      engine_id, engine_boots, engine_time, username, auth_param, priv_param = sec_params_asn.map(&:value)
+      engine_id, engine_boots, engine_time, _username, auth_param, priv_param = sec_params_asn.map(&:value)
 
       # validate_authentication
       security_parameters.verify(stream.sub(auth_param, AUTHNONE.value), auth_param)
 
-      engine_boots=engine_boots.to_i
-      engine_time =engine_time.to_i
+      engine_boots = engine_boots.to_i
+      engine_time = engine_time.to_i
 
       encoded_pdu = security_parameters.decode(pdu_payload, salt: priv_param,
                                                             engine_boots: engine_boots,
                                                             engine_time: engine_time)
-     
-      pdu = ScopedPDU.decode(encoded_pdu) 
+
+      pdu = ScopedPDU.decode(encoded_pdu)
       [pdu, engine_id, engine_boots, engine_time]
     end
 
@@ -42,33 +44,33 @@ module NETSNMP
     #
     # @return [String] the byte representation of an SNMP v3 Message
     #
-    def encode(pdu, security_parameters: , engine_boots: 0, engine_time: 0)
-      scoped_pdu, salt_param = security_parameters.encode(pdu, salt: PRIVNONE, 
-                                                               engine_boots: engine_boots, 
+    def encode(pdu, security_parameters:, engine_boots: 0, engine_time: 0)
+      scoped_pdu, salt_param = security_parameters.encode(pdu, salt: PRIVNONE,
+                                                               engine_boots: engine_boots,
                                                                engine_time: engine_time)
 
       sec_params = OpenSSL::ASN1::Sequence.new([
-        OpenSSL::ASN1::OctetString.new(security_parameters.engine_id),
-        OpenSSL::ASN1::Integer.new(engine_boots),
-        OpenSSL::ASN1::Integer.new(engine_time),
-        OpenSSL::ASN1::OctetString.new(security_parameters.username),
-        AUTHNONE,
-        salt_param
-      ])
+                                                 OpenSSL::ASN1::OctetString.new(security_parameters.engine_id),
+                                                 OpenSSL::ASN1::Integer.new(engine_boots),
+                                                 OpenSSL::ASN1::Integer.new(engine_time),
+                                                 OpenSSL::ASN1::OctetString.new(security_parameters.username),
+                                                 AUTHNONE,
+                                                 salt_param
+                                               ])
       message_flags = MSG_REPORTABLE | security_parameters.security_level
       message_id    = OpenSSL::ASN1::Integer.new(SecureRandom.random_number(2147483647))
       headers = OpenSSL::ASN1::Sequence.new([
-        message_id, MSG_MAX_SIZE,
-        OpenSSL::ASN1::OctetString.new( [String(message_flags)].pack("h*") ),
-        MSG_SECURITY_MODEL
-      ])
+                                              message_id, MSG_MAX_SIZE,
+                                              OpenSSL::ASN1::OctetString.new([String(message_flags)].pack("h*")),
+                                              MSG_SECURITY_MODEL
+                                            ])
 
-      encoded = OpenSSL::ASN1::Sequence([ 
-        MSG_VERSION, 
-        headers,
-        OpenSSL::ASN1::OctetString.new(sec_params.to_der),
-        scoped_pdu
-      ]).to_der
+      encoded = OpenSSL::ASN1::Sequence([
+                                          MSG_VERSION,
+                                          headers,
+                                          OpenSSL::ASN1::OctetString.new(sec_params.to_der),
+                                          scoped_pdu
+                                        ]).to_der
       signature = security_parameters.sign(encoded)
       if signature
         auth_salt = OpenSSL::ASN1::OctetString.new(signature)
@@ -76,6 +78,5 @@ module NETSNMP
       end
       encoded
     end
-
   end
 end

data/lib/netsnmp/oid.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
+
 module NETSNMP
   # Abstracts the OID structure
   #
   module OID
     OIDREGEX = /^[\d\.]*$/
 
-    extend self
+    module_function
 
     def build(o)
       case o
       when OID then o
       when Array
-        o.join('.')
+        o.join(".")
       when OIDREGEX
-        o = o[1..-1] if o.start_with?('.')
+        o = o[1..-1] if o.start_with?(".")
         o
       # TODO: MIB to OID
       else raise Error, "can't convert #{o} to OID"
@@ -28,7 +29,7 @@ module NETSNMP
     # @return [true, false] whether the given OID belongs to the sub-tree
     #
     def parent?(parent_oid, child_oid)
-      child_oid.match(%r/\A#{parent_oid}\./)
+      child_oid.match(/\A#{parent_oid}\./)
     end
   end
 end

data/lib/netsnmp/pdu.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
-require 'forwardable'
+
+require "forwardable"
 module NETSNMP
   # Abstracts the PDU base structure into a ruby object. It gives access to its varbinds.
   #
   class PDU
-    MAXREQUESTID=2147483647
+    MAXREQUESTID = 2147483647
     class << self
-
       def decode(der)
         asn_tree = case der
-        when String
-          OpenSSL::ASN1.decode(der)
-        when OpenSSL::ASN1::ASN1Data
-          der
-        else
-          raise "#{der}: unexpected data"
-        end
+                   when String
+                     OpenSSL::ASN1.decode(der)
+                   when OpenSSL::ASN1::ASN1Data
+                     der
+                   else
+                     raise "#{der}: unexpected data"
+                   end
 
         *headers, request = asn_tree.value
 
@@ -25,34 +25,34 @@ module NETSNMP
 
         *request_headers, varbinds = request.value
 
-        request_id, error_status, error_index  = request_headers.map(&:value).map(&:to_i)
+        request_id, error_status, error_index = request_headers.map(&:value).map(&:to_i)
 
         varbs = varbinds.value.map do |varbind|
-          oid_asn, val_asn  = varbind.value
+          oid_asn, val_asn = varbind.value
           oid = oid_asn.value
           { oid: oid, value: val_asn }
         end
 
         new(type: type, headers: [version, community],
-                        error_status: error_status,
-                        error_index: error_index,
-                        request_id: request_id, 
-                        varbinds: varbs)
+            error_status: error_status,
+            error_index: error_index,
+            request_id: request_id,
+            varbinds: varbs)
       end
 
       # factory method that abstracts initialization of the pdu types that the library supports.
-      # 
+      #
       # @param [Symbol] type the type of pdu structure to build
-      # 
+      #
       def build(type, **args)
         typ = case type
-          when :get       then 0
-          when :getnext   then 1
-#          when :getbulk   then 5
-          when :set       then 3
-          when :response  then 2
-          else raise Error, "#{type} is not supported as type"
-        end
+              when :get       then 0
+              when :getnext   then 1
+              #          when :getbulk   then 5
+              when :set       then 3
+              when :response  then 2
+              else raise Error, "#{type} is not supported as type"
+              end
         new(args.merge(type: typ))
       end
     end
@@ -61,11 +61,11 @@ module NETSNMP
 
     attr_reader :version, :community, :request_id
 
-    def initialize(type: , headers: , 
-                           request_id: nil, 
-                           error_status: 0,
-                           error_index: 0,
-                           varbinds: [])
+    def initialize(type:, headers:,
+                   request_id: nil,
+                   error_status: 0,
+                   error_index: 0,
+                   varbinds: [])
       @version, @community = headers
       @version = @version.to_i
       @error_status = error_status
@@ -79,70 +79,67 @@ module NETSNMP
       check_error_status(@error_status)
     end
 
-
     def to_der
       to_asn.to_der
     end
 
     # Adds a request varbind to the pdu
-    # 
+    #
     # @param [OID] oid a valid oid
     # @param [Hash] options additional request varbind options
     # @option options [Object] :value the value for the oid
-    def add_varbind(oid: , **options)
+    def add_varbind(oid:, **options)
       @varbinds << Varbind.new(oid, **options)
     end
-    alias_method :<<, :add_varbind
-
+    alias << add_varbind
 
     def to_asn
-      request_id_asn = OpenSSL::ASN1::Integer.new( @request_id )
-      error_asn = OpenSSL::ASN1::Integer.new( @error_status )
-      error_index_asn = OpenSSL::ASN1::Integer.new( @error_index )
+      request_id_asn = OpenSSL::ASN1::Integer.new(@request_id)
+      error_asn = OpenSSL::ASN1::Integer.new(@error_status)
+      error_index_asn = OpenSSL::ASN1::Integer.new(@error_index)
 
-      varbind_asns = OpenSSL::ASN1::Sequence.new( @varbinds.map(&:to_asn) )
+      varbind_asns = OpenSSL::ASN1::Sequence.new(@varbinds.map(&:to_asn))
 
-      request_asn = OpenSSL::ASN1::ASN1Data.new( [request_id_asn,
-                                                  error_asn, error_index_asn,
-                                                  varbind_asns], @type,
-                                                  :CONTEXT_SPECIFIC )
+      request_asn = OpenSSL::ASN1::ASN1Data.new([request_id_asn,
+                                                 error_asn, error_index_asn,
+                                                 varbind_asns], @type,
+                                                :CONTEXT_SPECIFIC)
 
-      OpenSSL::ASN1::Sequence.new( [ *encode_headers_asn, request_asn ] )
+      OpenSSL::ASN1::Sequence.new([*encode_headers_asn, request_asn])
     end
 
     private
 
     def encode_headers_asn
-      [ OpenSSL::ASN1::Integer.new( @version ),
-        OpenSSL::ASN1::OctetString.new( @community ) ]
+      [OpenSSL::ASN1::Integer.new(@version),
+       OpenSSL::ASN1::OctetString.new(@community)]
     end
 
-
     # http://www.tcpipguide.com/free/t_SNMPVersion2SNMPv2MessageFormats-5.htm#Table_219
     def check_error_status(status)
-      return if status == 0
+      return if status.zero?
       message = case status
-        when 1 then "Response-PDU too big"
-        when 2 then "No such name"
-        when 3 then "Bad value"
-        when 4 then "Read Only"
-        when 5 then "General Error"
-        when 6 then "Access denied"
-        when 7 then "Wrong type"
-        when 8 then "Wrong length"
-        when 9 then "Wrong encoding"
-        when 10 then "Wrong value"
-        when 11 then "No creation"
-        when 12 then "Inconsistent value"
-        when 13 then "Resource unavailable"
-        when 14 then "Commit failed"
-        when 15 then "Undo Failed"
-        when 16 then "Authorization Error"
-        when 17 then "Not Writable"
-        when 18 then "Inconsistent Name"
-        else
-          "Unknown Error: (#{status})"
-      end
+                when 1 then "Response-PDU too big"
+                when 2 then "No such name"
+                when 3 then "Bad value"
+                when 4 then "Read Only"
+                when 5 then "General Error"
+                when 6 then "Access denied"
+                when 7 then "Wrong type"
+                when 8 then "Wrong length"
+                when 9 then "Wrong encoding"
+                when 10 then "Wrong value"
+                when 11 then "No creation"
+                when 12 then "Inconsistent value"
+                when 13 then "Resource unavailable"
+                when 14 then "Commit failed"
+                when 15 then "Undo Failed"
+                when 16 then "Authorization Error"
+                when 17 then "Not Writable"
+                when 18 then "Inconsistent Name"
+                else
+                  "Unknown Error: (#{status})"
+                end
       raise Error, message
     end
   end

data/lib/netsnmp/scoped_pdu.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
+
 module NETSNMP
   class ScopedPDU < PDU
-
-
     attr_reader :engine_id
 
-    def initialize(type: , headers:, **options)
+    def initialize(type:, headers:, **options)
       @engine_id, @context = headers
       super(type: type, headers: [3, nil], **options)
     end
 
     def encode_headers_asn
-      [ OpenSSL::ASN1::OctetString.new(@engine_id || ""),
-        OpenSSL::ASN1::OctetString.new(@context   || "") ] 
-    end 
-
+      [OpenSSL::ASN1::OctetString.new(@engine_id || ""),
+       OpenSSL::ASN1::OctetString.new(@context || "")]
+    end
   end
 end