dnsruby 1.2 → 1.23

data/lib/Dnsruby/code_mapper.rb

@@ -51,7 +51,7 @@ module Dnsruby
       
       constants = self.constants - CodeMapper.constants
       constants.each do |i|
-        @@strings[self].store(i, const_get(i))
+        @@strings[self].store(i.to_s, const_get(i))
       end 
       @@maxcode[self] = constants.length
       @@values[self] = @@strings[self].invert
@@ -74,7 +74,10 @@ module Dnsruby
     end
     
     def unknown_code(arg) #:nodoc: all
-      raise ArgumentError.new("Code #{arg} not a member of #{self.class}")
+      # Be liberal in what you accept...
+#      raise ArgumentError.new("Code #{arg} not a member of #{self.class}")
+      Classes.add_pair(arg.to_s, arg)
+      set_code(arg)
     end
     
     def self.method_missing(methId) #:nodoc: all
@@ -86,12 +89,14 @@ module Dnsruby
       if (arg.kind_of?String)
         if (@@stringsdown[self.class][arg.downcase] != nil)
           set_string(arg)
-        else unknown_string(arg)
+        else 
+          unknown_string(arg)
         end
       elsif (arg.kind_of?Fixnum)
         if (@@values[self.class][arg] != nil)
           set_code(arg)
-        else unknown_code(arg)
+        else 
+          unknown_code(arg)
         end
       elsif (arg.kind_of?self.class)
         set_code(arg.code)

data/lib/Dnsruby/dnssec.rb

@@ -151,7 +151,7 @@ module Dnsruby
       end
     
       # Now check that we are in the validity period for the RRSIG
-      now = Time.now.to_i
+      now = Time.now
       if ((sigrec.expiration < now) || (sigrec.inception > now))
         raise VerifyError.new("Signature record not in validity period")
       end
@@ -329,6 +329,9 @@ module Dnsruby
         data = MessageEncoder.new { |msg|
           msg.put_rr(rec, true)
         }.to_s # @TODO@ worry about wildcards here?
+        if (RUBY_VERSION >= "1.9")
+          data.force_encoding("ASCII-8BIT")
+        end
         sig_data += data
       end
       
@@ -339,12 +342,12 @@ module Dnsruby
       elsif (sigrec.algorithm == HMAC_SHA256)
         verified = keyrec.public_key.verify(OpenSSL::Digest::SHA256.new, sigrec.signature, sig_data)
       else
-        raise RuntimeError.new("Algorithm #{sigrec.algorithm.string} unsupported by Dnsruby")
+        raise RuntimeError.new("Algorithm #{sigrec.algorithm.code} unsupported by Dnsruby")
       end
     
       if (verified)
         # Sort out the TTLs - set it to the minimum valid ttl
-        expiration_diff = (sigrec.expiration - Time.now.to_i).abs
+        expiration_diff = (sigrec.expiration.to_i - Time.now.to_i).abs
         rrset.ttl = ([rrset.ttl, sigrec.ttl, sigrec.original_ttl, 
             expiration_diff].sort)[0]
 

data/lib/Dnsruby/message.rb

@@ -111,6 +111,7 @@ module Dnsruby
       @signing = false
       @tsigkey = nil
       @answerfrom = nil
+      @answerip = nil
       type = Types.A
       klass = Classes.IN
       if (args.length > 0)
@@ -140,6 +141,9 @@ module Dnsruby
     #If this Message is a response from a server, then answerfrom contains the address of the server
     attr_accessor :answerfrom
     
+    #If this Message is a response from a server, then answerfrom contains the IP address of the server
+    attr_accessor :answerip
+    
     #If this Message is a response from a server, then answersize contains the size of the response
     attr_accessor :answersize
     
@@ -305,6 +309,25 @@ module Dnsruby
       return (@tsigstate == :Verified)
     end
     
+    def get_opt
+      each_additional do |r|
+        if (r.type == Types.OPT)
+          return r
+        end
+      end
+      return nil
+    end
+    
+    def rcode
+	rcode = @header.get_header_rcode
+	opt = get_opt
+	if (opt != nil)
+            rcode = rcode.code + (opt.xrcode << 4)
+            rcode = RCode.new(rcode)
+        end
+	return rcode;
+    end    
+
     def to_s
       retval = "";
       
@@ -312,11 +335,20 @@ module Dnsruby
         retval = retval + ";; Answer received from #{@answerfrom} (#{@answersize} bytes)\n;;\n";
       end
       
-      retval = retval + ";; HEADER SECTION\n";
-      retval = retval + @header.to_s;
-      retval = retval + "\n";
+      retval = retval + ";; HEADER SECTION\n"
+      # OPT pseudosection? EDNS flags, udpsize
+      opt = get_opt
+      if (!opt)
+        retval = retval + @header.to_s
+      else
+        retval = retval + @header.to_s_with_rcode(rcode())
+      end
+      retval = retval + "\n"
       
