dnsruby 1.73.1 → 2.0.0

data/lib/dnsruby/resource/CAA.rb

@@ -16,26 +16,28 @@
 module Dnsruby
   class RR
     # Class for CAA resource records.
-    # RFC 6844
+    # RFC 8659
     class CAA < RR
       ClassValue = nil #:nodoc: all
       TypeValue= Types::CAA #:nodoc: all
 
-      # The property tag for the record (issue|issuewild|issuemail|issuevmc|iodef|contactemail|contactphone)
+      # The property tag. Tags are extensible ASCII letters and digits.
       attr_accessor :property_tag
       # The value for the property_tag
       attr_accessor :property_value
       # The value for the flag
-      attr_writer :flag
+      def flag=(value)
+        @flag = value.to_i
+      end
 
       def from_hash(hash) #:nodoc: all
-        @property_tag = hash[:property_tag]
-        @property_value = hash[:property_value]
-        @flag = hash[:flag]
+        from_data([hash[:flag], hash[:property_tag], hash[:property_value]])
       end
 
       def from_data(data) #:nodoc: all
-        @flag, @property_tag, @property_value = data
+        flag, @property_tag, @property_value = data
+        self.flag = flag
+        validate_fields
       end
 
       def flag
@@ -43,20 +45,31 @@ module Dnsruby
       end
 
       def from_string(input) #:nodoc: all
-        matches = (/(\d+) (issuewild|issuemail|issuevmc|issue|iodef|contactemail|contactphone) "(.+)"$/i).match(input)
-        if matches.nil?
-          raise DecodeError.new("Cannot parse record: #{input[0...1000]}")
-        end
-        @flag = matches[1]
-        @property_tag = matches[2]
-        @property_value = matches[3]
+        # A CAA value is one character-string, with no 255-octet limit.
+        matches = /\A\s*(\d+)\s+([A-Za-z0-9]+)\s+("(?:\\.|[^"\\])*"|(?:\\.|[^\s"\\])+)\s*\z/m.match(input.b)
+        raise DecodeError, "Cannot parse CAA record: #{input[0...1000]}" unless matches
+
+        value = matches[3]
+        value = value[1...-1] if value.start_with?('"')
+        from_data([matches[1], matches[2], decode_value(value)])
       end
 
       def rdata_to_string #:nodoc: all
-        "#{flag} #{@property_tag} \"#{@property_value}\""
+        value = +''.b
+        @property_value.each_byte do |octet|
+          if octet == 34 || octet == 92
+            value << 92 << octet
+          elsif octet < 32 || octet > 126
+            value << format('\\%03d', octet)
+          else
+            value << octet
+          end
+        end
+        "#{flag} #{@property_tag} \"#{value}\""
       end
 
       def encode_rdata(msg, canonical=false) #:nodoc: all
+        validate_fields
         msg.put_pack('C', flag)
         msg.put_string(@property_tag)
         # We don't put a length byte on the final string.
@@ -68,8 +81,46 @@ module Dnsruby
         property_tag = msg.get_string
         # The final string has no length byte - its length is implicit as the remainder of the packet length
         property_value = msg.get_bytes
-        return self.new("#{flag} #{property_tag} \"#{property_value}\"")
+        record = self.new([flag, property_tag, property_value])
+        # Keep the public construction-time rdata String used by Comparable
+        # and older serializers, without reparsing arbitrary wire value bytes.
+        record.rdata = record.rdata_to_string
+        record
+      end
+
+      def validate_fields
+        unless (0..255).cover?(flag) && @property_tag.is_a?(String) &&
+            @property_tag.bytesize.between?(1, 255) && /\A[A-Za-z0-9]+\z/n.match?(@property_tag.b) &&
+            @property_value.is_a?(String)
+          raise DecodeError, 'CAA requires an octet flag, an alphanumeric tag and a string value'
+        end
+      end
+      private :validate_fields
+
+      def decode_value(value)
+        decoded = +''.b
+        index = 0
+        while index < value.bytesize
+          octet = value.getbyte(index)
+          if octet == 92
+            index += 1
+            octet = value.getbyte(index)
+            raise DecodeError, 'Incomplete CAA value escape' unless octet
+            if (48..57).cover?(octet)
+              digits = value.byteslice(index, 3)
+              unless /\A[0-9]{3}\z/.match?(digits) && digits.to_i <= 255
+                raise DecodeError, 'CAA decimal escapes must specify one octet with three digits'
+              end
+              octet = digits.to_i
+              index += 2
+            end
+          end
+          decoded << octet
+          index += 1
+        end
+        decoded
       end
