dnsruby 1.2 → 1.23

data/lib/Dnsruby/resource/DS.rb.new

@@ -0,0 +1,202 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR
+    #RFC4034, section 4
+    #The DS Resource Record refers to a DNSKEY RR and is used in the DNS
+    #DNSKEY authentication process.  A DS RR refers to a DNSKEY RR by
+    #storing the key tag, algorithm number, and a digest of the DNSKEY RR.
+    #Note that while the digest should be sufficient to identify the
+    #public key, storing the key tag and key algorithm helps make the
+    #identification process more efficient.  By authenticating the DS
+    #record, a resolver can authenticate the DNSKEY RR to which the DS
+    #record points.  The key authentication process is described in
+    #[RFC4035].
+
+    class DS < RR
+      class DigestTypes < CodeMapper
+        update()
+        add_pair("SHA-1", 1)
+        add_pair("SHA-2", 2 )
+      end
+  
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::DS #:nodoc: all
+      
+      #The RDATA for a DS RR consists of a 2 octet Key Tag field, a 1 octet
+      #Algorithm field, a 1 octet Digest Type field, and a Digest field.
+      #
+      #                     1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
+      # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #|           Key Tag             |  Algorithm    |  Digest Type  |
+      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #/                                                               /
+      #/                            Digest                             /
+      #/                                                               /
+      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   
+
+      #The Key Tag field lists the key tag of the DNSKEY RR referred to by
+      #the DS record, in network byte order.
+      attr_accessor :key_tag
+      #The algorithm used for this key
+      #See Dnsruby::Algorithms for permitted values
+      attr_reader :algorithm
+      #The DS RR refers to a DNSKEY RR by including a digest of that DNSKEY
+      #RR.  The Digest Type field identifies the algorithm used to construct
+      #the digest.
+      attr_reader :digest_type
+      #The DS record refers to a DNSKEY RR by including a digest of that
+      #DNSKEY RR.
+      attr_accessor :digest
+      
+      def digest_type=(d)
+        dig = DS.get_digest_type(d)
+        @digest_type = dig
+      end
+      
+      def DS.get_digest_type(d)
+        if (d.instance_of?String)
+          if (d.length == 1)
+            d = d.to_i
+          end
+        end
+        begin
+          digest = DigestTypes.new(d)
+          return digest
+        rescue ArgumentError => e
+          raise DecodeError.new(e)
+        end        
+      end
+
+      def algorithm=(a)
+        if (a.instance_of?String)
+          if (a.length == 1)
+            a = a.to_i
+          end
+        end
+        begin
+          alg = Algorithms.new(a)
+          @algorithm = alg
+        rescue ArgumentError => e
+          raise DecodeError.new(e)
+        end        
+      end
+      
+      # Return the digest of the specified DNSKEY RR
+      def digest_key(key)
+        return DS.digest_key(key, @digest_type)
+      end
+      
+      def DS.digest_key(key, digest_type)
+        data = MessageEncoder.new {|msg|
+          msg.put_rr(key, true)
+        }.to_s
+
+        if (digest_type.code == 1)
+            digest = OpenSSL::Digest::SHA1.digest(data)
+            print digest.to_s + "\n"
+            return digest
+        elsif (digest_type.code == 2) 
+            digest = OpenSSL::Digest::SHA256.digest(data)
+            print digest.to_s + "\n"
+            return digest
+        end
+
+      end
+
+      # Check if the key's digest is the same as that stored in the DS record      
+      def check_key(key)
+        if (key.key_tag == @key_tag)
+          digest = digest_key(key)
+          if (@digest == digest)
+            if (!key.zone_key?)
+            else
+              return true
+            end
+          else
+          end
+        end
+        return false
+      end
+      
+      def DS.from_key(key, digest_type)
+        digest_type = get_digest_type(digest_type)
+        # Create a new DS record from the specified key
+        ds = RR.create(:name => key.name, :type => "DS", :ttl => key.ttl, 
+                      :key_tag => key.key_tag,
+                     :digest_type => digest_type, :algorithm => key.algorithm,
+                     :digest => digest_key(key, digest_type))
+        return ds
+      end
+      
+
+      def from_data(data) #:nodoc: all
+        key_tag, algorithm, digest_type, digest = data
+        self.key_tag=(key_tag)
+        self.algorithm=(algorithm)
+        self.digest_type=(digest_type)
+        self.digest=(digest)
+      end
+      
+      def from_string(input)
+        if (input.length > 0)
+          data = input.split(" ")
+          self.key_tag=(data[0].to_i)
+          self.algorithm=(data[1])
+          self.digest_type=(data[2])
+
+          buf = ""
+          index = 3
+          end_index = data.length - 1
+          if (data[index]=="(")
+            end_index = data.length - 2
+            index = 4
+          end
+          (index..end_index).each {|i|
+            buf += data[i]
+          } 
+##          self.digest=Base64.decode64(buf)
+#          buf.gsub!(/\n/, "")
+#          buf.gsub!(/ /, "")
+          self.digest=buf.unpack("m*")[0]
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@key_tag != nil)
+#          return "#{@key_tag.to_i} #{@algorithm.string} #{@digest_type} ( #{Base64.encode64(@digest)} )"
+          return "#{@key_tag.to_i} #{@algorithm.string} #{@digest_type.code} ( #{[@digest].pack("m*").gsub("\n", "")} )"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack("ncc", @key_tag, @algorithm.code, @digest_type.code)
+        msg.put_bytes(@digest)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        key_tag, algorithm, digest_type = msg.get_unpack("ncc")
+        digest = msg.get_bytes
+        return self.new(
+          [key_tag, algorithm, digest_type, digest])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/DS.rb.orig

