dns_json 0.1.0

data/lib/dns_json/wire/writer.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module DNSJSON
+  module Wire
+    class Writer
+      def initialize(data, **limits)
+        @data = data
+        @limits = DNSJSON.validate_limits(limits)
+        @record_count = 0
+      end
+
+      def write
+        Message.new(@data, **@limits)
+        return bounded(DNSJSON.unhex(@data["messageOctetsHEX"])) if @data.key?("messageOctetsHEX")
+
+        sections = SECTIONS.map { |section| expand(@data.fetch("#{section}RRs", [])) }
+        if sections[0].empty? && (@data.key?("QNAME") || @data.key?("QNAMEHEX"))
+          sections[0] = [@data.each_with_object({}) { |(k, v), h| h[k.delete_prefix("Q")] = v if k.start_with?("Q") && k != "QDCOUNT" }]
+        end
+        raise LimitError, "record count exceeds max_records" if sections.sum(&:length) > @limits[:max_records]
+
+        id = required(@data, "ID")
+        flags = BITS.sum { |key, shift| [true, 1].include?(@data.fetch(key, 0)) ? 1 << shift : 0 }
+        flags |= @data.fetch("Opcode", 0) << 11
+        flags |= @data.fetch("RCODE", 0)
+        counts = COUNTS.each_with_index.map { |key, i| @data.fetch(key, sections[i].length) }
+        result = [id, flags, *counts].pack("n6")
+        sections.each_with_index do |records, index|
+          records.each do |record|
+            result << encode_record(record, question: index.zero?)
+            bounded(result)
+          end
+        end
+        bounded(result)
+      end
+
+      private
+
+      def bounded(bytes)
+        raise LimitError, "wire output exceeds max_bytes" if bytes.bytesize > @limits[:max_bytes]
+
+        bytes
+      end
+
+      def required(data, key)
+        raise ConversionError, "missing #{key}" unless data.key?(key)
+
+        data[key]
+      end
+
+      def expand(records)
+        records.flat_map do |record|
+          count = record.key?("rrSet") ? record["rrSet"].length : 1
+          @record_count += count
+          raise LimitError, "record count exceeds max_records" if @record_count > @limits[:max_records]
+
+          record.key?("rrSet") ? record["rrSet"].map { |entry| record.except("rrSet").merge(entry) } : [record]
+        end
+      end
+
+      def code(record, key, kind)
+        record.key?(key) ? record[key] : Registry.number(required(record, "#{key}name"), kind)
+      end
+
+      def encode_record(record, question:)
+        name = if record.key?("NAMEHEX")
+                 bytes = DNSJSON.unhex(record["NAMEHEX"])
+                 labels, size = Name.read(bytes, 0, max_pointers: 0)
+                 raise ConversionError, "excess NAMEHEX data" unless size == bytes.bytesize
+
+                 Name.pack(labels)
+               else
+                 Name.encode(required(record, "NAME"))
+               end
+        type = code(record, "TYPE", :type)
+        klass = code(record, "CLASS", :class)
+        result = name + [type, klass].pack("nn")
+        return result if question
+
+        ttl = required(record, "TTL")
+        # Prefer structured RDATA on reconstruction: captured RDATAHEX can contain obsolete compression offsets.
+        member = "rdata#{RData::FORMATS[type]}"
+        rdata = if record.key?(member)
+                  RData.encode(type, record[member])
+                else
+                  DNSJSON.unhex(required(record, "RDATAHEX"))
+                end
+        raise ConversionError, "RDATA exceeds 65535 bytes" if rdata.bytesize > 65_535
+
+        result + [ttl, record.key?(member) ? rdata.bytesize : record.fetch("RDLENGTH", rdata.bytesize)].pack("l>n") + rdata
+      end
+    end
+  end
+end

