nesser 0.0.1

data/lib/nesser/packets/packer.rb

@@ -0,0 +1,97 @@
+# Encoding: ASCII-8BIT
+##
+# packer.rb
+# Created June 20, 2017
+# By Ron Bowes
+#
+# See: LICENSE.md
+#
+# DNS has some unusual properties that we have to handle, which is why I
+# wrote this class. It handles building / parsing DNS packets and keeping
+# track of where in the packet we currently are. The advantage, besides
+# simpler unpacking, is that encoded names (with pointers to other parts
+# of the packet) can be trivially handled.
+##
+
+require 'nesser/dns_exception'
+require 'nesser/packets/constants'
+
+module Nesser
+  class Packer
+    public
+    def initialize()
+      @data = ''
+      @segment_cache = {}
+    end
+
+    public
+    def pack(format, *data)
+      @data += data.pack(format)
+    end
+
+    private
+    def validate!(name)
+      if name.chars.detect { |ch| !LEGAL_CHARACTERS.include?(ch) }
+        raise(FormatException, "DNS name contains illegal characters")
+      end
+      if name.length > 253
+        raise(FormatException, "DNS name can't be longer than 253 characters")
+      end
+      name.split(/\./).each do |segment|
+        if segment.length == 0 || segment.length > 63
+          raise(FormatException, "DNS segments must be between 1 and 63 characters!")
+        end
+      end
+    end
+
+    # Take a name, as a dotted string ("google.com") and return it as length-
+    # prefixed segments ("\x06google\x03com\x00"). It also does a pointer
+    # (\xc0\xXX) when possible!
+    public
+    def pack_name(name, dry_run:false, compress:true)
+      length = 0
+      validate!(name)
+
+      # `name` becomes nil at the end, unless there's a comma on the end, in
+      # which case it's a 0-length string
+      while name and name.length() > 0
+        if compress && @segment_cache[name]
+          # User a pointer if we've already done this
+          if not dry_run
+            @data += [0xc000 | @segment_cache[name]].pack("n")
+          end
+
+          # If we use break here, we get a bad NUL terminator
+          return length + 2
+        end
+
+        # Log where we put this segment
+        if not dry_run
+          @segment_cache[name] = @data.length
+        end
+
+        # Get the next label
+        segment, name = name.split(/\./, 2)
+
+        # Encode it into the string
+        if not dry_run
+          @data += [segment.length(), segment].pack("Ca*")
+        end
+        length += 1 + segment.length()
+      end
+
+      # Always be null terminating
+      if not dry_run
+        @data += "\0"
+      end
+      length += 1
+
+      return length
+    end
+
+    public
+    def get()
+      return @data
+    end
+  end
+end

data/lib/nesser/packets/packet.rb

