net-ldap 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 570b21d340b31538c59bb0082891227b4b048398
-  data.tar.gz: 3101e8927d74913355235198f91b2907b308b712
+  metadata.gz: fe93b5d4adc9f8aad092d00b1e3b6f9049ebf40d
+  data.tar.gz: 3483c7b26e26a6f87385e60f2c58b32fa508df89
 SHA512:
-  metadata.gz: c9f13490870b0aba267a7de18150eaf40aabf0fb1ace4f0476456b78305873ceb6417448685f3727e737759ae8c4e3db05743cf3b38ba5a64ddf4f6559b11302
-  data.tar.gz: ba4770abb3b87844dc138d21f94cc4c783d0addae63f525b119d99656b9b1ac32d36a6dc28ea017b74504828737b90b757d878337db1ada66edf9ccfe3d3d451
+  metadata.gz: 4790e354827d3886500a788a154247c8b8ef582273e74d876d88d1a52edcfe5fb44c8f5efcbc54a7f246bca20413ace95491508f69d379c89b57b52c12b2f3f7
+  data.tar.gz: cab9f575616ca54675015d42ac15f4add481a24fd4ae5c30867980ddf306363dbb28262b134e04cbb975557a6821f777c2a62ee0aa4d1c0173991f8f62a28bea

data/History.rdoc

@@ -1,3 +1,7 @@
+=== Net::LDAP 0.10.1
+* Bug fixes:
+  * Fix Integer BER encoding of signed values
+
 === Net::LDAP 0.10.0
 * Major enhancements:
   * Accept SimpleTLS/StartTLS encryption options (compatible with `OpenSSL::SSL::SSLContext#set_params`)

data/lib/net/ber/ber_parser.rb

@@ -41,9 +41,18 @@ module Net::BER::BERParser
       s.ber_identifier = id
       s
     elsif object_type == :integer
-      j = 0
-      data.each_byte { |b| j = (j << 8) + b }
-      j
+      neg = !(data.unpack("C").first & 0x80).zero?
+      int = 0
+
+      data.each_byte do |b|
+        int = (int << 8) + (neg ? 255 - b : b)
+      end
+
+      if neg
+        (int + 1) * -1
+      else
+        int
+      end
     elsif object_type == :oid
       # See X.690 pgh 8.19 for an explanation of this algorithm.
       # This is potentially not good enough. We may need a

data/lib/net/ber/core_ext.rb

@@ -33,17 +33,10 @@ class Array
 end
 # :startdoc:
 
-require 'net/ber/core_ext/bignum'
+require 'net/ber/core_ext/integer'
 # :stopdoc:
-class Bignum
-  include Net::BER::Extensions::Bignum
-end
-# :startdoc:
-
-require 'net/ber/core_ext/fixnum'
-# :stopdoc:
-class Fixnum
-  include Net::BER::Extensions::Fixnum
+class Integer
+  include Net::BER::Extensions::Integer
 end
 # :startdoc:
 

data/lib/net/ber/core_ext/integer.rb

