rubyntlm 0.6.6 → 0.6.7

data/lib/net/ntlm/encode_util.rb

@@ -1,48 +1,49 @@
-module Net
-module NTLM
+# frozen_string_literal: true
 
-  class EncodeUtil
-    if RUBY_VERSION == "1.8.7"
-      require "kconv"
+module Net
+  module NTLM
+    # UTF-16LE string encoding and decoding helpers.
+    class EncodeUtil
+      if RUBY_VERSION == '1.8.7'
+        require 'kconv'
 
-      # Decode a UTF16 string to a ASCII string
-      # @param [String] str The string to convert
-      def self.decode_utf16le(str)
-        Kconv.kconv(swap16(str), Kconv::ASCII, Kconv::UTF16)
-      end
+        # Decode a UTF16 string to a ASCII string
+        # @param [String] str The string to convert
+        def self.decode_utf16le(str)
+          Kconv.kconv(swap16(str), Kconv::ASCII, Kconv::UTF16)
+        end
 
-      # Encodes a ASCII string to a UTF16 string
-      # @param [String] str The string to convert
-      def self.encode_utf16le(str)
-        swap16(Kconv.kconv(str, Kconv::UTF16, Kconv::ASCII))
-      end
+        # Encodes a ASCII string to a UTF16 string
+        # @param [String] str The string to convert
+        def self.encode_utf16le(str)
+          swap16(Kconv.kconv(str, Kconv::UTF16, Kconv::ASCII))
+        end
 
-      # Taggle the strings endianness between big/little and little/big
-      # @param [String] str The string to swap the endianness on
-      def self.swap16(str)
-        str.unpack("v*").pack("n*")
-      end
-    else # Use native 1.9 string encoding functions
+        # Taggle the strings endianness between big/little and little/big
+        # @param [String] str The string to swap the endianness on
+        def self.swap16(str)
+          str.unpack('v*').pack('n*')
+        end
+      else # Use native 1.9 string encoding functions
 
-      # Decode a UTF16 string to a ASCII string
-      # @param [String] str The string to convert
-      def self.decode_utf16le(str)
-        str = str.dup.force_encoding(Encoding::UTF_16LE)
-        str.encode(Encoding::UTF_8, Encoding::UTF_16LE).force_encoding('UTF-8')
-      end
+        # Decode a UTF16 string to a ASCII string
+        # @param [String] str The string to convert
+        def self.decode_utf16le(str)
+          str = str.dup.force_encoding(Encoding::UTF_16LE)
+          str.encode(Encoding::UTF_8, Encoding::UTF_16LE).force_encoding('UTF-8')
+        end
 
-      # Encodes a ASCII string to a UTF16 string
-      # @param [String] str The string to convert
-      # @note This implementation may seem stupid but the problem is that UTF16-LE and UTF-8 are incompatiable
-      #   encodings. This library uses string contatination to build the packet bytes. The end result is that
-      #   you can either marshal the encodings elsewhere of simply know that each time you call encode_utf16le
-      #   the function will convert the string bytes to UTF-16LE and note the encoding as UTF-8 so that byte
-      #   concatination works seamlessly.
-      def self.encode_utf16le(str)
-        str.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('ASCII-8BIT')
+        # Encodes a ASCII string to a UTF16 string
+        # @param [String] str The string to convert
+        # @note This implementation may seem stupid but the problem is that UTF16-LE and UTF-8 are incompatiable
+        #   encodings. This library uses string contatination to build the packet bytes. The end result is that
+        #   you can either marshal the encodings elsewhere of simply know that each time you call encode_utf16le
+        #   the function will convert the string bytes to UTF-16LE and note the encoding as UTF-8 so that byte
+        #   concatination works seamlessly.
+        def self.encode_utf16le(str)
+          str.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('ASCII-8BIT')
+        end
       end
     end
   end
-
-end
 end

data/lib/net/ntlm/exceptions.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
     class NtlmError < StandardError; end
 