+      private :decode_value
     end
   end
 end

data/lib/dnsruby/resource/DLV.rb

@@ -22,6 +22,12 @@ module Dnsruby
      class DLV < RR::DS
        ClassValue = nil #:nodoc: all
        TypeValue = Types::DLV #:nodoc: all
+
+       # DLV owners are names within the lookaside registry, rather than the
+       # DNSKEY owner used in the digest. Keep that legacy distinction explicit.
+       def check_key(key)
+         key.type == Types.DNSKEY && key.klass == klass && matching_key_digest?(key)
+       end
      end
    end
 end

data/lib/dnsruby/resource/DNSKEY.rb

@@ -77,6 +77,7 @@ module Dnsruby
         begin
           alg = Algorithms.new(a)
           @algorithm = alg
+          @public_key = @key_length = nil
         rescue ArgumentError => e
           raise DecodeError.new(e)
         end
@@ -207,13 +208,13 @@ 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.code)
+        msg.put_pack('nCC', @flags, @protocol, @algorithm.code)
         msg.put_bytes(@key)
       end
 
       def self.decode_rdata(msg) #:nodoc: all
         #  2 octets, then 2 sets of 1 octet
-        flags, protocol, algorithm = msg.get_unpack('ncc')
+        flags, protocol, algorithm = msg.get_unpack('nCC')
         key = msg.get_bytes
         return self.new(
           [flags, protocol, algorithm, key])
@@ -292,9 +293,8 @@ module Dnsruby
 
       def key=(key_text)
         begin
-          key_text.gsub!(/\n/, "")
-          key_text.gsub!(/ /, "")
-          @key=Base64.decode64(key_text)
+          @key=Base64.decode64(key_text.delete("\n "))
+          @public_key = @key_length = nil
           public_key
           get_new_key_tag
         rescue Exception => e
@@ -315,31 +315,121 @@ module Dnsruby
             @public_key = dsa_key
           elsif [Algorithms.ECDSAP256SHA256, Algorithms.ECDSAP384SHA384].include?(@algorithm)
             @public_key = ec_key(Algorithms.ECDSAP256SHA256 == @algorithm ? 'prime256v1' : 'secp384r1')
+          elsif @algorithm == Algorithms.ED25519 && DNSKEY.ed25519_supported?
+            @public_key = ed25519_key
+          elsif @algorithm == Algorithms.ED448 && DNSKEY.ed448_supported?
+            @public_key = ed448_key
           end
         end
         #  @TODO@ Support other key encodings!
         return @public_key
       end
 
