Merge pull request #172 from ruby-ldap/ber-message-id-encoding-fix

Test ber encoding of message_id > 128

Author: mtodd

Diff for: lib/net/ber/ber_parser.rb

@@ -41,9 +41,18 @@ def parse_ber_object(syntax, id, data)
       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

Diff for: 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:
 

Diff for: lib/net/ber/core_ext/bignum.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

Diff for: lib/net/ber/core_ext/fixnum.rb

@@ -26,25 +26,44 @@ def test_false
     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.