rubyntlm 0.6.1 → 0.6.2

data/lib/net/ntlm/encode_util.rb

@@ -1,48 +1,48 @@
-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 = 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('UTF-8')
-      end
-    end
-  end
-
-end
-end
+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 = 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('UTF-8')
+      end
+    end
+  end
+
+end
+end

data/lib/net/ntlm/exceptions.rb

@@ -1,14 +1,14 @@
-module Net
-  module NTLM
-    class NtlmError < StandardError; end
-
-    class InvalidTargetDataError < NtlmError
-      attr_reader :data
-
-      def initialize(msg, data)
-        @data = data
-        super(msg)
-      end
-    end
-  end
-end
+module Net
+  module NTLM
+    class NtlmError < StandardError; end
+
+    class InvalidTargetDataError < NtlmError
+      attr_reader :data
+
+      def initialize(msg, data)
+        @data = data
+        super(msg)
+      end
+    end
+  end
+end

data/lib/net/ntlm/field.rb

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

@@ -1,129 +1,129 @@
-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 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
-      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
-
-      def has_disabled_fields?
-        @alist.any? { |name, field| !field.active }
-      end
-    end
-
-  end
-end
+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 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
+      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
+
+      def has_disabled_fields?
+        @alist.any? { |name, field| !field.active }
+      end
+    end
+
+  end
+end