data/lib/dns_json.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "time"
+require "date"
+require "ipaddr"
+
+require_relative "dns_json/version"
+
+module DNSJSON
+  VERSION = DnsJson::VERSION
+  MEDIA_TYPE = "application/dns+json"
+  LIMITS = { max_bytes: 65_535, max_records: 4096, max_pointers: 128, max_json_bytes: 4_194_304, max_depth: 32 }.freeze
+  BITS = { "QR" => 15, "AA" => 10, "TC" => 9, "RD" => 8, "RA" => 7, "AD" => 5, "CD" => 4 }.freeze
+  SECTIONS = %w[question answer authority additional].freeze
+  COUNTS = %w[QDCOUNT ANCOUNT NSCOUNT ARCOUNT].freeze
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class ConversionError < Error; end
+  class LimitError < ParseError; end
+
+  class ValidationError < Error
+    attr_reader :pointer
+
+    def initialize(message, pointer: "")
+      @pointer = pointer
+      super("#{pointer.empty? ? "/" : pointer}: #{message}")
+    end
+  end
+  Problem = Data.define(:offset, :reason)
+  class DecimalToken
+    attr_reader :source
+
+    def initialize(source)
+      @source = source
+    end
+  end
+
+  def self.validate_limits(options)
+    raise ArgumentError, "unknown limit" unless (options.keys - LIMITS.keys).empty?
+
+    limits = LIMITS.merge(options)
+    limits.each do |name, value|
+      minimum = name == :max_depth ? 1 : 0
+      raise ArgumentError, "#{name} must be an Integer >= #{minimum}" unless value.is_a?(Integer) && value >= minimum
+    end
+    limits
+  end
+
+  def self.normalize_decimals(value, errors, pointer = "", member = nil, known: true)
+    case value
+    when Hash
+      value.to_h do |key, item|
+        child_known = known && (%w[queryMessage responseMessage compressedNAME compressedQNAME rrSet].include?(key) || SECTIONS.any? { |s| key == "#{s}RRs" })
+        path = "#{pointer}/#{key.gsub("~", "~0").gsub("/", "~1")}"
+        [key, normalize_decimals(item, errors, path, known ? key : nil, known: child_known)]
+      end
+    when Array
+      value.each_with_index.map { |item, index| normalize_decimals(item, errors, "#{pointer}/#{index}", known: known) }
+    when DecimalToken
+      errors << ValidationError.new("dateSeconds forbids signs and exponents", pointer: pointer) if member == "dateSeconds" && value.source.match?(/[eE-]/)
+      Float(value.source)
+    else value
+    end
+  end
+
+  def self.hex(bytes) = bytes.unpack1("H*").upcase
+
+  def self.unhex(text)
+    raise ConversionError, "expected uppercase even-length hexadecimal" unless text.is_a?(String) && text.match?(/\A(?:[0-9A-F]{2})*\z/)
+
+    [text].pack("H*")
+  end
+
+  def self.copy(value, depth = 0)
+    raise LimitError, "object copy exceeds safe depth" if depth > 128
+
+    case value
+    when Hash then value.to_h { |k, v| [k.dup, copy(v, depth + 1)] }
+    when Array then value.map { |v| copy(v, depth + 1) }
+    when String then value.dup
+    else value
+    end
+  end
+
+  def self.parse(source, strict: true, profile: nil, **limits)
+    raise ParseError, "JSON source must be a String" unless source.is_a?(String)
+
+    limits = validate_limits(limits)
+    raise LimitError, "JSON exceeds max_json_bytes" if source.bytesize > limits[:max_json_bytes]
+    raise ParseError, "JSON source must contain only ASCII characters" unless source.ascii_only?
+
+    data = JSON.parse(source, allow_duplicate_key: false, decimal_class: DecimalToken, max_nesting: limits[:max_depth])
+    lexical_errors = []
+    data = normalize_decimals(data, lexical_errors)
+    raise ParseError, "expected a JSON object" unless data.is_a?(Hash)
+
+    type = data.key?("queryMessage") || data.key?("responseMessage") ? Pair : Message
+    raise lexical_errors.first if strict && !lexical_errors.empty?
+
+    result = type.new(data, strict: strict, profile: profile, **limits)
+    result.warnings.concat(lexical_errors)
+    result
+  rescue JSON::ParserError, EncodingError => e
+    raise ParseError, e.message
+  end
+
+  def self.from_wire(bytes, date: nil, **limits)
+    limits = validate_limits(limits)
+    Wire::Reader.new(bytes, **limits).read(date: date)
+  end
+end
+
+require_relative "dns_json/registry"
+require_relative "dns_json/wire/name"
+require_relative "dns_json/rdata"
+require_relative "dns_json/model"
+require_relative "dns_json/profile"
+require_relative "dns_json/wire/reader"
+require_relative "dns_json/wire/writer"
+require_relative "dns_json/stream"