+    # Raised when target info AV_PAIR data cannot be parsed.
     class InvalidTargetDataError < NtlmError
       attr_reader :data
 

data/lib/net/ntlm/field.rb

@@ -1,35 +1,33 @@
-module Net
-module NTLM
-
-  # base classes for primitives
-  # @private
-  class Field
-    attr_accessor :active, :value
-
-    def initialize(opts)
-      @value  = opts[:value]
-      @active = opts[:active].nil? ? true : opts[:active]
-      @size   = opts[:size].nil? ? 0 : opts[:size]
-    end
-
-    def size
-      @active ? @size : 0
-    end
+# frozen_string_literal: true
 
-    # Serializer function for field data
-    # Exists in this class to be overridden by child classes
-    def serialize
-      raise NotImplementedError
-    end
-
-    # Parser function for field data
-    # Exists in this class to be overridden by child classes
-    def parse(str, offset=0)
-      raise NotImplementedError
+module Net
+  module NTLM
+    # base classes for primitives
+    # @private
+    class Field
+      attr_accessor :active, :value
+
+      def initialize(opts)
+        @value  = opts[:value]
+        @active = opts[:active].nil? || opts[:active]
+        @size   = opts[:size].nil? ? 0 : opts[:size]
+      end
+
+      def size
+        @active ? @size : 0
+      end
+
+      # Serializer function for field data
+      # Exists in this class to be overridden by child classes
+      def serialize
+        raise NotImplementedError
+      end
+
+      # Parser function for field data
+      # Exists in this class to be overridden by child classes
+      def parse(str, offset = 0)
+        raise NotImplementedError
+      end
     end
-
   end
-
-
 end
-end

data/lib/net/ntlm/field_set.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
-
     # base class of data structure
     class FieldSet
       class << FieldSet
-
         # @macro string_security_buffer
         #   @method $1
         #   @method $1=
@@ -17,26 +17,41 @@ module Net
         #   @method $1
         #   @method $1=
         #   @return [Int16LE]
-        def int16LE(name, opts)
+        def int16_le(name, opts)
           add_field(name, Net::NTLM::Int16LE, opts)
         end
 
+        # Legacy camelCase alias for {.int16_le}; kept for backward compatibility.
+        # rubocop:disable Naming/MethodName
+        alias int16LE int16_le
+        # rubocop:enable Naming/MethodName
+
         # @macro int32le_security_buffer
         #   @method $1
         #   @method $1=
         #   @return [Int32LE]
-        def int32LE(name, opts)
+        def int32_le(name, opts)
           add_field(name, Net::NTLM::Int32LE, opts)
         end
 
+        # Legacy camelCase alias for {.int32_le}; kept for backward compatibility.
+        # rubocop:disable Naming/MethodName
+        alias int32LE int32_le
+        # rubocop:enable Naming/MethodName
+
         # @macro int64le_security_buffer
         #   @method $1
         #   @method $1=
         #   @return [Int64]
-        def int64LE(name, opts)
+        def int64_le(name, opts)
           add_field(name, Net::NTLM::Int64LE, opts)
         end
 
+        # Legacy camelCase alias for {.int64_le}; kept for backward compatibility.
+        # rubocop:disable Naming/MethodName
+        alias int64LE int64_le
+        # rubocop:enable Naming/MethodName
+
         # @macro security_buffer
         #   @method $1
         #   @method $1=
@@ -51,17 +66,20 @@ module Net
 
         def names
           return [] if @proto.nil?
-          @proto.map{|n, t, o| n}
+
+          @proto.map { |n, _t, _o| n }
         end
 
         def types
           return [] if @proto.nil?
-          @proto.map{|n, t, o| t}
+
+          @proto.map { |_n, t, _o| t }
         end
 
         def opts
           return [] if @proto.nil?
-          @proto.map{|n, t, o| o}
+
+          @proto.map { |_n, _t, o| o }
         end
 
         private
@@ -72,7 +90,7 @@ module Net
         end
 
         def define_accessor(name)