-      def rsa_key
-        exponentLength = @key[0]
-        if (exponentLength.class == String)
-          exponentLength = exponentLength.getbyte(0) # Ruby 1.9
+      # Check the actual provider as well as Ruby's OpenSSL API. Parsing a
+      # public key alone does not guarantee that signature verification works.
+      def self.ed25519_supported? #:nodoc:
+        return @ed25519_supported if defined?(@ed25519_supported)
+        return false unless defined?(OpenSSL::PKey)
+        public_bytes = ['d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a'].pack('H*')
+        signature = ['e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e06522490155' \
+          '5fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b'].pack('H*')
+        # RFC 8032 section 7.1, test 1 (the empty message).
+        key = OpenSSL::PKey.read(ed25519_subject_public_key(public_bytes))
+        @ed25519_supported = key.verify(nil, signature, ''.b)
+      rescue OpenSSL::OpenSSLError, NotImplementedError, TypeError, ArgumentError
+        @ed25519_supported = false
+      end
+
+      def self.ed25519_subject_public_key(bytes) #:nodoc:
+        # RFC 8410 SubjectPublicKeyInfo: Ed25519's algorithm has no parameters.
+        OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::ObjectId.new('1.3.101.112')]),
+          OpenSSL::ASN1::BitString.new(bytes)
+        ]).to_der
+      end
+      private_class_method :ed25519_subject_public_key
+
+      def ed25519_key
+        unless @key.bytesize == 32
+          raise OpenSSL::PKey::PKeyError, 'Ed25519 DNSKEY must contain 32 octets'
+        end
+        @key_length = 256
+        OpenSSL::PKey.read(DNSKEY.send(:ed25519_subject_public_key, @key))
+      end
+
+      def self.ed448_supported? #:nodoc:
+        return @ed448_supported if defined?(@ed448_supported)
+        return false unless defined?(OpenSSL::PKey)
+        # RFC 8032 section 7.4, the empty-message test vector.
+        public_bytes = ['5fd7449b59b461fd2ce787ec616ad46a' \
+          '1da1342485a70e1f8a0ea75d80e96778' \
+          'edf124769b46c7061bd6783df1e50f6c' \
+          'd1fa1abeafe8256180'].pack('H*')
+        signature = ['533a37f6bbe457251f023c0d88f976ae' \
+          '2dfb504a843e34d2074fd823d41a591f' \
+          '2b233f034f628281f2fd7a22ddd47d78' \
+          '28c59bd0a21bfd3980ff0d2028d4b18a' \
+          '9df63e006c5d1c2d345b925d8dc00b41' \
+          '04852db99ac5c7cdda8530a113a0f4db' \
+          'b61149f05a7363268c71d95808ff2e65' \
+          '2600'].pack('H*')
+        key = OpenSSL::PKey.read(ed448_subject_public_key(public_bytes))
+        @ed448_supported = key.verify(nil, signature, ''.b)
+      rescue OpenSSL::OpenSSLError, NotImplementedError, TypeError, ArgumentError
+        @ed448_supported = false
+      end
+
+      def self.ed448_subject_public_key(bytes) #:nodoc:
+        # RFC 8410: Ed448, like Ed25519, has no algorithm parameters.
+        OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::ObjectId.new('1.3.101.113')]),
+          OpenSSL::ASN1::BitString.new(bytes)
+        ]).to_der
+      end
+      private_class_method :ed448_subject_public_key
+
+      def ed448_key
+        unless @key.bytesize == 57
+          raise OpenSSL::PKey::PKeyError, 'Ed448 DNSKEY must contain 57 octets'
         end
+        @key_length = 448
+        OpenSSL::PKey.read(DNSKEY.send(:ed448_subject_public_key, @key))
+      end
+
+      def rsa_key
+        exponentLength = @key.getbyte(0)
         pos = 1
         if (exponentLength == 0)
-          key1 = @key[1]
-          if (key1.class == String) # Ruby 1.9
-            key1 = key1.getbyte(0)
+          if @key.bytesize < 3
+            raise OpenSSL::PKey::PKeyError, "Truncated RSA DNSKEY exponent length"
+          end
+          exponentLength = @key.byteslice(1, 2).unpack1('n')
+          if exponentLength < 256
+            raise OpenSSL::PKey::PKeyError, "Noncanonical RSA DNSKEY exponent length"
           end
-          exponentLength = (key1<<8) + key1
           pos += 2
         end
+        if !exponentLength || exponentLength == 0 || @key.bytesize <= pos + exponentLength
+          raise OpenSSL::PKey::PKeyError, "Truncated RSA DNSKEY exponent or modulus"
+        end
+        # RFC 3110 section 2 limits both integers to 4096 bits and forbids
+        # leading zero octets. Check bytes before constructing OpenSSL BNs.
+        modulus_length = @key.bytesize - pos - exponentLength
+        if exponentLength > 512 || modulus_length > 512 ||
+            @key.getbyte(pos) == 0 || @key.getbyte(pos + exponentLength) == 0
+          raise OpenSSL::PKey::PKeyError, "Invalid RSA DNSKEY integer encoding or size"
+        end
+        bits = (modulus_length - 1) * 8 + @key.getbyte(pos + exponentLength).bit_length
+        # RFC 3110 section 3 and RFC 5702 section 2 define modulus minima.
+        minimum = @algorithm == Algorithms.RSASHA512 ? 1024 : 512
+        if bits < minimum
+          raise OpenSSL::PKey::PKeyError, "RSA DNSKEY modulus must be at least #{minimum} bits"
+        end
         exponent = RR::get_num(@key[pos, exponentLength])
         pos += exponentLength
 
         modulus = RR::get_num(@key[pos, @key.length])
