dnsruby 1.1

data/lib/Dnsruby/resource/NSEC3.rb

@@ -0,0 +1,173 @@
+#--
+#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
+    #The NSEC3 Resource Record (RR) provides authenticated denial of
+    #existence for DNS Resource Record Sets.
+    #
+    #The NSEC3 RR lists RR types present at the original owner name of the
+    #NSEC3 RR.  It includes the next hashed owner name in the hash order
+    #of the zone.  The complete set of NSEC3 RRs in a zone indicates which
+    #RRSets exist for the original owner name of the RR and form a chain
+    #of hashed owner names in the zone.  This information is used to
+    #provide authenticated denial of existence for DNS data.  To provide
+    #protection against zone enumeration, the owner names used in the
+    #NSEC3 RR are cryptographic hashes of the original owner name
+    #prepended as a single label to the name of the zone.  The NSEC3 RR
+    #indicates which hash function is used to construct the hash, which
+    #salt is used, and how many iterations of the hash function are
+    #performed over the original owner name.
+    class NSEC3 < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::NSEC3 #:nodoc: all
+      
+      #The Hash Algorithm field identifies the cryptographic hash algorithm
+      #used to construct the hash-value.
+      attr_reader :hash_alg
+      #The Flags field contains 8 one-bit flags that can be used to indicate
+      #different processing.  All undefined flags must be zero.  The only
+      #flag defined by the NSEC3 specification is the Opt-Out flag.
+      attr_reader :flags
+      #The Iterations field defines the number of additional times the hash
+      #function has been performed.
+      attr_accessor :iterations
+      #The Salt Length field defines the length of the Salt field in octets,
+      #ranging in value from 0 to 255.
+      attr_reader :salt_length
+      #The Salt field is appended to the original owner name before hashing
+      #in order to defend against pre-calculated dictionary attacks.
+      attr_accessor :salt
+      #The Hash Length field defines the length of the Next Hashed Owner
+      #Name field, ranging in value from 1 to 255 octets.
+      attr_reader :hash_length
+      #The Next Hashed Owner Name field contains the next hashed owner name
+      #in hash order.        
+      attr_accessor :next_hashed
+      #The Type Bit Maps field identifies the RRset types that exist at the
+      #NSEC RR's owner name
+      attr_reader :types
+      
+      def hash_alg=(a)
+        if (a.instance_of?String)
+          if (a.length == 1)
+            a = a.to_i
+          end
+        end
+        begin
+          alg = Algorithms.new(a)
+          @hash_alg = alg
+        rescue ArgumentError => e
+          raise DecodeError.new(e)
+        end        
+      end
+      
+      def types=(t)
+        @types = NSEC.get_types(t)
+      end
+      
+      def add_type(t)
+        self.types=(@types + [t])
+      end
+      
+      def flags=(f)
+        if (f==0 || f==1)
+          @flags=f
+        else
+          raise DecodeError.new("Unknown NSEC3 flags field - #{f}")
+        end
+      end
+      
+      #If the Opt-Out flag is set, the NSEC3 record covers zero or more
+      #unsigned delegations.
+      def opt_out?
+        return (@flags==1)
+      end
+      
+      def salt_length=(l)
+        if ((l < 0) || (l > 255))
+          raise DecodeError.new("NSEC3 salt length must be between 0 and 255")
+        end
+        @salt_length = l
+      end
+      
+      def hash_length=(l)
+        if ((l < 0) || (l > 255))
+          raise DecodeError.new("NSEC3 hash length must be between 0 and 255")
+        end
+        @hash_length = l        
+      end
+   
+      def from_data(data) #:nodoc: all
+        hash_alg, flags, iterations, salt_length, salt, hash_length, next_hashed, types = data
+        self.hash_alg=(hash_alg)
+        self.flags=(flags)
+        self.iterations=(iterations)
+        self.salt_length=(salt_length)
+        self.salt=(salt)
+        self.hash_length=(hash_length)
+        self.next_hashed=(next_hashed)
+        self.types=(types)
+      end
+      
+      def from_string(input)
+        if (input.length > 0)
+          data = input.split(" ")
+          self.hash_alg=(data[0]).to_i
+          self.flags=(data[1]).to_i
+          self.iterations=(data[2]).to_i
+          self.salt=(data[3])
+          self.salt_length=(data[3].length)
+          self.next_hashed=(data[5])
+          self.hash_length=(data[5].length)
+          len = data[0].length + data[1].length + data[2].length + data[3].length + data[5].length + 7
+          self.types=(input[len, input.length-len])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@next_hashed!=nil)
+          type_strings = []
+          @types.each do |t|
+            type_strings.push(t.string)
+          end
+          types = type_strings.join(" ")
+          return "#{@hash_alg.code} #{@flags} #{@iterations} #{@salt} ( #{@next_hashed} #{types} )"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack("ccnc", @hash_alg.code, @flags, @iterations, @salt_length)
+        msg.put_bytes(@salt)
+        msg.put_pack("c", @hash_length)
+        msg.put_bytes(@next_hashed)
+        types = NSEC.encode_types(self)
+        msg.put_bytes(types)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        hash_alg, flags, iterations, salt_length = msg.get_unpack("ccnc")
+        salt = msg.get_bytes(salt_length)
+        hash_length, = msg.get_unpack("c")
+        next_hashed = msg.get_bytes(hash_length)
+        types = NSEC.decode_types(msg.get_bytes)
+        return self.new(
+          [hash_alg, flags, iterations, salt_length, salt, hash_length, next_hashed, types])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/NSEC3PARAM.rb