@@ -0,0 +1,162 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR
+    #RFC4034, section 4
+    #The DS Resource Record refers to a DNSKEY RR and is used in the DNS
+    #DNSKEY authentication process.  A DS RR refers to a DNSKEY RR by
+    #storing the key tag, algorithm number, and a digest of the DNSKEY RR.
+    #Note that while the digest should be sufficient to identify the
+    #public key, storing the key tag and key algorithm helps make the
+    #identification process more efficient.  By authenticating the DS
+    #record, a resolver can authenticate the DNSKEY RR to which the DS
+    #record points.  The key authentication process is described in
+    #[RFC4035].
+
+    class DS < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::DS #:nodoc: all
+      
+      #The RDATA for a DS RR consists of a 2 octet Key Tag field, a 1 octet
+      #Algorithm field, a 1 octet Digest Type field, and a Digest field.
+      #
+      #                     1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
+      # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #|           Key Tag             |  Algorithm    |  Digest Type  |
+      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #/                                                               /
+      #/                            Digest                             /
+      #/                                                               /
+      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   
+
+      #The Key Tag field lists the key tag of the DNSKEY RR referred to by
+      #the DS record, in network byte order.
+      attr_accessor :key_tag
+      #The algorithm used for this key
+      #See Dnsruby::Algorithms for permitted values
+      attr_reader :algorithm
+      #The DS RR refers to a DNSKEY RR by including a digest of that DNSKEY
+      #RR.  The Digest Type field identifies the algorithm used to construct
+      #the digest.
+      attr_reader :digest_type
+      #The DS record refers to a DNSKEY RR by including a digest of that
+      #DNSKEY RR.
+      attr_accessor :digest
+      
+      def digest_type=(d)
+        if ((d == 1) || (d == "SHA-1") || (d == "1"))
+          @digest_type = 1
+        else
+          raise DecodeError.new("Unsupported DS digest type (#{d})")
+        end
+      end
+      
+      def algorithm=(a)
+        if (a.instance_of?String)
+          if (a.length == 1)
+            a = a.to_i
+          end
+        end
+        begin
+          alg = Algorithms.new(a)
+          @algorithm = alg
+        rescue ArgumentError => e
+          raise DecodeError.new(e)
+        end        
+      end
+      
+      # Return the digest of the specified DNSKEY RR
+      def digest_key(key)
+        data = MessageEncoder.new {|msg|
+          msg.put_rr(key, true)
+        }.to_s
+
+        OpenSSL::Digest::SHA1.new(data)
+        return digest
+
+      end
+
+      # Check if the key's digest is the same as that stored in the DS record      
+      def check_key(key)
+        if (key.key_tag == @key_tag)
+          digest = digest_key(key)
+          if (@digest == digest)
+            if (!key.zone_key?)
+            else
+              return true
+            end
+          else
+          end
+        end
+        return false
+      end
+      
+
+      def from_data(data) #:nodoc: all
+        key_tag, algorithm, digest_type, digest = data
+        self.key_tag=(key_tag)
+        self.algorithm=(algorithm)
+        self.digest_type=(digest_type)
+        self.digest=(digest)
+      end
+      
+      def from_string(input)
+        if (input.length > 0)
+          data = input.split(" ")
+          self.key_tag=(data[0].to_i)
+          self.algorithm=(data[1])
+          self.digest_type=(data[2])
+
+          buf = ""
+          index = 3
+          end_index = data.length - 1
+          if (data[index]=="(")
+            end_index = data.length - 2
+            index = 4
+          end
+          (index..end_index).each {|i|
+            buf += data[i]
+          } 
+#          self.digest=Base64.decode64(buf)
+          self.digest=buf.unpack("m*")[0]
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@key_tag != nil)
+#          return "#{@key_tag.to_i} #{@algorithm.string} #{@digest_type} ( #{Base64.encode64(@digest)} )"
+          return "#{@key_tag.to_i} #{@algorithm.string} #{@digest_type} ( #{[@digest].pack("m*")} )"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack("ncc", @key_tag, @algorithm.code, @digest_type)
+        msg.put_bytes(@digest)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        key_tag, algorithm, digest_type = msg.get_unpack("ncc")
+        digest = msg.get_bytes
+        return self.new(
+          [key_tag, algorithm, digest_type, digest])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/NSEC.rb