-          module_eval(<<-End, __FILE__, __LINE__ + 1)
+          module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def #{name}
             self['#{name}'].value
           end
@@ -80,35 +98,37 @@ module Net
           def #{name}=(val)
             self['#{name}'].value = val
           end
-          End
+          RUBY
         end
       end
 
       def initialize
-        @alist = self.class.prototypes.map{ |n, t, o| [n, t.new(o)] }
+        @alist = self.class.prototypes.map { |n, t, o| [n, t.new(o)] }
       end
 
-      def parse(str, offset=0)
-        @alist.inject(offset){|cur, a| cur += a[1].parse(str, cur)}
+      def parse(str, offset = 0)
+        @alist.inject(offset) { |cur, a| cur + a[1].parse(str, cur) }
       end
 
       def serialize
-        @alist.map{|n, f| f.serialize }.join
+        @alist.map { |_n, f| f.serialize }.join
       end
 
       def size
-        @alist.inject(0){|sum, a| sum += a[1].size}
+        @alist.inject(0) { |sum, a| sum + a[1].size }
       end
 
       def [](name)
         a = @alist.assoc(name.to_s.intern)
         raise ArgumentError, "no such field: #{name}" unless a
+
         a[1]
       end
 
       def []=(name, val)
         a = @alist.assoc(name.to_s.intern)
         raise ArgumentError, "no such field: #{name}" unless a
+
         a[1] = val
       end
 
@@ -120,10 +140,11 @@ module Net
         self[name].active = false
       end
 
-      def has_disabled_fields?
-        @alist.any? { |name, field| !field.active }
+      def disabled_fields?
+        @alist.any? { |_name, field| !field.active }
       end
-    end
 
+      alias has_disabled_fields? disabled_fields?
+    end
   end
 end

data/lib/net/ntlm/int16_le.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
-
+    # 16-bit little-endian integer field.
     class Int16LE < Field
-
       def initialize(opt)
         super(opt)
         @size = 2
       end
 
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          @value = str[offset, @size].unpack("v")[0]
+      def parse(str, offset = 0)
+        if @active && str.size >= offset + @size
+          @value = str[offset, @size].unpack1('v')
           @size
         else
           0
@@ -18,9 +19,8 @@ module Net
       end
 
       def serialize
-        [@value].pack("v")
+        [@value].pack('v')
       end
     end
-
   end
-end
+end

data/lib/net/ntlm/int32_le.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
-
+    # 32-bit little-endian integer field.
     class Int32LE < Field
       def initialize(opt)
         super(opt)
         @size = 4
       end
 
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          @value = str.slice(offset, @size).unpack("V")[0]
+      def parse(str, offset = 0)
+        if @active && str.size >= offset + @size
+          @value = str.slice(offset, @size).unpack1('V')
           @size
         else
           0
@@ -17,9 +19,8 @@ module Net
       end
 
       def serialize
-        [@value].pack("V") if @active
+        [@value].pack('V') if @active
       end
     end
-
   end
-end
+end

data/lib/net/ntlm/int64_le.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
-
+    # 64-bit little-endian integer field.
     class Int64LE < Field
       def initialize(opt)
         super(opt)
         @size = 8
       end
 
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          d, u = str.slice(offset, @size).unpack("V2")
+      def parse(str, offset = 0)
+        if @active && str.size >= offset + @size
+          d, u = str.slice(offset, @size).unpack('V2')
           @value = (u * 0x100000000 + d)
           @size
         else
@@ -18,9 +20,8 @@ module Net
       end
 
       def serialize
-        [@value & 0x00000000ffffffff, @value >> 32].pack("V2") if @active
+        [@value & 0x00000000ffffffff, @value >> 32].pack('V2') if @active
       end
     end
-
   end
-end
+end

data/lib/net/ntlm/md4.rb

@@ -1,81 +1,119 @@
+# frozen_string_literal: true
+
 require 'openssl'
 
 module Net