@@ -0,0 +1,74 @@
+# -*- ruby encoding: utf-8 -*-
+##
+# BER extensions to the Integer class, affecting Fixnum and Bignum objects.
+module Net::BER::Extensions::Integer
+  ##
+  # Converts the Integer to BER format.
+  def to_ber
+    "\002#{to_ber_internal}"
+  end
+
+  ##
+  # Converts the Integer to BER enumerated format.
+  def to_ber_enumerated
+    "\012#{to_ber_internal}"
+  end
+
+  ##
+  # Converts the Integer to BER length encoding format.
+  def to_ber_length_encoding
+    if self <= 127
+      [self].pack('C')
+    else
+      i = [self].pack('N').sub(/^[\0]+/,"")
+      [0x80 + i.length].pack('C') + i
+    end
+  end
+
+  ##
+  # Generate a BER-encoding for an application-defined INTEGER. Examples of
+  # such integers are SNMP's Counter, Gauge, and TimeTick types.
+  def to_ber_application(tag)
+    [0x40 + tag].pack("C") + to_ber_internal
+  end
+
+  ##
+  # Used to BER-encode the length and content bytes of an Integer. Callers
+  # must prepend the tag byte for the contained value.
+  def to_ber_internal
+    # Compute the byte length, accounting for negative values requiring two's
+    # complement.
+    size  = 1
+    size += 1 until (((self < 0) ? ~self : self) >> (size * 8)).zero?
+
+    # Padding for positive, negative values. See section 8.5 of ITU-T X.690:
+    # http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
+
+    # For positive integers, if most significant bit in an octet is set to one,
+    # pad the result (otherwise it's decoded as a negative value).
+    if self > 0 && (self & (0x80 << (size - 1) * 8)) > 0
+      size += 1
+    end
+
+    # And for negative integers, pad if the most significant bit in the octet
+    # is not set to one (othwerise, it's decoded as positive value).
+    if self < 0 && (self & (0x80 << (size - 1) * 8)) == 0
+      size += 1
+    end
+
+    # Store the size of the Integer in the result
+    result = [size]
+
+    # Appends bytes to result, starting with higher orders first. Extraction
+    # of bytes is done by right shifting the original Integer by an amount
+    # and then masking that with 0xff.
+    while size > 0
+      # right shift size - 1 bytes, mask with 0xff
+      result << ((self >> ((size - 1) * 8)) & 0xff)
+      size -= 1
+    end
+
+    result.pack('C*')
+  end
+  private :to_ber_internal
+end

data/lib/net/ldap/version.rb

@@ -1,5 +1,5 @@
 module Net
   class LDAP
-    VERSION = "0.10.0"
+    VERSION = "0.10.1"
   end
 end

data/test/ber/test_ber.rb

@@ -26,25 +26,44 @@ class TestBEREncoding < Test::Unit::TestCase
     0           => "\x02\x01\x00",
     1           => "\x02\x01\x01",
     127         => "\x02\x01\x7F",
-    128         => "\x02\x01\x80",
-    255         => "\x02\x01\xFF",
+    128         => "\x02\x02\x00\x80",
+    255         => "\x02\x02\x00\xFF",
     256         => "\x02\x02\x01\x00",
-    65535       => "\x02\x02\xFF\xFF",
+    65535       => "\x02\x03\x00\xFF\xFF",
     65536       => "\x02\x03\x01\x00\x00",
-    16_777_215  => "\x02\x03\xFF\xFF\xFF",
+    8388607     => "\x02\x03\x7F\xFF\xFF",
+    8388608     => "\x02\x04\x00\x80\x00\x00",
+    16_777_215  => "\x02\x04\x00\xFF\xFF\xFF",
     0x01000000  => "\x02\x04\x01\x00\x00\x00",
     0x3FFFFFFF  => "\x02\x04\x3F\xFF\xFF\xFF",
     0x4FFFFFFF  => "\x02\x04\x4F\xFF\xFF\xFF",
 
     # Some odd samples...
-    5           => "\002\001\005",
-    500         => "\002\002\001\364",
-    50_000      => "\x02\x02\xC3P",
-    5_000_000_000  => "\002\005\001*\005\362\000"
+    5           => "\x02\x01\x05",
+    500         => "\x02\x02\x01\xf4",
+    50_000      => "\x02\x03\x00\xC3\x50",
+    5_000_000_000 => "\x02\x05\x01\x2a\x05\xF2\x00",
+
+    # negatives
+    -1          => "\x02\x01\xFF",
+    -127        => "\x02\x01\x81",
+    -128        => "\x02\x01\x80",
+    -255        => "\x02\x02\xFF\x01",
+    -256        => "\x02\x02\xFF\x00",
+    -65535      => "\x02\x03\xFF\x00\x01",
+    -65536      => "\x02\x03\xFF\x00\x00",
+    -65537      => "\x02\x03\xFE\xFF\xFF",
+    -8388607    => "\x02\x03\x80\x00\x01",
+    -8388608    => "\x02\x03\x80\x00\x00",
+    -16_777_215 => "\x02\x04\xFF\x00\x00\x01",
   }.each do |number, expected_encoding|
     define_method "test_encode_#{number}" do
       assert_equal expected_encoding.b, number.to_ber
     end
