rubyntlm 0.3.4 → 0.4.0

data/lib/net/ntlm/blob.rb

@@ -0,0 +1,17 @@
+module Net
+  module NTLM
+
+    BLOB_SIGN = 0x00000101
+
+    class Blob < FieldSet
+      int32LE    :blob_signature,   {:value => BLOB_SIGN}
+      int32LE    :reserved,         {:value => 0}
+      int64LE    :timestamp,      {:value => 0}
+      string     :challenge,      {:value => "", :size => 8}
+      int32LE    :unknown1,     {:value => 0}
+      string     :target_info,      {:value => "", :size => 0}
+      int32LE    :unknown2,         {:value => 0}
+    end
+
+  end
+end

data/lib/net/ntlm/encode_util.rb

@@ -0,0 +1,49 @@
+module Net
+module NTLM
+
+  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
+
+      # 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
+
+         # Decode a UTF16 string to a ASCII string
+         # @param [String] str The string to convert
+      def self.decode_utf16le(str)
+        str.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 = str.force_encoding('UTF-8') if [::Encoding::ASCII_8BIT,::Encoding::US_ASCII].include?(str.encoding)
+        str.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('UTF-8')
+      end
+    end
+  end
+
+end
+end

data/lib/net/ntlm/field.rb

@@ -0,0 +1,35 @@
+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
+
+    # 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

data/lib/net/ntlm/field_set.rb

@@ -0,0 +1,125 @@
+module Net
+  module NTLM
+
+    # base class of data structure
+    class FieldSet
+      class << FieldSet
+
+        # @macro string_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [String]
+        def string(name, opts)
+          add_field(name, Net::NTLM::String, opts)
+        end
+
+        # @macro int16le_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [Int16LE]
+        def int16LE(name, opts)
+          add_field(name, Net::NTLM::Int16LE, opts)
+        end
+
+        # @macro int32le_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [Int32LE]
+        def int32LE(name, opts)
+          add_field(name, Net::NTLM::Int32LE, opts)
+        end
+
+        # @macro int64le_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [Int64]
+        def int64LE(name, opts)
+          add_field(name, Net::NTLM::Int64LE, opts)
+        end
+
+        # @macro security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [SecurityBuffer]
+        def security_buffer(name, opts)
+          add_field(name, Net::NTLM::SecurityBuffer, opts)
+        end
+
+        def prototypes
+          @proto
+        end
+
+        def names
+          return [] if @proto.nil?
+          @proto.map{|n, t, o| n}
+        end
+
+        def types
+          return [] if @proto.nil?
+          @proto.map{|n, t, o| t}
+        end
+
+        def opts
+          return [] if @proto.nil?
+          @proto.map{|n, t, o| o}
+        end
+
+        private
+
+        def add_field(name, type, opts)
+          (@proto ||= []).push [name, type, opts]
+          define_accessor name
+        end
+
+        def define_accessor(name)
+          module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def #{name}
+            self['#{name}'].value
+          end
+
+          def #{name}=(val)
+            self['#{name}'].value = val
+          end
+          End
+        end
+      end
+
+      def initialize
+        @alist = self.class.prototypes.map{ |n, t, o| [n, t.new(o)] }
+      end
+
+      def serialize
+        @alist.map{|n, f| f.serialize }.join
+      end
+
+      def parse(str, offset=0)
+        @alist.inject(offset){|cur, a|  cur += a[1].parse(str, cur)}
+      end
+
+      def 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
+
+      def enable(name)
+        self[name].active = true
+      end
+
+      def disable(name)
+        self[name].active = false
+      end
+    end
+
+  end
+end

data/lib/net/ntlm/int16_le.rb

@@ -0,0 +1,26 @@
+module Net
+  module NTLM
+
+    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]
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        [@value].pack("v")
+      end
+    end
+
+  end
+end

data/lib/net/ntlm/int32_le.rb

@@ -0,0 +1,25 @@
+module Net
+  module NTLM
+
+    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]
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        [@value].pack("V") if @active
+      end
+    end
+
+  end
+end

data/lib/net/ntlm/int64_le.rb

@@ -0,0 +1,26 @@
+module Net
+  module NTLM
+
+    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")
+          @value = (u * 0x100000000 + d)
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        [@value & 0x00000000ffffffff, @value >> 32].pack("V2") if @active
+      end
+    end
+
+  end
+end