@@ -0,0 +1,186 @@
+# Encoding: ASCII-8BIT
+##
+# packet.rb
+# Created June 20, 2017
+# By Ron Bowes
+#
+# See: LICENSE.md
+##
+
+require 'nesser/dns_exception'
+require 'nesser/packets/answer'
+require 'nesser/packets/constants'
+require 'nesser/packets/packer'
+require 'nesser/packets/question'
+require 'nesser/packets/rr_types'
+require 'nesser/packets/unpacker'
+
+module Nesser
+  class Packet
+    attr_accessor :trn_id, :qr, :opcode, :flags, :rcode, :questions, :answers
+
+    def initialize(trn_id:, qr:, opcode:, flags:, rcode:, questions:[], answers:[])
+      @trn_id    = trn_id
+      @qr        = qr
+      @opcode    = opcode
+      @flags     = flags
+      @rcode     = rcode
+
+      questions.each { |q| raise(DnsException, "Questions must be of type Answer!") if !q.is_a?(Question) }
+      @questions = questions
+
+      answers.each { |a| raise(DnsException, "Answers must be of type Answer!") if !a.is_a?(Answer) }
+      @answers   = answers
+    end
+
+    def add_question(question)
+      if !question.is_a?(Question)
+        raise(DnsException, "Questions must be of type Question!")
+      end
+
+      @questions << question
+    end
+
+    def add_answer(answer)
+      if !answer.is_a?(Answer)
+        raise(DnsException, "Questions must be of type Question!")
+      end
+
+      @answers << answer
+    end
+
+    def self.parse(data)
+      unpacker = Unpacker.new(data)
+      trn_id, full_flags, qdcount, ancount, _, _ = unpacker.unpack("nnnnnn")
+
+      qr     = (full_flags >> 15) & 0x0001
+      opcode = (full_flags >> 11) & 0x000F
+      flags  = (full_flags >> 7)  & 0x000F
+      rcode  = (full_flags >> 0)  & 0x000F
+
+      packet = self.new(
+        trn_id: trn_id,
+        qr: qr,
+        opcode: opcode,
+        flags: flags,
+        rcode: rcode,
+        questions: [],
+        answers: [],
+      )
+
+      0.upto(qdcount - 1) do
+        question = Question.unpack(unpacker)
+        packet.add_question(question)
+      end
+
+      0.upto(ancount - 1) do
+        answer = Answer.unpack(unpacker)
+        packet.add_answer(answer)
+      end
+
+      return packet
+    end
+
+    def answer(answers:[], question:nil)
+      question = question || @questions[0]
+
+      return Packet.new(
+        trn_id: @trn_id,
+        qr: QR_RESPONSE,
+        opcode: OPCODE_QUERY,
+        flags: FLAG_RD | FLAG_RA,
+        rcode: RCODE_SUCCESS,
+        questions: [question],
+        answers: answers,
+      )
+    end
+
+    def error(rcode:, question:nil)
+      question = question || @questions[0]
+
+      return Packet.new(
+        trn_id: @trn_id,
+        qr: QR_RESPONSE,
+        opcode: OPCODE_QUERY,
+        flags: FLAG_RD | FLAG_RA,
+        rcode: rcode,
+        questions: [question],
+        answers: [],
+      )
+    end
+
+    def to_bytes()
+      packer = Packer.new()
+
+      full_flags = ((@qr     << 15) & 0x8000) |
+                   ((@opcode << 11) & 0x7800) |
+                   ((@flags  <<  7) & 0x0780) |
+                   ((@rcode  <<  0) & 0x000F)
+
+      packer.pack('nnnnnn',
+        @trn_id,             # trn_id
+        full_flags,          # qr, opcode, flags, rcode
+        @questions.length(), # qdcount
+        @answers.length(),   # ancount
+        0,                   # nscount (we don't handle)
+        0,                   # arcount (we don't handle)
+      )
+
+      questions.each do |q|
+        q.pack(packer)
+      end
+
+      answers.each do |a|
+        a.pack(packer)
+      end
+
+      return packer.get()
+    end
+
+    def to_s(brief:false)
+      if(brief)
+        question = @questions[0] || '<unknown>'
+
+        # Print error packets more clearly
+        if(@rcode != RCODE_SUCCESS)
+          return "Request for #{question}: error: #{RCODES[@rcode]}"
+        end
+
+        if(@qr == QR_QUERY)
+          return "Request for #{question}"
+        else
+          if(@answers.length == 0)
+            return "Response for %s: n/a" % question.to_s
+          else
+            return "Response for %s: %s (and %d others)" % [
+              question.to_s(),
+              @answers[0].to_s(),
+              @answers.length - 1,
+            ]
+          end
+        end
+      end
+
+      results = []
+      results << "DNS %s: id=0x%04x, opcode = %s, flags = %s, rcode = %s, qdcount = 0x%04x, ancount = 0x%04x" % [
+        QRS[@qr] || "unknown",
+        @trn_id,
+        OPCODES[@opcode] || "unknown opcode",
+        Nesser::FLAGS(@flags),
+        RCODES[@rcode] || "unknown",
+        @questions.length,
+        @answers.length,
+      ]
+
+      @questions.each do |q|
+        results << "    Question: %s" % q.to_s()
+      end
+
+      @answers.each do |a|
+        results << "    Answer: %s" % a.to_s()
+      end
+
+      return results.join("\n")
+    end
+  end
+end

data/lib/nesser/packets/question.rb