data/sig/dns_json.rbs

@@ -0,0 +1,89 @@
+module DnsJson
+  VERSION: String
+end
+module DNSJSON
+  VERSION: String
+  MEDIA_TYPE: String
+  type json = nil | bool | Integer | Float | String | Array[json] | Hash[String, json]
+  type object = Hash[String, json]
+  class Error < StandardError
+  end
+  class ParseError < Error
+  end
+  class ConversionError < Error
+  end
+  class LimitError < ParseError
+  end
+  class ValidationError < Error
+    attr_reader pointer: String
+    def initialize: (String, ?pointer: String) -> void
+  end
+  class Problem < Data
+    attr_reader offset: Integer
+    attr_reader reason: String
+  end
+  def self.parse: (String, ?strict: bool, ?profile: Profile?, **Integer) -> Message
+  def self.from_wire: (String, ?date: Time?, **Integer) -> Message
+  class Message
+    attr_reader problems: Array[Problem]
+    attr_reader warnings: Array[ValidationError]
+    def initialize: (?object, ?strict: bool, ?profile: Profile?, ?problems: Array[Problem], **Integer) -> void
+    def []: (String | Symbol) -> json
+    def to_h: () -> object
+    def to_json: (*untyped, ?profile: Profile) -> String
+    def to_wire: () -> String
+    def malformed?: () -> bool
+    def validate: () -> Array[ValidationError]
+    def id: () -> Integer?
+    def qname: () -> String?
+    def qtype: () -> Integer?
+    def qclass: () -> Integer?
+    def name: () -> String?
+    def type: () -> Integer?
+    def klass: () -> Integer?
+    def ttl: () -> Integer?
+    def rdlength: () -> Integer?
+    def opcode: () -> Integer?
+    def rcode: () -> Integer?
+    def qdcount: () -> Integer?
+    def ancount: () -> Integer?
+    def nscount: () -> Integer?
+    def arcount: () -> Integer?
+    def length: () -> Integer?
+  end
+  class RR < Message
+  end
+  class Pair < Message
+    def initialize: (?object, ?query: Message?, ?response: Message?, **untyped) -> void
+    def query: () -> Message?
+    def response: () -> Message?
+    def to_wire: () -> bot
+  end
+  class Profile
+    FULL: Profile
+    LOGGING: Profile
+    PRIVACY: Profile
+    def initialize: (?include: Array[Symbol], ?required: Array[String | Symbol], ?prohibited: Array[String | Symbol], ?one_bit_as: Symbol, ?privacy: bool) -> void
+    def apply: (object) -> object
+    def validate: (object) -> Array[ValidationError]
+  end
+  module Stream
+    class Writer
+      def initialize: (untyped, ?profile: Profile) -> void
+      def <<: (Message) -> Writer
+    end
+    class Reader
+      include Enumerable[Message]
+      attr_reader problems: Array[Problem]
+      attr_reader dropped_problems: Integer
+      def initialize: (untyped, ?strict: bool, ?max_json_bytes: Integer, ?max_problems: Integer, **untyped) -> void
+      def each: () { (Message) -> void } -> Reader
+              | () -> Enumerator[Message, Reader]
+    end
+  end
+  module Registry
+    def self.type: (Integer) -> String
+    def self.klass: (Integer) -> String
+    def self.number: (String, ?Symbol) -> Integer
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: dns_json
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Bounded tolerant DNS wire parsing, RFC 8427 JSON conversion, RDATA codecs,
+  profiles, and JSON text sequences.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- SECURITY.md
+- data/properties.yml
+- data/rdata_formats.yml
+- data/rr_types.yml
+- lib/dns_json.rb
+- lib/dns_json/model.rb
+- lib/dns_json/profile.rb
+- lib/dns_json/rdata.rb
+- lib/dns_json/registry.rb
+- lib/dns_json/stream.rb
+- lib/dns_json/version.rb
+- lib/dns_json/wire/name.rb
+- lib/dns_json/wire/reader.rb
+- lib/dns_json/wire/writer.rb
+- sig/dns_json.rbs
+homepage: https://github.com/ydah/dns_json
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/ydah/dns_json
+  changelog_uri: https://github.com/ydah/dns_json/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Read and write DNS messages as RFC 8427 JSON
+test_files: []