-module NTLM
-
-  class Md4
+  # Pure-Ruby MD4 digest, used to compute the NTLM hash.
+  module NTLM
+    # MD4 message digest.
+    class Md4
+      begin
+        OpenSSL::Digest.digest('MD4', '')
+      rescue StandardError
+        # libssl-3.0+ doesn't support legacy MD4 -> use our own implementation
 
-    begin
-      OpenSSL::Digest::MD4.digest("")
-    rescue
-      # libssl-3.0+ doesn't support legacy MD4 -> use our own implementation
+        require 'stringio'
 
-      require 'stringio'
+        MD4_MASK = (1 << 32) - 1
+        MD4_INITIAL_STATE = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476].freeze
 
-      def self.digest(string)
-        # functions
-        mask = (1 << 32) - 1
-        f = proc {|x, y, z| x & y | x.^(mask) & z}
-        g = proc {|x, y, z| x & y | x & z | y & z}
-        h = proc {|x, y, z| x ^ y ^ z}
-        r = proc {|v, s| (v << s).&(mask) | (v.&(mask) >> (32 - s))}
+        def self.digest(string)
+          state = MD4_INITIAL_STATE.dup
+          io = StringIO.new(md4_pad(string))
+          block = +''
 
-        # initial hash
-        a, b, c, d = 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
+          while io.read(64, block)
+            words = block.unpack('V16')
+            md4_process_block(state, words)
+          end
 
-        string = string.b
-        bit_len = string.bytesize << 3
-        string += "\x80".b
-        while (string.size % 64) != 56
-          string += "\0"
+          state.pack('V4')
         end
-        string = string.force_encoding('ascii-8bit') + [bit_len & mask, bit_len >> 32].pack("V2")
 
-        if string.size % 64 != 0
-          fail "failed to pad to correct length"
-        end
+        class << self
+          private
 
-        io = StringIO.new(string)
-        block = ""
-
-        while io.read(64, block)
-          x = block.unpack("V16")
-
-          # Process this block.
-          aa, bb, cc, dd = a, b, c, d
-          [0, 4, 8, 12].each {|i|
-            a = r[a + f[b, c, d] + x[i],  3]; i += 1
-            d = r[d + f[a, b, c] + x[i],  7]; i += 1
-            c = r[c + f[d, a, b] + x[i], 11]; i += 1
-            b = r[b + f[c, d, a] + x[i], 19]
-          }
-          [0, 1, 2, 3].each {|i|
-            a = r[a + g[b, c, d] + x[i] + 0x5a827999,  3]; i += 4
-            d = r[d + g[a, b, c] + x[i] + 0x5a827999,  5]; i += 4
-            c = r[c + g[d, a, b] + x[i] + 0x5a827999,  9]; i += 4
-            b = r[b + g[c, d, a] + x[i] + 0x5a827999, 13]
-          }
-          [0, 2, 1, 3].each {|i|
-            a = r[a + h[b, c, d] + x[i] + 0x6ed9eba1,  3]; i += 8
-            d = r[d + h[a, b, c] + x[i] + 0x6ed9eba1,  9]; i -= 4
-            c = r[c + h[d, a, b] + x[i] + 0x6ed9eba1, 11]; i += 8
-            b = r[b + h[c, d, a] + x[i] + 0x6ed9eba1, 15]
-          }
-          a = (a + aa) & mask
-          b = (b + bb) & mask
-          c = (c + cc) & mask
-          d = (d + dd) & mask
-        end
+          def md4_pad(string)
+            string = string.b
+            bit_len = string.bytesize << 3
+            string += "\x80".b
+            string += "\0" while (string.size % 64) != 56
+            string = string.force_encoding('ascii-8bit') + [bit_len & MD4_MASK, bit_len >> 32].pack('V2')
 