-      # @TODO@ OPT pseudosection? EDNS flags, udpsize
+      if (opt)
+        retval = retval + opt.to_s
+        retval = retval + "\n"
+      end
             
       section = (@header.opcode == OpCode.UPDATE) ? "ZONE" : "QUESTION";
       retval = retval +  ";; #{section} SECTION (#{@header.qdcount}  record#{@header.qdcount == 1 ? '' : 's'})\n";
@@ -324,25 +356,33 @@ module Dnsruby
         retval = retval + ";; #{qr.to_s}\n";
       }
       
-      retval = retval + "\n";
-      section = (@header.opcode == OpCode.UPDATE) ? "PREREQUISITE" : "ANSWER";
-      retval = retval + ";; #{section} SECTION (#{@header.ancount}  record#{@header.ancount == 1 ? '' : 's'})\n";
-      each_answer { |rr|
-        retval = retval + rr.to_s + "\n";
-      }
+      if (@answer.size > 0)
+        retval = retval + "\n";
+        section = (@header.opcode == OpCode.UPDATE) ? "PREREQUISITE" : "ANSWER";
+        retval = retval + ";; #{section} SECTION (#{@header.ancount}  record#{@header.ancount == 1 ? '' : 's'})\n";
+        each_answer { |rr|
+          retval = retval + rr.to_s + "\n";
+        }
+      end
       
-      retval = retval + "\n";
-      section = (@header.opcode == OpCode.UPDATE) ? "UPDATE" : "AUTHORITY";
-      retval = retval + ";; #{section} SECTION (#{@header.nscount}  record#{@header.nscount == 1 ? '' : 's'})\n";
-      each_authority { |rr|
-        retval = retval + rr.to_s + "\n";
-      }
+      if (@authority.size > 0)
+        retval = retval + "\n";
+        section = (@header.opcode == OpCode.UPDATE) ? "UPDATE" : "AUTHORITY";
+        retval = retval + ";; #{section} SECTION (#{@header.nscount}  record#{@header.nscount == 1 ? '' : 's'})\n";
+        each_authority { |rr|
+          retval = retval + rr.to_s + "\n";
+        }
+      end
       
-      retval = retval + "\n";
-      retval = retval + ";; ADDITIONAL SECTION (#{@header.arcount}  record#{@header.arcount == 1 ? '' : 's'})\n";
-      each_additional { |rr|
-        retval = retval + rr.to_s+ "\n";
-      }
+      if ((@additional.size > 0 && !opt) || (@additional.size > 1))
+        retval = retval + "\n";
+        retval = retval + ";; ADDITIONAL SECTION (#{@header.arcount}  record#{@header.arcount == 1 ? '' : 's'})\n";
+        each_additional { |rr|
+          if (rr.type != Types.OPT)
+            retval = retval + rr.to_s+ "\n"
+          end
+        }
+      end
       
       return retval;
     end
@@ -488,7 +528,12 @@ module Dnsruby
     attr_accessor :ra
     
     #Query response code
-    attr_reader :rcode
+    #deprecated - use Message#rcode
+#    attr_reader :rcode
+# This new get_header_rcode method is intended for use only by the Message class
+    def get_header_rcode
+      @rcode
+    end
     
     # The header opcode
     attr_reader :opcode
@@ -584,10 +629,14 @@ module Dnsruby
         @ra == other.ra &&
         @cd == other.cd &&
         @ad == other.ad &&
-        @rcode == other.rcode
+        @rcode == other.get_header_rcode
     end
     
     def to_s
+      to_s_with_rcode(@rcode)
+    end
+      
+    def to_s_with_rcode(rcode)
       retval = ";; id = #{@id}\n";
       
       if (@opcode == OpCode::Update)
@@ -609,7 +658,7 @@ module Dnsruby
         retval += ";; ra = #{@ra}    " +\
           "ad = #{@ad}    "  +\
           "cd = #{@cd}    "  +\
-          "rcode  = #{@rcode.string}\n";
+          "rcode  = #{rcode.string}\n";
         
         retval += ";; qdcount = #{@qdcount}  " +\
           "ancount = #{@ancount}  " +\
@@ -699,17 +748,34 @@ module Dnsruby
     
     def get_unpack(template)
       len = 0