data/lib/net/ntlm/message.rb

@@ -0,0 +1,115 @@
+module Net
+module NTLM
+
+  SSP_SIGN = "NTLMSSP\0"
+
+  FLAGS = {
+      :UNICODE              => 0x00000001,
+      :OEM                  => 0x00000002,
+      :REQUEST_TARGET       => 0x00000004,
+      :MBZ9                 => 0x00000008,
+      :SIGN                 => 0x00000010,
+      :SEAL                 => 0x00000020,
+      :NEG_DATAGRAM         => 0x00000040,
+      :NETWARE              => 0x00000100,
+      :NTLM                 => 0x00000200,
+      :NEG_NT_ONLY          => 0x00000400,
+      :MBZ7                 => 0x00000800,
+      :DOMAIN_SUPPLIED      => 0x00001000,
+      :WORKSTATION_SUPPLIED => 0x00002000,
+      :LOCAL_CALL           => 0x00004000,
+      :ALWAYS_SIGN          => 0x00008000,
+      :TARGET_TYPE_DOMAIN   => 0x00010000,
+      :TARGET_INFO          => 0x00800000,
+      :NTLM2_KEY            => 0x00080000,
+      :KEY128               => 0x20000000,
+      :KEY56                => 0x80000000
+  }.freeze
+
+  FLAG_KEYS = FLAGS.keys.sort{|a, b| FLAGS[a] <=> FLAGS[b] }
+
+  DEFAULT_FLAGS = {
+      :TYPE1 => FLAGS[:UNICODE] | FLAGS[:OEM] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY],
+      :TYPE2 => FLAGS[:UNICODE],
+      :TYPE3 => FLAGS[:UNICODE] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY]
+  }
+
+
+  # @private false
+  class Message < FieldSet
+    class << Message
+      def parse(str)
+        m = Type0.new
+        m.parse(str)
+        case m.type
+          when 1
+            t = Type1.parse(str)
+          when 2
+            t = Type2.parse(str)
+          when 3
+            t = Type3.parse(str)
+          else
+            raise ArgumentError, "unknown type: #{m.type}"
+        end
+        t
+      end
+
+      def decode64(str)
+        parse(Base64.decode64(str))
+      end
+    end
+
+    def has_flag?(flag)
+      (self[:flag].value & FLAGS[flag]) == FLAGS[flag]
+    end
+
+    def set_flag(flag)
+      self[:flag].value  |= FLAGS[flag]
+    end
+
+    def dump_flags
+      FLAG_KEYS.each{ |k| print(k, "=", has_flag?(k), "\n") }
+    end
+
+    def serialize
+      deflag
+      super + security_buffers.map{|n, f| f.value}.join
+    end
+
+    def encode64
+      Base64.encode64(serialize).gsub(/\n/, '')
+    end
+
+    def decode64(str)
+      parse(Base64.decode64(str))
+    end
+
+    alias head_size size
+
+    def data_size
+      security_buffers.inject(0){|sum, a| sum += a[1].data_size}
+    end
+
+    def size
+      head_size + data_size
+    end
+
+
+    def security_buffers
+      @alist.find_all{|n, f| f.instance_of?(SecurityBuffer)}
+    end
+
+    def deflag
+      security_buffers.inject(head_size){|cur, a|
+        a[1].offset = cur
+        cur += a[1].data_size
+      }
+    end
+
+    def data_edge
+      security_buffers.map{ |n, f| f.active ? f.offset : size}.min
+    end
+
+  end
+end
+end

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

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

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

@@ -0,0 +1,43 @@
+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          :padding,      {:size => 0, :value => "", :active => false }
+
+        class << Type1
+          # Parses a Type 1 Message
+          # @param [String] str A string containing Type 1 data
+          # @return [Type1] The parsed Type 1 message
+          def parse(str)
+            t = new
+            t.parse(str)
+            t
+          end
+        end
+
+        # @!visibility private
+        def parse(str)
+          super(str)
+          enable(:domain) if has_flag?(:DOMAIN_SUPPLIED)
+          enable(:workstation) if has_flag?(:WORKSTATION_SUPPLIED)
+          super(str)
+          if ( (len = data_edge - head_size) > 0)
+            self.padding = "\0" * len
+            super(str)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+