-        [a, b, c, d].pack("V4")
-      end
+            raise 'failed to pad to correct length' if string.size % 64 != 0
+
+            string
+          end
+
+          def md4_process_block(state, words)
+            saved = state.dup
+            md4_round1(state, words)
+            md4_round2(state, words)
+            md4_round3(state, words)
+            state.map!.with_index { |word, index| (word + saved[index]) & MD4_MASK }
+          end
+
+          def md4_round1(state, words)
+            mix = method(:md4_f)
+            4.times do |round|
+              base = round * 4
+              md4_step(state, 0, words[base], 3, mix)
+              md4_step(state, 3, words[base + 1], 7, mix)
+              md4_step(state, 2, words[base + 2], 11, mix)
+              md4_step(state, 1, words[base + 3], 19, mix)
+            end
+            state
+          end
+
+          def md4_round2(state, words)
+            mix = ->(first, second, third) { md4_g(first, second, third) + 0x5a827999 }
+            4.times do |round|
+              md4_step(state, 0, words[round], 3, mix)
+              md4_step(state, 3, words[round + 4], 5, mix)
+              md4_step(state, 2, words[round + 8], 9, mix)
+              md4_step(state, 1, words[round + 12], 13, mix)
+            end
+            state
+          end
 
-    else
-      # Openssl/libssl provides MD4, so we can use it.
-      def self.digest(string)
-        OpenSSL::Digest::MD4.digest(string)
+          def md4_round3(state, words)
+            mix = ->(first, second, third) { md4_h(first, second, third) + 0x6ed9eba1 }
+            [0, 2, 1, 3].each do |round|
+              md4_step(state, 0, words[round], 3, mix)
+              md4_step(state, 3, words[round + 8], 9, mix)
+              md4_step(state, 2, words[round + 4], 11, mix)
+              md4_step(state, 1, words[round + 12], 15, mix)
+            end
+            state
+          end
+
+          def md4_step(state, target, word, shift, mix)
+            others = [state[(target + 1) % 4], state[(target + 2) % 4], state[(target + 3) % 4]]
+            state[target] = md4_rotate(state[target] + mix.call(*others) + word, shift)
+          end
+
+          def md4_f(first, second, third)
+            (first & second) | ((first ^ MD4_MASK) & third)
+          end
+
+          def md4_g(first, second, third)
+            (first & second) | (first & third) | (second & third)
+          end
+
+          def md4_h(first, second, third)
+            first ^ second ^ third
+          end
+
+          def md4_rotate(value, shift)
+            ((value << shift) & MD4_MASK) | ((value & MD4_MASK) >> (32 - shift))
+          end
+        end
+      else
+        # Openssl/libssl provides MD4, so we can use it.
+        def self.digest(string)
+          OpenSSL::Digest::MD4.digest(string)
+        end
       end
     end
   end
 end
-end

data/lib/net/ntlm/message/type0.rb

@@ -1,16 +1,13 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
     class Message
-
       # sub class definitions
       class Type0 < Message
-        string        :sign,      {:size => 8, :value => SSP_SIGN}
-        int32LE       :type,      {:value => 0}
+        string :sign, { size: 8, value: SSP_SIGN }
+        int32_le :type, { value: 0 }
       end
-
-
     end
   end
 end
-
-

data/lib/net/ntlm/message/type1.rb

@@ -1,17 +1,16 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
     class Message
-
       # @private false
       class Type1 < Message
-
-        string          :sign,         {:size => 8, :value => SSP_SIGN}
-        int32LE         :type,         {:value => 1}
-        int32LE         :flag,         {:value => DEFAULT_FLAGS[:TYPE1] }
-        security_buffer :domain,       {:value => ""}
-        security_buffer :workstation,  {:value => Socket.gethostname }
-        string          :os_version,   {:size => 8, :value => "", :active => false }
-
+        string :sign, { size: 8, value: SSP_SIGN }
+        int32_le :type, { value: 1 }
+        int32_le :flag, { value: DEFAULT_FLAGS[:TYPE1] }
+        security_buffer :domain,       { value: '' }
+        security_buffer :workstation,  { value: Socket.gethostname }
+        string          :os_version,   { size: 8, value: '', active: false }
       end
     end
   end