+
+    define_method "test_decode_encoded_#{number}" do
+      assert_equal number, expected_encoding.b.read_ber
+    end
   end
 
   # Round-trip encoding: This is mostly to be sure to cover Bignums well.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-ldap
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Francis Cianfrocca
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-10 00:00:00.000000000 Z
+date: 2014-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: flexmock
@@ -85,9 +85,8 @@ files:
 - lib/net/ber/ber_parser.rb
 - lib/net/ber/core_ext.rb
 - lib/net/ber/core_ext/array.rb
-- lib/net/ber/core_ext/bignum.rb
 - lib/net/ber/core_ext/false_class.rb
-- lib/net/ber/core_ext/fixnum.rb
+- lib/net/ber/core_ext/integer.rb
 - lib/net/ber/core_ext/string.rb
 - lib/net/ber/core_ext/true_class.rb
 - lib/net/ldap.rb

data/lib/net/ber/core_ext/bignum.rb

@@ -1,22 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-##
-# BER extensions to the Bignum class.
-module Net::BER::Extensions::Bignum
-  ##
-  # Converts a Bignum to an uncompressed BER integer.
-  def to_ber
-    result = []
-
-    # NOTE: Array#pack's 'w' is a BER _compressed_ integer. We need
-    # uncompressed BER integers, so we're not using that. See also:
-    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/228864
-    n = self
-    while n > 0
-      b = n & 0xff
-      result << b
-      n = n >> 8
-    end
-
-    "\002" + ([result.size] + result.reverse).pack('C*')
-  end
-end

data/lib/net/ber/core_ext/fixnum.rb

@@ -1,66 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-##
-# Ber extensions to the Fixnum class.
-module Net::BER::Extensions::Fixnum
-  ##
-  # Converts the fixnum to BER format.
-  def to_ber
-    "\002#{to_ber_internal}"
-  end
-
-  ##
-  # Converts the fixnum to BER enumerated format.
-  def to_ber_enumerated
-    "\012#{to_ber_internal}"
-  end
-
-  ##
-  # Converts the fixnum to BER length encodining format.
-  def to_ber_length_encoding
-    if self <= 127
-      [self].pack('C')
-    else
-      i = [self].pack('N').sub(/^[\0]+/,"")
-      [0x80 + i.length].pack('C') + i
-    end
-  end
-
-  ##
-  # Generate a BER-encoding for an application-defined INTEGER. Examples of
-  # such integers are SNMP's Counter, Gauge, and TimeTick types.
-  def to_ber_application(tag)
-    [0x40 + tag].pack("C") + to_ber_internal
-  end
-
-  ##
-  # Used to BER-encode the length and content bytes of a Fixnum. Callers
-  # must prepend the tag byte for the contained value.
-  def to_ber_internal
-    # CAUTION: Bit twiddling ahead. You might want to shield your eyes or
-    # something.
-
-    # Looks for the first byte in the fixnum that is not all zeroes. It does
-    # this by masking one byte after another, checking the result for bits
-    # that are left on.
-    size = Net::BER::MAX_FIXNUM_SIZE
-    while size > 1
-      break if (self & (0xff << (size - 1) * 8)) > 0
-      size -= 1
-    end
-
-    # Store the size of the fixnum in the result
-    result = [size]
-
-    # Appends bytes to result, starting with higher orders first. Extraction
-    # of bytes is done by right shifting the original fixnum by an amount
-    # and then masking that with 0xff.
-    while size > 0
-      # right shift size - 1 bytes, mask with 0xff
-      result << ((self >> ((size - 1) * 8)) & 0xff)
-      size -= 1
-    end
-
-    result.pack('C*')
-  end
-  private :to_ber_internal
-end