+        littlec = ?c
+        bigc = ?C
+        littleh = ?h
+        bigh = ?H
+        littlen = ?n
+        bign = ?N
+        star = ?*
+      if (littlec.class != Fixnum)
+        # We're using Ruby 1.9 - convert the codes
+        littlec = littlec.getbyte(0)
+        bigc = bigc.getbyte(0)
+        littleh = littleh.getbyte(0)
+        bigh = bigh.getbyte(0)
+        littlen = littlen.getbyte(0)
+        bign = bign.getbyte(0)
+        star = star.getbyte(0)
+      end
       template.each_byte {|byte|
         case byte
-        when ?c, ?C
+        when littlec, bigc
           len += 1
-        when ?h, ?H
+        when littleh, bigh
           len += 1          
-        when ?n
+        when littlen
           len += 2
-        when ?N
+        when bign
           len += 4
-        when ?*
+        when star
           len = @limit-@index
         else
           raise StandardError.new("unsupported template: '#{byte.chr}' in '#{template}'")
@@ -723,7 +789,10 @@ module Dnsruby
     
     def get_string
       len = @data[@index]
-      raise DecodeError.new("limit exceeded") if @limit < @index + 1 + len
+      if (len.class == String)
+        len = len.getbyte(0)
+      end
+      raise DecodeError.new("limit exceeded\nlimit = #{@limit}, index = #{@index}, len = #{len}\n") if @limit < @index + 1 + len
       d = @data[@index + 1, len]
       @index += 1 + len
       return d
@@ -745,7 +814,11 @@ module Dnsruby
       limit = @index if !limit || @index < limit
       d = []
       while true
-        case @data[@index]
+        temp = @data[@index]
+        if (temp.class == String) 
+          temp = (temp.getbyte(0))
+        end
+        case temp # @data[@index]
         when 0
           @index += 1
           return d
@@ -767,7 +840,8 @@ module Dnsruby
     end
     
     def get_label
-      return Name::Label.new(Name::decode(self.get_string))
+      label = Name::Label.new(Name::decode(self.get_string))
+      return label
     end
     
     def get_question
@@ -957,5 +1031,7 @@ module Dnsruby
     alias ztype qtype
     # For Updates, the qclass field is redefined to zclass (RFC2136, section 2.3)
     alias zclass qclass
+    
+    alias type qtype
   end
 end

data/lib/Dnsruby/resource/DLV.rb

@@ -0,0 +1,27 @@
+#-- 
+#Copyright 2008 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
+     #RFC4431 specifies that the DLV is assigned type 32769, and the 
+     # rdata is identical to that of the DS record. 
+
+     class DLV < RR::DS
+       ClassValue = nil #:nodoc: all 
+       TypeValue = Types::DLV #:nodoc: all 
+     end
+   end
+end

data/lib/Dnsruby/resource/DNSKEY.rb

@@ -10,7 +10,7 @@
 #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 
+#See the License f181or the specific language governing permissions and 
 #limitations under the License.
 #++
 module Dnsruby
@@ -142,7 +142,7 @@ module Dnsruby
       def rdata_to_string #:nodoc: all
         if (@flags!=nil)
 #          return "#{@flags} #{@protocol} #{@algorithm.string} ( #{Base64.encode64(@key.to_s)} )"
-          return "#{@flags} #{@protocol} #{@algorithm.string} ( #{[@key.to_s].pack("m*")} )"
+          return "#{@flags} #{@protocol} #{@algorithm.string} ( #{[@key.to_s].pack("m*").gsub("\n", "")} )"
         else
           return ""
         end
@@ -150,7 +150,7 @@ module Dnsruby
       
       def encode_rdata(msg, canonical=false) #:nodoc: all
         # 2 octets, then 2 sets of 1 octet
-        msg.put_pack('ncc', @flags, @protocol, @algorithm.to_i)
+        msg.put_pack('ncc', @flags, @protocol, @algorithm.code)
         msg.put_bytes(@key)
       end
       
@@ -178,13 +178,28 @@ module Dnsruby
           last = 0
           0.step(rdata.length-1, 2) {|i|
             last = i
-            d1 = rdata[i] & 0xFF
-            d2 = rdata[i + 1] & 0xFF
+            d1 = rdata[i]
+            d2 = rdata[i + 1]
+
+          if (d1.class == String) # Ruby 1.9
+            d1 = d1.getbyte(0)
+            d2 = d2.getbyte(0)
+          end
+          
+            d1 = d1  & 0xFF
+            d2 = d2  & 0xFF
+
             tag += ((d1 << 8) + d2)
           }
           last+=2
           if (last < rdata.length)
-            d1 = rdata[last] & 0xFF
+            d1 = rdata[last] 
+            
+            if (d1.class == String) # Ruby 1.9
+              d1 = d1.getbyte(0)
+            end
+            
+            d1 = d1 & 0xFF
             tag += (d1 << 8)
           end
           tag += ((tag >> 16) & 0xFFFF)
@@ -212,9 +227,16 @@ module Dnsruby
       
       def rsa_key
         exponentLength = @key[0]
+        if (exponentLength.class == String)
+          exponentLength = exponentLength.getbyte(0) # Ruby 1.9
+        end
         pos = 1
         if (exponentLength == 0)
-          exponentLength = (@key[1]<<8) + @key[1]
+          key1 = @key[1]
+          if (key1.class == String) # Ruby 1.9
+            key1 = key1.getbyte(0)
+          end
+          exponentLength = (key1<<8) + key1
           pos += 2
         end
         exponent = get_num(@key[pos, exponentLength])

data/lib/Dnsruby/resource/DS.rb

@@ -13,6 +13,7 @@
 #See the License for the specific language governing permissions and 
 #limitations under the License.
 #++
+require 'base64'
 module Dnsruby
   class RR
     #RFC4034, section 4
@@ -27,6 +28,12 @@ module Dnsruby
     #[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
       
@@ -57,15 +64,27 @@ module Dnsruby
       #The DS record refers to a DNSKEY RR by including a digest of that
       #DNSKEY RR.
       attr_accessor :digest
+      attr_accessor :digestbin
       
       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
+        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)
@@ -81,21 +100,36 @@ module Dnsruby
       end
       
       # Return the digest of the specified DNSKEY RR