@@ -0,0 +1,43 @@
+# Encoding: ASCII-8BIT
+##
+# question.rb
+# Created June 21, 2017
+# By Ron Bowes
+#
+# See: LICENSE.md
+#
+# This defines a DNS question. One question is sent in outgoing packets,
+# and one question is also sent in the response - generally, the same as
+# the question that was asked.
+##
+module Nesser
+  class Question
+    attr_reader :name, :type, :cls
+
+    def initialize(name:, type:, cls:)
+      @name  = name
+      @type  = type
+      @cls  = cls
+    end
+
+    def self.unpack(unpacker)
+      name = unpacker.unpack_name()
+      type, cls = unpacker.unpack("nn")
+
+      return self.new(name: name, type: type, cls: cls)
+    end
+
+    def pack(packer)
+      packer.pack_name(@name)
+      packer.pack('nn', type, cls)
+    end
+
+    def to_s()
+      return '%s [%s %s]' % [
+        @name,
+        TYPES[@type] || '<0x%04x?>' % @type,
+        CLSES[@cls]  || '<0x%04x?>' % @cls,
+      ]
+    end
+  end
+end

data/lib/nesser/packets/rr_types.rb

@@ -0,0 +1,290 @@
+# Encoding: ASCII-8BIT
+##
+# types.rb
+# Created June 20, 2017
+# By Ron Bowes
+#
+# See: LICENSE.md
+##
+
+require 'ipaddr'
+
+require 'nesser/packets/constants'
+require 'nesser/dns_exception'
+require 'nesser/packets/packer'
+require 'nesser/packets/unpacker'
+
+module Nesser
+  class A
+    attr_accessor :address
+
+    def initialize(address:)
+      if !address.is_a?(String)
+        raise(FormatException, "String required!")
+      end
+
+      begin
+        @address = IPAddr.new(address)
+      rescue IPAddr::InvalidAddressError => e
+        raise(FormatException, "Invalid address: %s" % e)
+      end
+
+      if !@address.ipv4?()
+        raise(FormatException, "IPv4 address required!")
+      end
+    end
+
+    def self.unpack(unpacker)
+      length = unpacker.unpack_one('n')
+      if length != 4
+        raise(FormatException, "Invalid A record!")
+      end
+
+      data = unpacker.unpack('a4').join()
+      return self.new(address: IPAddr.ntop(data))
+    end
+
+    def pack(packer)
+      packer.pack('n', 4) # length
+      packer.pack('C4', *@address.hton().bytes())
+    end
+
+    def to_s()
+      return "#{@address} [A]"
+    end
+  end
+
+  class NS
+    attr_accessor :name
+
+    def initialize(name:)
+      @name = name
+    end
+
+    def self.unpack(unpacker)
+      # We don't really need the name for anything, so just discard it
+      unpacker.unpack('n')
+
+      return self.new(name: unpacker.unpack_name())
+    end
+
+    def pack(packer)
+      length = packer.pack_name(@name, dry_run: true)
+      packer.pack('n', length)
+
+      packer.pack_name(@name)
+    end
+
+    def to_s()
+      return "#{@name} [NS]"
+    end
+  end
+
+  class CNAME
+    attr_accessor :name
+
+    def initialize(name:)
+      @name = name
+    end
+
+    def self.unpack(unpacker)
+      # We don't really need the name for anything, so just discard it
+      unpacker.unpack('n')
+
+      return self.new(name: unpacker.unpack_name())
+    end
+
+    def pack(packer)
+      length = packer.pack_name(@name, dry_run: true)
+      packer.pack('n', length)
+      packer.pack_name(@name)
+    end
+
+    def to_s()
+      return "#{@name} [CNAME]"
+    end
+  end
+
+  class SOA
+    attr_accessor :primary, :responsible, :serial, :refresh, :retry_interval, :expire, :ttl
+
+    def initialize(primary:, responsible:, serial:, refresh:, retry_interval:, expire:, ttl:)
+      @primary = primary
+      @responsible = responsible
+      @serial = serial
+      @refresh = refresh
+      @retry_interval = retry_interval
+      @expire = expire
+      @ttl = ttl
+    end
+
+    def self.unpack(unpacker)
+      length = unpacker.unpack_one('n')
+      if length < 22
+        raise(FormatException, "Invalid SOA record")
+      end
+
+      primary = unpacker.unpack_name()
+      responsible = unpacker.unpack_name()
+      serial, refresh, retry_interval, expire, ttl = unpacker.unpack("NNNNN")
+
+      return self.new(primary: primary, responsible: responsible, serial: serial, refresh: refresh, retry_interval: retry_interval, expire: expire, ttl: ttl)
+    end
+
+    def pack(packer)
+      length = packer.pack_name(@primary, dry_run: true) + packer.pack_name(@responsible, dry_run: true, compress: false) + 20
+      packer.pack('n', length)
+
+      packer.pack_name(@primary)
+      # It's a pain to calculate the length when both of these can be
+      # compressed, so we're just not going to compress the second name
+      packer.pack_name(@responsible, compress: false)
+      packer.pack("NNNNN", @serial, @refresh, @retry_interval, @expire, @ttl)
+    end
+
+    def to_s()
+      return "Primary name server = %s, responsible authority's mailbox: %s, serial number: 0x%08x, refresh interval: 0x%08x, retry interval: 0x%08x, expire limit: 0x%08x, min_ttl: 0x%08x, [SOA]" % [
+        @primary,
+        @responsible,
+        @serial,
+        @refresh,
+        @retry_interval,
+        @expire,
+        @ttl,
+      ]
+    end
+  end
+
+  class MX
+    attr_accessor :preference, :name
+
+    def initialize(name:, preference:)
+      @name = name
+      @preference = preference
+    end
+
+    def self.unpack(unpacker)
+      length = unpacker.unpack_one('n')
+      if length < 3
+        raise(FormatException, "Invalid MX record")
+      end
+
+      preference = unpacker.unpack_one('n')
+      name = unpacker.unpack_name()
+
+      return self.new(name: name, preference: preference)
+    end
+
+    def pack(packer)
+      length = packer.pack_name(@name, dry_run: true) + 2
+      packer.pack('n', length)
+
+      packer.pack('n', @preference)
+      packer.pack_name(@name)
+    end
+
+    def to_s()
+      return "#{@preference} #{@name} [MX]"
+    end
+  end
+
+  class TXT
+    attr_accessor :data
+
+    def initialize(data:)
+      @data = data
+    end
+
+    def self.unpack(unpacker)
+      length = unpacker.unpack_one('n')
+      if length < 1
+        raise(FormatException, "Invalid TXT record")
+      end
+
+      len = unpacker.unpack_one("C")
+
+      if len != length - 1
+        raise(FormatException, "Invalid TXT record")
+      end
+
+      data = unpacker.unpack_one("a#{len}")
+
+      return self.new(data: data)
+    end
+
+    def pack(packer)
+      packer.pack('n', @data.length + 1)
+
+      packer.pack('Ca*', @data.length, @data)
+    end
+
+    def to_s()
+      return "#{@data} [TXT]"
+    end
+  end
+
+  class AAAA
+    attr_accessor :address
+
+    def initialize(address:)
+      if !address.is_a?(String)
+        raise(FormatException, "String required!")
+      end
+
+      begin
+        @address = IPAddr.new(address)
+      rescue IPAddr::InvalidAddressError => e
+        raise(FormatException, "Invalid address: %s" % e)
+      end
+
+      if !@address.ipv6?()
+        raise(FormatException, "IPv6 address required!")
+      end
+    end
+
+    def self.unpack(unpacker)
+      length = unpacker.unpack_one('n')
+      if length != 16
+        raise(FormatException, "Invalid AAAA record")
+      end
+
+      data = unpacker.unpack('a16').join()
+      return self.new(address: IPAddr.ntop(data))
+    end
+
+    def pack(packer)
+      packer.pack('n', 16)
+
+      packer.pack('C16', *@address.hton().bytes())
+    end
+
+
+    def to_s()
+      return "#{@address} [AAAA]"
+    end
+  end
+
+  class RRUnknown
+    attr_reader :type, :data
+    def initialize(type:, data:)
+      @type = type
+      @data = data
+    end
+
+    def self.unpack(unpacker, type)
+      length = unpacker.unpack_one('n')
+      data = unpacker.unpack_one("a#{length}")
+      return self.new(type: type, data: data)
+    end
+
+    def pack(packer)
+      packer.pack('n', @data.length)
+
+      packer.pack('a*', @data)
+    end
+
+    def to_s()
+      return "(Unknown record type 0x%04x: %s)" % [@type, @data]
+    end
+  end
+end