@@ -0,0 +1,120 @@
+#--
+#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
+    #The NSEC3PARAM RR contains the NSEC3 parameters (hash algorithm,
+    #flags, iterations and salt) needed by authoritative servers to
+    #calculate hashed owner names.  The presence of an NSEC3PARAM RR at a
+    #zone apex indicates that the specified parameters may be used by
+    #authoritative servers to choose an appropriate set of NSEC3 RRs for
+    #negative responses.  The NSEC3PARAM RR is not used by validators or
+    #resolvers.
+    class NSEC3PARAM < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::NSEC3PARAM #:nodoc: all
+      
+      #The Hash Algorithm field identifies the cryptographic hash algorithm
+      #used to construct the hash-value.
+      attr_reader :hash_alg
+      #The Flags field contains 8 one-bit flags that can be used to indicate
+      #different processing.  All undefined flags must be zero.  The only
+      #flag defined by the NSEC3 specification is the Opt-Out flag.
+      attr_reader :flags
+      #The Iterations field defines the number of additional times the hash
+      #function has been performed.
+      attr_accessor :iterations
+      #The Salt Length field defines the length of the Salt field in octets,
+      #ranging in value from 0 to 255.
+      attr_reader :salt_length
+      #The Salt field is appended to the original owner name before hashing
+      #in order to defend against pre-calculated dictionary attacks.
+      attr_accessor :salt
+      
+      def hash_alg=(a)
+        if (a.instance_of?String)
+          if (a.length == 1)
+            a = a.to_i
+          end
+        end
+        begin
+          alg = Algorithms.new(a)
+          @hash_alg = alg
+        rescue ArgumentError => e
+          raise DecodeError.new(e)
+        end        
+      end
+      
+      def types=(t)
+        @types = NSEC.get_types(t)
+      end
+      
+      def flags=(f)
+        if (f==0 || f==1)
+          @flags=f
+        else
+          raise DecodeError.new("Unknown NSEC3 flags field - #{f}")
+        end
+      end
+      
+      def salt_length=(l)
+        if ((l < 0) || (l > 255))
+          raise DecodeError.new("NSEC3 salt length must be between 0 and 255")
+        end
+        @salt_length = l
+      end
+      
+      def from_data(data) #:nodoc: all
+        hash_alg, flags, iterations, salt_length, salt = data
+        self.hash_alg=(hash_alg)
+        self.flags=(flags)
+        self.iterations=(iterations)
+        self.salt_length=(salt_length)
+        self.salt=(salt)
+      end
+      
+      def from_string(input)
+        if (input.length > 0)
+          data = input.split(" ")
+          self.hash_alg=(data[0]).to_i
+          self.flags=(data[1]).to_i
+          self.iterations=(data[2]).to_i
+          self.salt=(data[3])
+          self.salt_length=(data[3].length)
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@next_hashed!=nil)
+          return "#{@hash_alg.code} #{@flags} #{@iterations} #{@salt}"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack("ccnc", @hash_alg.code, @flags, @iterations, @salt_length)
+        msg.put_bytes(@salt)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        hash_alg, flags, iterations, salt_length = msg.get_unpack("ccnc")
+        salt = msg.get_bytes(salt_length)
+        return self.new(
+          [hash_alg, flags, iterations, salt_length, salt])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/OPT.rb