@@ -95,6 +95,10 @@ module Dnsruby
           end
           window_number = bytes[pos]
           bitmap_length = bytes[pos+1]
+          if (window_number.class == String) # Ruby 1.9
+            window_number = window_number.getbyte(0)
+            bitmap_length = bitmap_length.getbyte(0)
+          end
           pos += 2
           bitmap = bytes[pos,bitmap_length]
           pos += bitmap_length
@@ -170,7 +174,11 @@ module Dnsruby
                 break if (types_to_go.empty?)
               end
               bitmap += " "
-              bitmap[bitmap_pos]=byte
+              if (bitmap[bitmap_pos].class == String)
+                bitmap.setbyte(bitmap_pos, byte) # Ruby 1.9
+              else
+                bitmap[bitmap_pos]=byte              
+              end
               bitmap_pos+=1
             end
             
@@ -180,11 +188,19 @@ module Dnsruby
               output += " "
             end
           
-            output[start] = window
-            output[start+1] = bitmap.length
-            bitmap.length.times do |i|
-              output[start+2+i] = bitmap[i]
-            end
+            if (output[start].class == String)
+              output.setbyte(start, window)
+              output.setbyte(start+1, bitmap.length)
+              bitmap.length.times do |i|
+                output.setbyte(start+2+i, bitmap[i].getbyte(0))
+              end
+            else
+              output[start] = window
+              output[start+1] = bitmap.length
+              bitmap.length.times do |i|
+                output[start+2+i] = bitmap[i]
+              end
+           end
           end
           window += 1
           

data/lib/Dnsruby/resource/OPT.rb

@@ -130,7 +130,7 @@ module Dnsruby
       end
       
       def payloadsize
-        return @klass
+        return @klass.code
       end
       
       def payloadsize=(size)
@@ -161,28 +161,25 @@ module Dnsruby
       end
       
       def from_string(input)
-        if input
-          @options = input.split(" ")
-        end
+        raise NotImplementedError
       end
       
       def to_s
-        ret = "OPT pseudo-record : #{klass.code} max UDP packet size, "
-        ret = ""
+        ret = "OPT pseudo-record : payloadsize #{payloadsize}, xrcode #{xrcode}, version #{version}, flags #{flags}"
         if @options
           @options.each do |opt|
-            ret = ret + opt.to_s + " "
+            ret = ret + " " + opt.to_s
           end
-          ret.chomp!
         end
+        ret = ret + "\n"
         return ret
       end
       
       def encode_rdata(msg, canonical=false)
         if (@options)
           @options.each do |opt|
-            msg.pack('n', opt.code)
-            msg.pack('n', opt.data.length)
+            msg.put_pack('n', opt.code)
+            msg.put_pack('n', opt.data.length)
             msg.put_bytes(opt.data)
           end
           msg.put_array(@options)
@@ -193,10 +190,10 @@ module Dnsruby
         if (msg.has_remaining)
           options = []
           while (msg.has_remaining) do
-            code = msg.unpack('n')
-            len = msg.unpack('n')
+            code  = msg.get_unpack('n')[0]
+            len = msg.get_unpack('n')[0]
             data = msg.get_bytes(len)
-            options.add(Option.new(code, data))
+            options.push(Option.new(code, data))
           end
         end
         return self.new([options])
@@ -204,6 +201,10 @@ module Dnsruby
       
       class Option
         attr_accessor :code, :data
+        def initialize(code, data)
+          @code = code
+          @data = data
+        end
       end
     end
   end