-        @key_length = (@key.length - pos) * 8
+        @key_length = bits
 
         data_sequence = OpenSSL::ASN1::Sequence([
                                                   OpenSSL::ASN1::Integer(modulus),
@@ -351,8 +441,10 @@ module Dnsruby
       end
 
       def dsa_key
-        t = @key[0]
-        t = t.getbyte(0) if t.class == String
+        t = @key.getbyte(0)
+        if !t || t > 8 || @key.bytesize != 21 + 3 * (t * 8 + 64)
+          raise OpenSSL::PKey::PKeyError, "Invalid DSA DNSKEY length"
+        end
         pgy_len = t * 8 + 64
         pos = 1
         q = RR::get_num(@key[pos, 20])

data/lib/dnsruby/resource/DS.rb

@@ -75,13 +75,10 @@ module Dnsruby
       end
 
       def DS.get_digest_type(d)
-        if (d.instance_of?String)
-          if (d.length == 1)
-            d = d.to_i
-          end
-        end
+        d = d.to_i if d.is_a?(String) && /\A[0-9]+\z/.match?(d)
         begin
           digest = DigestTypes.new(d)
+          raise ArgumentError, 'DS digest type must fit in an unsigned octet' unless (0..255).cover?(digest.code)
           return digest
         rescue ArgumentError => e
           raise DecodeError.new(e)
@@ -89,13 +86,10 @@ module Dnsruby
       end
 
       def algorithm=(a)
-        if (a.instance_of?String)
-          if (a.length < 3)
-            a = a.to_i
-          end
-        end
+        a = a.to_i if a.is_a?(String) && /\A[0-9]+\z/.match?(a)
         begin
           alg = Algorithms.new(a)
+          raise ArgumentError, 'DS algorithm must fit in an unsigned octet' unless (0..255).cover?(alg.code)
           @algorithm = alg
         rescue ArgumentError => e
           raise DecodeError.new(e)
@@ -130,24 +124,30 @@ module Dnsruby
 
       end
 
-      #  Check if the key's digest is the same as that stored in the DS record
+      # A DS binds both the DNSKEY's identity and its public-key digest.
       def check_key(key)
-        if ((key.key_tag == @key_tag) && (key.algorithm == @algorithm))
+        key.type == Types.DNSKEY && key.klass == klass && key.name.canonical == name.canonical &&
+          matching_key_digest?(key)
+      end
 
-          digestbin = digest_key(key)
-          if (@digestbin == digestbin)
-            if (!key.zone_key?)
-            else
-              return true
-            end
-          else
-          end
-        end
-        return false
+      def matching_key_digest?(key)
+        key.zone_key? && key.key_tag == @key_tag && key.algorithm == @algorithm &&
+          !@digestbin.nil? && @digestbin == digest_key(key)
       end
+      protected :matching_key_digest?
 
 
-      def DS.from_key(key, digest_type)
+      # Create a DS for current delegation use. Historical records can still
+      # be decoded and checked with digest_key/check_key, but RFC 9905 prohibits
+      # new SHA-1 delegations and DS records for RSA/SHA-1 signing keys.
+      def DS.from_key(key, digest_type = 2)
+        if [Algorithms.RSASHA1, Algorithms.RSASHA1_NSEC3_SHA1].include?(key.algorithm)
+          raise ArgumentError, "RFC 9905 prohibits creating DS records for RSA/SHA-1 keys"
+        end
+        digest_type = get_digest_type(digest_type)
+        if digest_type.code == 1
+          raise ArgumentError, "RFC 9905 prohibits SHA-1 for new DS delegations; use SHA-256 or SHA-384"
+        end
 # # The key must not be a NULL key.
 #    if ((key.flags & 0xc000 ) == 0xc000 )
 # 	puts "\nCreating a DS record for a NULL key is illegal"
@@ -175,9 +175,8 @@ module Dnsruby
 #          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,
+        ds = RR.create(:name => key.name, :type => "DS", :klass => key.klass, :ttl => key.ttl,
                       :key_tag => key.key_tag,
                      :digest_type => digest_type, :algorithm => key.algorithm)
 
@@ -238,16 +237,16 @@ module Dnsruby
       end
 
       def encode_rdata(msg, canonical=false) #:nodoc: all
-        msg.put_pack("ncc", @key_tag, @algorithm.code, @digest_type.code)
+        msg.put_pack("nCC", @key_tag, @algorithm.code, @digest_type.code)
         msg.put_bytes(@digestbin)
       end
 
       def self.decode_rdata(msg) #:nodoc: all
-        key_tag, algorithm, digest_type = msg.get_unpack("ncc")
+        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
+end

data/lib/dnsruby/resource/HTTPS.rb

@@ -0,0 +1,16 @@
+require 'dnsruby/resource/SVCB'
+
+module Dnsruby
+  class RR
+    # Class for DNS HTTPS resource records.
+    #
+    # RFC 9460 sec 9
+    #
+    # The HTTPS-specific instantiation of the SVCB record, sharing its wire and
+    # presentation formats, for the "https" and "http" URI schemes.
+    class HTTPS < SVCB
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::HTTPS #:nodoc: all
+    end
+  end
+end

data/lib/dnsruby/resource/IN.rb

@@ -74,6 +74,25 @@ module Dnsruby
         self.const_set(s.name.sub(/.*::/, ''), c)
       }
 
+      # RFC 9460 defines these formats only for class IN. Other ordinary
+      # classes must retain their opaque RDATA through the generic fallback.
+      class SVCB < RR::SVCB
+        ClassHash[[TypeValue = Types::SVCB, ClassValue = ClassValue]] = self #:nodoc: all
+      end
+
+      class HTTPS < RR::HTTPS
+        ClassHash[[TypeValue = Types::HTTPS, ClassValue = ClassValue]] = self #:nodoc: all
+      end
+
+      # RFC 2136 uses ANY/NONE as UPDATE markers, not as an RDATA format.
+      # Keep the IN codec (including empty deletes/prerequisites), with the
+      # actual class stored on the record, just as Update#delete does.
+      [SVCB, HTTPS].each do |record_class|
+        [Classes::ANY, Classes::NONE].each do |update_class|
+          ClassHash[[record_class::TypeValue, update_class]] = record_class
+        end
+      end
+
       #  RFC 1035, Section 3.4.2 (deprecated)
       class WKS < RR
         ClassHash[[TypeValue = Types::WKS, ClassValue = ClassValue]] = self  #:nodoc: all
@@ -87,13 +106,13 @@ module Dnsruby
 
         def encode_rdata(msg, canonical=false) #:nodoc: all
           msg.put_bytes(@address.address)
-          msg.put_pack("n", @protocol)
+          msg.put_pack("C", @protocol)
           msg.put_bytes(@bitmap)
         end
 
         def self.decode_rdata(msg) #:nodoc: all
           address = IPv4.new(msg.get_bytes(4))
-          protocol, = msg.get_unpack("n")
+          protocol, = msg.get_unpack("C")
           bitmap = msg.get_bytes
           return self.new(address, protocol, bitmap)
         end

data/lib/dnsruby/resource/MX.rb

@@ -37,7 +37,7 @@ module Dnsruby
 
       def from_string(input) #:nodoc: all
         if (input.length > 0)
-          names = input.split(" ")
+          names = Presentation.tokens(input)
           if(names.size != 2)
             raise DecodeError.new("MX record expects preference and domain")
           end
@@ -66,4 +66,4 @@ module Dnsruby
       end
     end
   end
-end
+end

data/lib/dnsruby/resource/NSEC.rb

@@ -236,14 +236,10 @@ module Dnsruby
 
       def from_string(input)
         if input.length > 0
-          data = input.split(' ')
-          self.next_domain = data[0]
-          len = data[0].length+ 1
-          if data[1] == '('
-            len += data[1].length
-          end
-          self.types = input[len, input.length-len]
-          @types = NSEC.get_types(input[len, input.length-len])
+          data = Presentation.tokens(input)
+          self.next_domain = data.shift
+          data.shift if data.first == '('
+          self.types = data.join(' ')
         end
       end
 
@@ -260,7 +256,7 @@ module Dnsruby
 
       def encode_rdata(msg, canonical=false) #:nodoc: all
         #  Canonical
-        msg.put_name(@next_domain, canonical, false) # dnssec-bis-updates says NSEC should not be downcased
+        msg.put_name(@next_domain, true, false) # dnssec-bis-updates says NSEC should not be downcased
         types = encode_types
         msg.put_bytes(types)
       end
@@ -272,4 +268,4 @@ module Dnsruby
       end
     end
   end
-end
+end

data/lib/dnsruby/resource/NSEC3.rb

@@ -90,14 +90,46 @@ module Dnsruby
       # NSEC RR's owner name
       attr_reader :types
 
-      def check_name_in_range(_name)
-        #  @TODO@ Check if the name is covered by this record
-        false
+      # A hash interval proves absence, while equality proves existence. Keep
+      # these operations separate: an interval's bitmap describes its owner,
+      # never a name merely covered by the interval (RFC 5155 sections 8.3-8.7).
+      def supported_parameters? # :nodoc:
+        @hash_alg == Nsec3HashAlgorithms.SHA_1 && [0, 1].include?(@flags)
       end
 
-      def check_name_in_wildcard_range(_name)
-        #  @TODO@ Check if the name is covered by this record
-        false
+      def usable_hash? # :nodoc:
+        supported_parameters? &&
+          @iterations.is_a?(Integer) && @iterations.between?(0, 65_535) &&
+          @next_hashed.is_a?(String) && @next_hashed.bytesize == 20 &&
+          /\A[0-9a-v]{32}\z/.match?(owner_hash)
+      end
+
+      def owner_hash # :nodoc:
+        @name.labels.first.to_s.downcase
+      end
+
+      def hash_name(name) # :nodoc:
+        NSEC3.calculate_hash(name, @iterations, @salt, @hash_alg)
+      end
+
+      def covers_hash?(hashed) # :nodoc:
+        return false unless usable_hash?
+        first, following = owner_hash, NSEC3.encode_next_hashed(@next_hashed)
+        return false if hashed == first || hashed == following
+        first < following ? first < hashed && hashed < following : first < hashed || hashed < following
+      end
+
+      def check_name_in_range(name)
+        candidate = Name.create(name)
+        zone = @name.strip_label
+        usable_hash? && (candidate == zone || candidate.subdomain_of?(zone)) && covers_hash?(hash_name(candidate))
+      end
+
+      # The closest encloser must be established by the complete proof before
+      # checking its literal wildcard name; one NSEC3 cannot discover it alone.
+      def check_name_in_wildcard_range(name)
+        candidate = Name.create(name)
+        candidate.wild? && check_name_in_range(candidate)
       end
 
       def calculate_hash
@@ -138,7 +170,12 @@ module Dnsruby
         n = Name.create(name)
         out = n.canonical
         begin
-          (iterations + 1).times { out = NSEC3.h(out + salt, hash_alg) }
+          budget = ValidationBudget.current
+          budget&.check!(iterations + 1)
+          (iterations + 1).times do |iteration|
+            budget&.check! if iteration % 64 == 0
+            out = NSEC3.h(out + salt, hash_alg)
+          end
           return Base32.encode32hex(out).downcase
         rescue ArgumentError
           TheLog.error("Unknown hash algorithm #{hash_alg} used for NSEC3 hash")
@@ -181,11 +218,12 @@ module Dnsruby
 
       OPT_OUT = 1
       def flags=(f)
-        if f == 0 || f == OPT_OUT
-          @flags = f
-        else
-          raise DecodeError.new("Unknown NSEC3 flags field - #{f}")
+        unless f.is_a?(Integer) && f.between?(0, 255)
+          raise DecodeError, "NSEC3 flags must be an octet: #{f}"
         end
+        # Preserve future flags on decode. Validators ignore unsupported
+        # records under RFC 5155 section 8.2 instead of rejecting the message.
+        @flags = f
       end
 
       # If the Opt-Out flag is set, the NSEC3 record covers zero or more
@@ -216,6 +254,7 @@ module Dnsruby
 #        self.salt_length=(salt_length)
 #        self.salt=(salt)
         @salt = salt
+        @salt_length = salt.bytesize
         self.hash_length = hash_length
         self.next_hashed = next_hashed
         self.types = types
@@ -301,27 +340,24 @@ module Dnsruby
 #        s = salt()
         s = @salt
         sl = s.length
-        if s == '-'
-          sl = 0
-        end
-        msg.put_pack('ccnc', @hash_alg.code, @flags, @iterations, sl)
+        msg.put_pack('CCnC', @hash_alg.code, @flags, @iterations, sl)
         if sl > 0
           msg.put_bytes(s)
         end
-        msg.put_pack('c', @hash_length)
+        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')
+        hash_alg, flags, iterations, salt_length = msg.get_unpack('CCnC')
         #  Salt may be omitted
-        salt = []
+        salt = ''.b
         if salt_length > 0
           salt = msg.get_bytes(salt_length)
         end
-        hash_length, = msg.get_unpack('c')
+        hash_length, = msg.get_unpack('C')
         next_hashed = msg.get_bytes(hash_length)
         types = NSEC.decode_types(msg.get_bytes)
         return self.new(