-      def digest_key(key)
+      def digest_key(*args) # key, digest_type)
+        digest_type = @digest_type
+        key = args[0]
+        if (args.length == 2)
+            digest_type = args[1]
+        end
+        
+        
         data = MessageEncoder.new {|msg|
-          msg.put_rr(key, true)
+           msg.put_name(key.name, true)
+           key.encode_rdata(msg, true)
         }.to_s
 
-        OpenSSL::Digest::SHA1.new(data)
-        return digest
+        
+        if (digest_type.code == 1)
+            digestbin = OpenSSL::Digest::SHA1.digest(data)
+            return digestbin
+        elsif (digest_type.code == 2) 
+            digestbin = OpenSSL::Digest::SHA256.digest(data)
+            return digestbin
+        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)
+          
+          digestbin = digest_key(key)
+          if (@digestbin == digestbin)
             if (!key.zone_key?)
             else
               return true
@@ -107,12 +141,52 @@ module Dnsruby
       end
       
 
+      def DS.from_key(key, digest_type)
+## The key must not be a NULL key.
+#    if ((key.flags & 0xc000 ) == 0xc000 )
+#	puts "\nCreating a DS record for a NULL key is illegal"
+#        return
+#    end
+#    
+#    # Bit 0 must not be set.
+#    if (key.flags & 0x8000)
+#	puts "\nCreating a DS record for a key with flag bit 0 set " +
+#	    "to 0 is illegal"
+#          return
+#    end
+#    
+    # Bit 6 must be set to 0 bit 7 must be set to 1
+    if (( key.flags & 0x300) != 0x100)
+	puts "\nCreating a DS record for a key with flags 6 and 7 not set "+
+	    "0  and 1 respectively is illegal"
+         return
+    end
+#    
+#
+#    if (key.protocol  != 3 )
+#	puts "\nCreating a DS record for a non DNSSEC (protocol=3) " +
+#	    "key is illegal"
+#          return
+#    end
+#    
+        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)
+                   
+        ds.digestbin = ds.digest_key(key, digest_type)
+        ds.digest = ds.digestbin.unpack("H*")[0]
+        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)
+        self.digestbin=(digest)
+        self.digest=@digestbin.unpack("H*")[0]
       end
       
       def from_string(input)
@@ -133,22 +207,27 @@ module Dnsruby
             buf += data[i]
           } 
 #          self.digest=Base64.decode64(buf)
-          self.digest=buf.unpack("m*")[0]
+          buf.gsub!(/\n/, "")
+          buf.gsub!(/ /, "")
+#          self.digest=buf.unpack("m*")[0]
+          self.digest=buf
+          self.digestbin = [buf].pack("H*")
         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*")} )"
+#          return "#{@key_tag.to_i} #{@algorithm.string} #{@digest_type.code} ( #{[@digest].pack("m*").gsub("\n", "")} )"
+          return "#{@key_tag.to_i} #{@algorithm.string} #{@digest_type.code} ( #{@digest.upcase} )"
         else
           return ""
-        end
+        end 
       end
       
       def encode_rdata(msg, canonical=false) #:nodoc: all
-        msg.put_pack("ncc", @key_tag, @algorithm.code, @digest_type)
-        msg.put_bytes(@digest)
+        msg.put_pack("ncc", @key_tag, @algorithm.code, @digest_type.code)
+        msg.put_bytes(@digestbin)
       end
       
       def self.decode_rdata(msg) #:nodoc: all