@nictool/dns-resource-record 1.6.1 → 1.8.0

package/rr/tsig.js

@@ -1,7 +1,14 @@
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
+import * as WIRE from '../lib/wire.js'
 
 export default class TSIG extends RR {
+  static typeName = 'TSIG'
+  static typeId = 250
+  static RFCs = [2845, 8945]
+  static rdataFields = ['algorithm name', 'time signed', 'fudge', 'mac', 'original id', 'error', 'other']
+
   constructor(opts) {
     super(opts)
     if (opts === null) return
@@ -13,18 +20,6 @@ export default class TSIG extends RR {
     return 'Transaction Signature'
   }
 
-  getRdataFields(arg) {
-    return ['algorithm name', 'time signed', 'fudge', 'mac', 'original id', 'error', 'other']
-  }
-
-  getRFCs() {
-    return [2845, 8945]
-  }
-
-  getTypeId() {
-    return 250
-  }
-
   getCanonical() {
     return {
       owner: 'test.example.',
@@ -114,22 +109,23 @@ export default class TSIG extends RR {
     const algUnpacked = TINYDNS.unpackDomainName(rdata)
     const algBinaryLen = algUnpacked[2]
 
-    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const bytes = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
     let bpos = algBinaryLen
 
-    const timeSigned = bytes.readUInt32BE(bpos)
+    const timeSigned = dv.getUint32(bpos)
     bpos += 4
-    const fudge = bytes.readUInt16BE(bpos)
+    const fudge = dv.getUint16(bpos)
     bpos += 2
-    const macSize = bytes.readUInt16BE(bpos)
+    const macSize = dv.getUint16(bpos)
     bpos += 2
-    const mac = macSize > 0 ? bytes.slice(bpos, bpos + macSize).toString('hex') : ''
+    const mac = macSize > 0 ? BINARY.bytesToHex(bytes.subarray(bpos, bpos + macSize)) : ''
     bpos += macSize
-    const originalId = bytes.readUInt16BE(bpos)
+    const originalId = dv.getUint16(bpos)
     bpos += 2
-    const error = bytes.readUInt16BE(bpos)
+    const error = dv.getUint16(bpos)
     bpos += 2
-    const other = bpos < bytes.length ? bytes.slice(bpos).toString() : ''
+    const other = bpos < bytes.length ? new TextDecoder().decode(bytes.subarray(bpos)) : ''
 
     return new TSIG({
       owner: this.fullyQualify(owner),
@@ -148,6 +144,38 @@ export default class TSIG extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const { fqdn: algorithmName, end } = this.wireUnpackDomain(rdata, 0)
+    const dv = new DataView(rdata.buffer, rdata.byteOffset)
+    let pos = end
+    const timeSigned = dv.getUint32(pos)
+    pos += 4
+    const fudge = dv.getUint16(pos)
+    pos += 2
+    const macSize = dv.getUint16(pos)
+    pos += 2
+    const mac = macSize > 0 ? BINARY.bytesToHex(rdata.subarray(pos, pos + macSize)) : ''
+    pos += macSize
+    const originalId = dv.getUint16(pos)
+    pos += 2
+    const error = dv.getUint16(pos)
+    pos += 2
+    const other = pos < rdata.length ? new TextDecoder().decode(rdata.subarray(pos)) : ''
+    return new TSIG({
+      owner,
+      ttl: 0,
+      class: 'ANY',
+      type: 'TSIG',
+      'algorithm name': algorithmName,
+      'time signed': timeSigned,
+      fudge,
+      mac,
+      'original id': originalId,
+      error,
+      other,
+    })
+  }
+
   /******  EXPORTERS   *******/
   toBind(zone_opts) {
     const mac = this.get('mac') ?? ''
@@ -172,19 +200,54 @@ export default class TSIG extends RR {
     )
   }
 
+  getWireRdata() {
+    const algWire = WIRE.wirePackDomain(this.get('algorithm name') || '')
+    const mac = this.get('mac') ?? ''
+    const macBytes = mac.length > 0 ? BINARY.hexToBytes(mac) : new Uint8Array()
+    const other = this.get('other') ?? ''
+    const otherBytes = other.length > 0 ? new TextEncoder().encode(other) : new Uint8Array()
+
+    const bytes = new Uint8Array(algWire.length + 4 + 2 + 2 + macBytes.length + 2 + 2 + otherBytes.length)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+    let pos = 0
+
+    bytes.set(algWire, pos)
+    pos += algWire.length
+    dv.setUint32(pos, this.get('time signed') ?? 0)
+    pos += 4
+    dv.setUint16(pos, this.get('fudge') ?? 0)
+    pos += 2
+    dv.setUint16(pos, macBytes.length)
+    pos += 2
+    if (macBytes.length > 0) {
+      bytes.set(macBytes, pos)
+      pos += macBytes.length
+    }
+    dv.setUint16(pos, this.get('original id') ?? 0)
+    pos += 2
+    dv.setUint16(pos, this.get('error') ?? 0)
+    pos += 2
+    if (otherBytes.length > 0) bytes.set(otherBytes, pos)
+
+    return bytes
+  }
+
   toTinydns() {
-    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
     const alg = this.get('algorithm name') || ''
+    const mac = this.get('mac') ?? ''
+    const macByteLen = mac.length > 0 ? mac.length / 2 : 0
 
     return this.getTinydnsGeneric(
       TINYDNS.packDomainName(alg) +
         TINYDNS.UInt32toOctal(this.get('time signed') ?? 0) +
         TINYDNS.UInt16toOctal(this.get('fudge')) +
-        TINYDNS.UInt16toOctal(this.get('mac size') ?? 0) +
-        (this.get('mac size') > 0 ? TINYDNS.escapeOctal(dataRe, this.get('mac')) : '') +
+        TINYDNS.UInt16toOctal(macByteLen) +
+        (macByteLen > 0 ? TINYDNS.packHex(mac) : '') +
         TINYDNS.UInt16toOctal(this.get('original id') ?? 0) +
         TINYDNS.UInt16toOctal(this.get('error') ?? 0) +
-        (this.get('other').length > 0 ? TINYDNS.escapeOctal(dataRe, this.get('other')) : ''),
+        (this.get('other').length > 0
+          ? TINYDNS.escapeOctal(new RegExp(/[\r\n\t:\\/]/, 'g'), this.get('other'))
+          : ''),
     )
   }
 }

package/rr/txt.js

@@ -3,6 +3,13 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class TXT extends RR {
+  static typeName = 'TXT'
+  static typeId = 16
+  static RFCs = [1035, 4408, 7208, 6376]
+  static tinydnsType = "'"
+  static rdataFields = [['data', 'charstrs']]
+  static tags = ['common']
+
   constructor(opts) {
     super(opts)
   }
@@ -16,22 +23,6 @@ export default class TXT extends RR {
     return 'Text'
   }
 
-  getTags() {
-    return ['common']
-  }
-
-  getRdataFields(arg) {
-    return ['data']
-  }
-
-  getRFCs() {
-    return [1035, 4408, 7208, 6376]
-  }
-
-  getTypeId() {
-    return 16
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -71,35 +62,20 @@ export default class TXT extends RR {
     if (n != 16) this.throwHelp('TXT fromTinydns, invalid n')
 
     rdata = TINYDNS.octalToChar(rdata)
-    let s = ''
-    let len = rdata[0].charCodeAt(0)
-    let pos = 1
+    // Walk RFC 1035 §3.3.14 len-prefixed <character-string> segments.
+    const parts = []
+    let pos = 0
     while (pos < rdata.length) {
-      s += rdata.slice(pos, +(len + pos))
-      pos = len + pos
-      len = rdata.charCodeAt(pos + 1)
+      const len = rdata.charCodeAt(pos)
+      pos += 1
+      if (pos + len > rdata.length) {
+        this.throwHelp('TXT fromTinydnsGeneric: truncated character-string in rdata')
+      }
+      parts.push(rdata.slice(pos, pos + len))
+      pos += len
     }
-    return [fqdn, s, ttl, ts, loc]
-  }
-
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  TXT  "..."
-    const regex = /^(?<owner>\S{1,255})\s+(?<ttl>\d{1,10})\s+(?<cls>IN)\s+(?<type>\w{3})\s+(?<rdata>\S.*)$/i
-    const match = bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse TXT: ${bindline}`)
-
-    const { owner, ttl, cls, type, rdata } = match.groups
-
-    return new this.constructor({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: cls,
-      type: type.toUpperCase(),
-      data: rdata
-        .match(/"([^"]+?)"/g)
-        .map((s) => s.replace(/^"|"$/g, ''))
-        .join(''),
-    })
+    const data = parts.length > 1 ? parts : (parts[0] ?? '')
+    return [fqdn, data, ttl, ts, loc]
   }
 
   /******  EXPORTERS   *******/
@@ -113,8 +89,31 @@ export default class TXT extends RR {
   }
 
   getWireRdata() {
-    let data = this.get('data')
-    if (Array.isArray(data)) data = data.join('')
+    // RFC 1035 §3.3.14: TXT rdata is one or more <character-string>s, each up
+    // to 255 bytes. An array preserves explicit boundaries between strings;
+    // each element MUST be <= 255 UTF-8 bytes, otherwise we would silently
+    // split it and the boundary the caller asked us to preserve would be lost.
+    // A single string is auto-chunked at 255-byte UTF-8 boundaries.
+    const data = this.get('data')
+    if (Array.isArray(data)) {
+      const enc = new TextEncoder()
+      const buffers = data.map((s, i) => {
+        if (enc.encode(s).length > 255) {
+          this.throwHelp(
+            `TXT: array element ${i} exceeds 255 bytes; split it yourself or pass a single string to auto-chunk`,
+          )
+        }
+        return packStringWire(s)
+      })
+      const total = buffers.reduce((n, b) => n + b.length, 0)
+      const out = new Uint8Array(total)
+      let off = 0
+      for (const b of buffers) {
+        out.set(b, off)
+        off += b.length
+      }
+      return out
+    }
     return packStringWire(data)
   }
 
@@ -127,38 +126,48 @@ export default class TXT extends RR {
 }
 
 function asQuotedStrings(data) {
-  // BIND croaks when any string in the TXT RR data is longer than 255
+  // RFC 1035 character-strings are 255 bytes max; chunk by UTF-8 bytes,
+  // not JS chars, so non-ASCII TXT data doesn't overflow the 255-byte limit.
+  const enc = new TextEncoder()
+
   if (Array.isArray(data)) {
-    let hasTooLong = false
-    for (const str of data) {
-      if (str.length > 255) hasTooLong = true
-    }
-    return hasTooLong
-      ? data
-          .join('')
-          .match(/(.{1,255})/g)
-          .join('" "')
-      : data.join('" "')
+    const anyTooLong = data.some((s) => enc.encode(s).length > 255)
+    if (!anyTooLong) return data.join('" "')
+    return chunkByBytes(data.join(''), 255).join('" "')
   }
 
-  if (data.length > 255) {
-    return data.match(/(.{1,255})/g).join('" "')
-  }
+  if (enc.encode(data).length <= 255) return data
+  return chunkByBytes(data, 255).join('" "')
+}
 
-  return data
+function chunkByBytes(str, maxBytes) {
+  const bytes = new TextEncoder().encode(str)
+  const dec = new TextDecoder()
+  const chunks = []
+  let start = 0
+  while (start < bytes.length) {
+    let end = Math.min(start + maxBytes, bytes.length)
+    // back up to a UTF-8 codepoint boundary so decode() returns whole chars
+    while (end < bytes.length && (bytes[end] & 0xc0) === 0x80) end--
+    chunks.push(dec.decode(bytes.subarray(start, end)))
+    start = end
+  }
+  return chunks
 }
 
 function packStringWire(str) {
-  const parts = str.match(/(.{1,255})/g)
-  let len = 0
-  for (const part of parts) len += part.length + 1
+  const encoded = new TextEncoder().encode(str)
+  if (encoded.length === 0) return new Uint8Array([0])
+
+  const chunks = []
+  for (let i = 0; i < encoded.length; i += 255) chunks.push(encoded.subarray(i, i + 255))
 
-  const buf = Buffer.allocUnsafe(len)
+  const buf = new Uint8Array(encoded.length + chunks.length)
   let offset = 0
-  for (const part of parts) {
-    buf.writeUInt8(part.length, offset++)
-    buf.write(part, offset, 'ascii')
-    offset += part.length
+  for (const chunk of chunks) {
+    buf[offset++] = chunk.length
+    buf.set(chunk, offset)
+    offset += chunk.length
   }
   return buf
 }

package/rr/uri.js

@@ -3,6 +3,15 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class URI extends RR {
+  static typeName = 'URI'
+  static typeId = 256
+  static RFCs = [7553]
+  static rdataFields = [
+    ['priority', 'u16'],
+    ['weight', 'u16'],
+    ['target', 'qstr'],
+  ]
+
   constructor(opts) {
     super(opts)
   }
@@ -44,37 +53,11 @@ export default class URI extends RR {
     })
   }
 
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  URI  priority, weight, target
-    const [owner, ttl, c, type, priority, weight, target] = bindline.split(/\s+/)
-    return new URI({
-      class: c,
-      type: type,
-      owner,
-      priority: parseInt(priority, 10),
-      weight: parseInt(weight, 10),
-      target: target.replace(/^"|"$/g, ''),
-      ttl: parseInt(ttl, 10),
-    })
-  }
-
   /******  MISC   *******/
   getDescription() {
     return 'URI'
   }
 
-  getRdataFields(arg) {
-    return ['priority', 'weight', 'target']
-  }
-
-  getRFCs() {
-    return [7553]
-  }
-
-  getTypeId() {
-    return 256
-  }
-
   getCanonical() {
     return {
       owner: 'www.example.com.',
@@ -87,11 +70,18 @@ export default class URI extends RR {
     }
   }
 
-  getQuotedFields() {
-    return ['target']
+  /******  EXPORTERS   *******/
+
+  getWireRdata() {
+    const target = new TextEncoder().encode(this.get('target'))
+    const result = new Uint8Array(4 + target.length)
+    const dv = new DataView(result.buffer)
+    dv.setUint16(0, this.get('priority'))
+    dv.setUint16(2, this.get('weight'))
+    result.set(target, 4)
+    return result
   }
 
-  /******  EXPORTERS   *******/
   toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
     let rdata = ''

package/rr/wks.js

@@ -2,7 +2,102 @@ import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
+const WELL_KNOWN_PORTS = {
+  echo: 7,
+  discard: 9,
+  systat: 11,
+  daytime: 13,
+  netstat: 15,
+  ftp_data: 20,
+  ftp: 21,
+  ssh: 22,
+  telnet: 23,
+  smtp: 25,
+  time: 37,
+  rlp: 39,
+  nameserver: 42,
+  nicname: 43,
+  domain: 53,
+  mtp: 57,
+  bootps: 67,
+  bootpc: 68,
+  tftp: 69,
+  gopher: 70,
+  rje: 77,
+  finger: 79,
+  http: 80,
+  link: 87,
+  supdup: 95,
+  hostnames: 101,
+  iso_tsap: 102,
+  csnet_ns: 105,
+  pop_2: 109,
+  pop3: 110,
+  sunrpc: 111,
+  auth: 113,
+  sftp: 115,
+  uucp_path: 117,
+  nntp: 119,
+  ntp: 123,
+  netbios_ns: 137,
+  netbios_dgm: 138,
+  netbios_ssn: 139,
+  imap: 143,
+  sql_net: 150,
+  snmp: 161,
+  snmp_trap: 162,
+  cmip_man: 163,
+  cmip_agent: 164,
+  xdmcp: 177,
+  nextstep: 178,
+  bgp: 179,
+  prospero: 191,
+  irc: 194,
+  smux: 199,
+  at_rtmp: 201,
+  at_nbp: 202,
+  at_echo: 204,
+  at_zis: 206,
+  qmtp: 209,
+  z3950: 210,
+  ipx: 213,
+  imap3: 220,
+  ulistproc: 372,
+  https: 443,
+  snpp: 444,
+  microsoft_ds: 445,
+  kpasswd: 464,
+  urd: 465,
+  saft: 487,
+  isakmp: 500,
+  exec: 512,
+  biff: 512,
+  login: 513,
+  who: 513,
+  cmd: 514,
+  syslog: 514,
+  printer: 515,
+  talk: 517,
+  ntalk: 518,
+  route: 520,
+  timed: 525,
+  tempo: 526,
+  courier: 530,
+  netnews: 532,
+  netwall: 533,
+  uucp: 540,
+  remotefs: 556,
+  nntps: 563,
+  ldap: 389,
+}
+
 export default class WKS extends RR {
+  static typeName = 'WKS'
+  static typeId = 11
+  static RFCs = [883, 1035]
+  static rdataFields = ['address', 'protocol', 'bit map']
+  static tags = ['obsolete']
+
   constructor(opts) {
     super(opts)
   }
@@ -29,22 +124,6 @@ export default class WKS extends RR {
     return 'Well Known Service'
   }
 
-  getTags() {
-    return ['obsolete']
-  }
-
-  getRdataFields(arg) {
-    return ['address', 'protocol', 'bit map']
-  }
-
-  getRFCs() {
-    return [883, 1035]
-  }
-
-  getTypeId() {
-    return 11
-  }
-
   getCanonical() {
     return {
       owner: 'host.example.com.',
@@ -77,14 +156,12 @@ export default class WKS extends RR {
   fromTinydns({ tinyline }) {
     const [owner, _typeId, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
 
-    const binary = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
-    const address = [binary.readUInt8(0), binary.readUInt8(1), binary.readUInt8(2), binary.readUInt8(3)].join(
-      '.',
-    )
-    const protoNum = binary.readUInt8(4)
+    const binary = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
+    const address = [binary[0], binary[1], binary[2], binary[3]].join('.')
+    const protoNum = binary[4]
     const protoMap = { 6: 'TCP', 17: 'UDP' }
     const protocol = protoMap[protoNum] ?? protoNum
-    const bitmap = binary.slice(5).toString()
+    const bitmap = new TextDecoder().decode(binary.subarray(5))
 
     return new WKS({
       owner: this.fullyQualify(owner),
@@ -98,6 +175,33 @@ export default class WKS extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const address = [...rdata.subarray(0, 4)].join('.')
+    const protoNum = rdata[4]
+    const protoMap = { 6: 'TCP', 17: 'UDP' }
+    const protocol = protoMap[protoNum] ?? String(protoNum)
+    const PORT_NAMES = Object.fromEntries(Object.entries(WELL_KNOWN_PORTS).map(([k, v]) => [v, k]))
+    const bitmap = rdata.subarray(5)
+    const ports = []
+    for (let i = 0; i < bitmap.length; i++) {
+      for (let bit = 0; bit < 8; bit++) {
+        if (bitmap[i] & (0x80 >> bit)) {
+          const port = i * 8 + bit
+          ports.push(PORT_NAMES[port] ?? String(port))
+        }
+      }
+    }
+    return new WKS({
+      owner,
+      ttl,
+      class: cls,
+      type: 'WKS',
+      address,
+      protocol,
+      'bit map': ports.join(' '),
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {
@@ -111,4 +215,32 @@ export default class WKS extends RR {
         TINYDNS.escapeOctal(dataRe, this.get('bit map')),
     )
   }
+
+  getWireRdata() {
+    const protoMap = { TCP: 6, UDP: 17, 6: 6, 17: 17 }
+    const addrBytes = this.get('address').split('.').map(Number)
+    const protoNum = protoMap[this.get('protocol')]
+
+    const portNums = this.get('bit map')
+      .trim()
+      .split(/\s+/)
+      .map((s) => {
+        if (/^\d+$/.test(s)) return parseInt(s, 10)
+        return WELL_KNOWN_PORTS[s.toLowerCase()]
+      })
+      .filter((p) => p !== undefined)
+
+    if (portNums.length === 0) return new Uint8Array([...addrBytes, protoNum])
+
+    const maxPort = Math.max(...portNums)
+    const bitmapLen = Math.floor(maxPort / 8) + 1
+    const bitmap = new Uint8Array(bitmapLen)
+    for (const port of portNums) bitmap[Math.floor(port / 8)] |= 0x80 >> (port % 8)
+
+    const result = new Uint8Array(5 + bitmapLen)
+    result.set(addrBytes)
+    result[4] = protoNum
+    result.set(bitmap, 5)
+    return result
+  }
 }