@@ -0,0 +1,210 @@
+#--
+#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   
+    #Class for EDNS pseudo resource record OPT.
+    #This class is effectively internal to Dnsruby
+    #See RFC 2671, RFC 2435 Section 3
+    # @TODO@ Extended labels RFC2671 section 3
+    class OPT < RR #:nodoc: all
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::OPT #:nodoc: all
+      DO_BIT = 0x8000
+
+      #Can be called with up to 3 arguments, none of which must be present
+      #* OPT.new()
+      #* OPT.new(size)
+      #* OPT.new(size,flags)
+      #* OPT.new(size,flags,options)
+      def initialize(*args)
+        @type = Types.new('OPT')
+        @ttl = nil
+        
+        @options=nil
+        if (args.length > 0)
+          self.payloadsize=(args[0])
+          if (args.length > 1)
+            self.flags=(args[1])
+            if (args.length > 2) 
+              self.options=(args[2])
+            else
+              self.options=nil
+            end
+          else
+            self.flags=0
+          end
+        else
+          self.payloadsize=0
+        end
+      end
+      
+      # From RFC 2671 :
+      # 4.3. The fixed part of an OPT RR is structured as follows:
+      #
+      #     Field Name   Field Type     Description
+      #     ------------------------------------------------------
+      #     NAME         domain name    empty (root domain)
+      #     TYPE         u_int16_t      OPT
+      #     CLASS        u_int16_t      sender's UDP payload size
+      #     TTL          u_int32_t      extended RCODE and flags
+      #     RDLEN        u_int16_t      describes RDATA
+      #     RDATA        octet stream   {attribute,value} pairs
+      
+      #4.6. The extended RCODE and flags (which OPT stores in the RR TTL field)
+      #are structured as follows:
+      #
+      #                 +0 (MSB)                            +1 (LSB)
+      #      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+      #   0: |         EXTENDED-RCODE        |            VERSION            |
+      #      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+      #   2: |                               Z                               |
+      #      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+      #
+      #   EXTENDED-RCODE  Forms upper 8 bits of extended 12-bit RCODE.  Note
+      #                   that EXTENDED-RCODE value "0" indicates that an
+      #                   unextended RCODE is in use (values "0" through "15").
+      #
+      #   VERSION         Indicates the implementation level of whoever sets
+      #                   it.  Full conformance with this specification is
+      #                   indicated by version "0." 
+      
+      def flags_from_ttl
+        if (@ttl)
+          return [@ttl].pack("N")
+        else
+          return [0].pack("N")
+        end
+      end
+      
+      def xrcode
+        return flags_from_ttl[0, 1].unpack("C")[0]
+      end
+      
+      def xrcode=(code)
+        @ttl = (code << 24) + (version() << 16) + flags()
+      end
+      
+      def version
+        return flags_from_ttl[1, 1].unpack("C")[0]
+      end
+      
+      def version=(code)
+        @ttl = (xrcode() << 24) + (code << 16) + flags()
+      end
+      
+      def flags
+        return flags_from_ttl[2, 2].unpack("n")[0]
+      end
+      
+      def flags=(code)
+        set_flags(code)
+      end
+      
+      def set_flags(code) # Should always be zero
+        @ttl = (xrcode() << 24) + (version() << 16) + code
+      end
+      
+      def dnssec_ok
+        return ((flags() & DO_BIT) == DO_BIT)
+      end
+      
+      def dnssec_ok=(on)
+        if (on)
+          set_flags(flags() | DO_BIT)
+        else
+          set_flags(flags() & (~DO_BIT))
+        end
+      end
+      
+      def payloadsize
+        return @klass
+      end
+      
+      def payloadsize=(size)
+        self.klass=size
+      end
+      
+      def options(args)
+        if (args==nil)
+          return @options
+        elsif args.kind_of?Fixnum
+          # return list of options with that code
+          ret = []
+          @options.each do |option|
+            if (option.code == args)
+              ret.push(option)
+            end
+          end
+          return ret
+        end
+      end
+      
+      def options=(options)
+        @options = options
+      end
+      
+      def from_data(data)
+        @options = data
+      end
+      
+      def from_string(input)
+        if input
+          @options = input.split(" ")
+        end
+      end
+      
+      def to_s
+        ret = "OPT pseudo-record : #{klass.code} max UDP packet size, "
+        ret = ""
+        if @options
+          @options.each do |opt|
+            ret = ret + opt.to_s + " "
+          end
+          ret.chomp!
+        end
+        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_bytes(opt.data)
+          end
+          msg.put_array(@options)
+        end
+      end
+      
+      def self.decode_rdata(msg)#:nodoc: all
+        if (msg.has_remaining)
+          options = []
+          while (msg.has_remaining) do
+            code = msg.unpack('n')
+            len = msg.unpack('n')
+            data = msg.get_bytes(len)
+            options.add(Option.new(code, data))
+          end
+        end
+        return self.new([options])
+      end
+      
+      class Option
+        attr_accessor :code, :data
+      end
+    end
+  end
+end