@nictool/dns-resource-record 1.4.0 → 1.5.0

package/rr/svcb.js

@@ -46,11 +46,11 @@ export default class SVCB extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  SVCB Priority TargetName Params
     // _8443._foo.api.example.com. 7200 IN SVCB 0 svc4.example.net.
     // svc4.example.net.  7200  IN SVCB 3 svc4.example.net. ( alpn="bar" port="8004" )
-    const [owner, ttl, c, type, pri, fqdn] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pri, fqdn] = bindline.split(/\s+/)
     return new SVCB({
       owner,
       ttl: parseInt(ttl, 10),
@@ -58,22 +58,35 @@ export default class SVCB extends RR {
       type,
       priority: parseInt(pri, 10),
       'target name': fqdn,
-      params: opts.bindline.split(/\s+/).slice(6).join(' ').trim(),
+      params: bindline.split(/\s+/).slice(6).join(' ').trim(),
     })
   }
 
-  fromTinydns({ rd, owner, ttl }) {
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
+
     if (rd.length < 6) {
       this.throwHelp(`SVCB: RDATA too short: ${rd}`)
     }
 
-    const priority = TINYDNS.octalToUInt16(rd.substring(0, 6))
-    const remainingRdata = rd.slice(6)
+    // Convert escaped octal RDATA into a binary buffer for reliable parsing
+    const binary = Buffer.from(TINYDNS.octalToChar(rd), 'binary')
 
-    const [targetName, consumedLength] = TINYDNS.unpackDomainName(remainingRdata)
+    const priority = binary.readUInt16BE(0)
 
-    const params = remainingRdata.slice(consumedLength)
-    const unescapedParams = TINYDNS.unescapeOctal(params)
+    // parse domain name from binary starting at offset 2
+    let pos = 2
+    const labels = []
+    while (true) {
+      const len = binary.readUInt8(pos)
+      pos += 1
+      if (len === 0) break
+      labels.push(binary.slice(pos, pos + len).toString())
+      pos += len
+    }
+    const targetName = `${labels.join('.')}.`
+    // remaining params are ASCII text after the domain
+    const params = binary.slice(pos).toString()
 
     return new SVCB({
       owner: this.fullyQualify(owner),
@@ -81,7 +94,9 @@ export default class SVCB extends RR {
       type: 'SVCB',
       priority: priority,
       'target name': targetName,
-      params: unescapedParams,
+      params: params,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/tlsa.js

@@ -76,12 +76,12 @@ export default class TLSA extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  TLSA, usage, selector, match, data
     const regex =
-      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<cls>IN)\s+(?<type>TLSA)\s+(?<usage>\d+)\s+(?<selector>\d+)\s+(?<matchtype>\d+)\s+(?<cad>.+)$/i
-    const match = opts.bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse TLSA: ${opts.bindline}`)
+      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<cls>IN)\s+(?<type>TLSA)\s+(?<usage>\d+)\s+(?<selector>\d+)\s+(?<matchtype>\d+)\s+(?<cad>\S.*)$/i
+    const match = bindline.trim().match(regex)
+    if (!match) this.throwHelp(`unable to parse TLSA: ${bindline}`)
     const { owner, ttl, cls, type, usage, selector, matchtype, cad } = match.groups
 
     return new TLSA({
@@ -92,12 +92,12 @@ export default class TLSA extends RR {
       'certificate usage': parseInt(usage, 10),
       selector: parseInt(selector, 10),
       'matching type': parseInt(matchtype, 10),
-      'certificate association data': cad,
+      'certificate association data': cad.trim(),
     })
   }
 
-  fromTinydns(opts) {
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 52) this.throwHelp('TLSA fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -111,7 +111,7 @@ export default class TLSA extends RR {
       'matching type': bytes.readUInt8(2),
       'certificate association data': bytes.slice(3).toString(),
       timestamp: ts,
-      location: loc.trim() || '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/tsig.js

@@ -1,4 +1,5 @@
 import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
 
 export default class TSIG extends RR {
   constructor(opts) {
@@ -17,32 +18,157 @@ export default class TSIG extends RR {
   }
 
   getRFCs() {
-    return [2845]
+    return [2845, 8945]
   }
 
   getTypeId() {
     return 250
   }
 
+  setClass(t) {
+    if (t !== 'ANY') this.throwHelp('TSIG: Class is required to be ANY')
+    this.set('class', t)
+  }
+
+  setTtl(t) {
+    if (t !== 0) this.throwHelp('TSIG: TTL is required to be 0')
+    this.set('ttl', t)
+  }
+
+  setAlgorithmName(val) {
+    if (!val) this.throwHelp(`TSIG: 'algorithm name' is required`)
+    this.set('algorithm name', val)
+  }
+
+  setTimeSigned(val) {
+    // a 48-bit unsigned integer, as seconds since the UNIX epoch
+    if (val === undefined) this.throwHelp(`TSIG: 'time signed' is required`)
+    this.set('time signed', val)
+  }
+
+  setFudge(val) {
+    // 16-bit unsigned
+    this.is16bitInt('TSIG', 'fudge', val)
+    this.set('fudge', val)
+  }
+
+  setMac(val) {
+    this.set('mac', val ?? '')
+  }
+
+  setOriginalId(val) {
+    this.is16bitInt('TSIG', 'original id', val)
+    this.set('original id', val)
+  }
+
+  setError(val) {
+    this.is16bitInt('TSIG', 'error', val)
+    this.set('error', val)
+  }
+
+  setOther(val) {
+    this.set('other', val ?? '')
+  }
+
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
-    // test.example.com  3600  IN  TSIG SAMPLE-ALG.EXAMPLE. 853804800 300 0 0 0
-    const [owner, ttl, c, type, algorithm] = opts.bindline.split(/\s+/)
+  fromBind({ bindline }) {
+    // owner ttl ANY TSIG alg time fudge mac_size mac original_id error other_len
+    const parts = bindline.trimEnd().split('\t')
+    const [owner, ttl, cls, type, alg, time, fudge, , mac, origId, error] = parts
+
     return new TSIG({
       owner,
       ttl: parseInt(ttl, 10),
-      class: c,
-      type: type,
-      algorithm: algorithm,
-      // 'time signed': opts.bindline,
-      // fudge
-      // mac
-      // original id
-      // error
-      // other
+      class: cls,
+      type: type.toUpperCase(),
+      'algorithm name': alg,
+      'time signed': parseInt(time, 10),
+      fudge: parseInt(fudge, 10),
+      mac: mac || '',
+      'original id': parseInt(origId, 10),
+      error: parseInt(error, 10),
+      other: '',
+    })
+  }
+
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+
+    const algUnpacked = TINYDNS.unpackDomainName(rdata)
+    const algBinaryLen = algUnpacked[2]
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    let bpos = algBinaryLen
+
+    const timeSigned = bytes.readUInt32BE(bpos)
+    bpos += 4
+    const fudge = bytes.readUInt16BE(bpos)
+    bpos += 2
+    const macSize = bytes.readUInt16BE(bpos)
+    bpos += 2
+    const mac = macSize > 0 ? bytes.slice(bpos, bpos + macSize).toString('hex') : ''
+    bpos += macSize
+    const originalId = bytes.readUInt16BE(bpos)
+    bpos += 2
+    const error = bytes.readUInt16BE(bpos)
+    bpos += 2
+    const other = bpos < bytes.length ? bytes.slice(bpos).toString() : ''
+
+    return new TSIG({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      class: 'ANY',
+      type: 'TSIG',
+      'algorithm name': algUnpacked[0],
+      'time signed': timeSigned,
+      fudge,
+      mac,
+      'original id': originalId,
+      error,
+      other,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 
   /******  EXPORTERS   *******/
+  toBind(zone_opts) {
+    const mac = this.get('mac') ?? ''
+    const macSize = mac.length > 0 ? mac.length : ''
+    const other = this.get('other') ?? ''
+    const otherLen = other.length > 0 ? other.length : 0
+    return (
+      [
+        this.getFQDN('owner', zone_opts),
+        this.get('ttl'),
+        this.get('class'),
+        this.get('type'),
+        this.get('algorithm name'),
+        this.get('time signed'),
+        this.get('fudge'),
+        macSize,
+        mac,
+        this.get('original id'),
+        this.get('error'),
+        otherLen,
+      ].join('\t') + '\n'
+    )
+  }
+
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+    const alg = this.get('algorithm name') || ''
+
+    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(this.get('original id') ?? 0) +
+        TINYDNS.UInt16toOctal(this.get('error') ?? 0) +
+        (this.get('other').length > 0 ? TINYDNS.escapeOctal(dataRe, this.get('other')) : ''),
+    )
+  }
 }

package/rr/txt.js

@@ -29,12 +29,12 @@ export default class TXT extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
-    const str = opts.tinyline
+  fromTinydns({ tinyline }) {
+    const str = tinyline
     let fqdn, rdata, s, ttl, ts, loc
     // 'fqdn:s:ttl:timestamp:lo
     if (str[0] === "'") {
-      ;[fqdn, s, ttl, ts, loc] = str.substring(1).split(':')
+      ;[fqdn, s, ttl, ts, loc] = str.slice(1).split(':')
       rdata = TINYDNS.octalToChar(s)
     } else {
       ;[fqdn, rdata, ttl, ts, loc] = this.fromTinydnsGeneric(str)
@@ -46,14 +46,14 @@ export default class TXT extends RR {
       type: 'TXT',
       data: rdata,
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() || '',
     })
   }
 
   fromTinydnsGeneric(str) {
     // generic: :fqdn:n:rdata:ttl:timestamp:location
     // eslint-disable-next-line prefer-const
-    let [fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
+    let [fqdn, n, rdata, ttl, ts, loc] = str.slice(1).split(':')
     if (n != 16) this.throwHelp('TXT fromTinydns, invalid n')
 
     rdata = TINYDNS.octalToChar(rdata)
@@ -61,19 +61,18 @@ export default class TXT extends RR {
     let len = rdata[0].charCodeAt(0)
     let pos = 1
     while (pos < rdata.length) {
-      s += rdata.substring(pos, +(len + pos))
+      s += rdata.slice(pos, +(len + pos))
       pos = len + pos
       len = rdata.charCodeAt(pos + 1)
     }
     return [fqdn, s, ttl, ts, loc]
   }
 
-  fromBind(opts) {
+  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+?\s*(?<rdata>.+?)$/i
-    const match = opts.bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse TXT: ${opts.bindline}`)
+    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
 

package/rr/uri.js

@@ -27,26 +27,26 @@ export default class URI extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // URI via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 256) this.throwHelp('URI fromTinydns, invalid n')
 
     return new URI({
       type: 'URI',
       owner: this.fullyQualify(fqdn),
-      priority: TINYDNS.octalToUInt16(rdata.substring(0, 8)),
-      weight: TINYDNS.octalToUInt16(rdata.substring(8, 16)),
-      target: TINYDNS.octalToChar(rdata.substring(16)),
+      priority: TINYDNS.octalToUInt16(rdata.slice(0, 8)),
+      weight: TINYDNS.octalToUInt16(rdata.slice(8, 16)),
+      target: TINYDNS.octalToChar(rdata.slice(16)),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc.trim() || '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  URI  priority, weight, target
-    const [owner, ttl, c, type, priority, weight, target] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, priority, weight, target] = bindline.split(/\s+/)
     return new URI({
       class: c,
       type: type,

package/rr/wks.js

@@ -43,9 +43,9 @@ export default class WKS extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  WKS 192.168.1.1 TCP ftp smtp
-    const parts = opts.bindline.split(/\s+/)
+    const parts = bindline.split(/\s+/)
     const [owner, ttl, c, type, address, protocol] = parts
     return new WKS({
       owner,
@@ -58,6 +58,30 @@ 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 protoMap = { 6: 'TCP', 17: 'UDP' }
+    const protocol = protoMap[protoNum] ?? protoNum
+    const bitmap = binary.slice(5).toString()
+
+    return new WKS({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'WKS',
+      address,
+      protocol,
+      'bit map': bitmap,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {

package/rr.js

@@ -4,10 +4,10 @@ export default class RR extends Map {
 
     if (opts === null) return
 
-    if (opts.default) this.default = opts.default
+    if (opts?.default) this.default = opts.default
 
-    if (opts.bindline) return this.fromBind(opts)
-    if (opts.tinyline) return this.fromTinydns(opts)
+    if (opts?.bindline) return this.fromBind(opts)
+    if (opts?.tinyline) return this.fromTinydns(opts)
 
     // tinydns specific
     this.setLocation(opts?.location)
@@ -21,10 +21,10 @@ export default class RR extends Map {
     for (const f of this.getFields('rdata')) {
       const fnName = `set${this.ucFirst(f)}`
       if (this[fnName] === undefined) this.throwHelp(`Missing ${fnName} in class ${this.get('type')}`)
-      this[fnName](opts[f])
+      this[fnName](opts?.[f])
     }
 
-    if (opts.comment) this.set('comment', opts.comment)
+    if (opts?.comment) this.set('comment', opts.comment)
   }
 
   ucFirst(str) {
@@ -91,7 +91,7 @@ export default class RR extends Map {
   }
 
   setTtl(t) {
-    if (t === undefined) t = this?.default?.ttl
+    t = t ?? this.default?.ttl
     if (t === undefined) {
       if (['SOA', 'SSHPF'].includes(this.get('type'))) return
       this.throwHelp('TTL is required, no default available')
@@ -157,7 +157,7 @@ export default class RR extends Map {
   }
 
   getEmpty(prop) {
-    return this.get(prop) === undefined ? '' : this.get(prop)
+    return this.get(prop) ?? ''
   }
 
   getComment(prop) {
@@ -307,6 +307,51 @@ export default class RR extends Map {
     )
   }
 
+  compressIPv6(val) {
+    //  * RFC 5952
+    //  * 4.1. Leading zeros MUST be suppressed...A single 16-bit 0000 field MUST be represented as 0.
+    //  * 4.2.1 The use of the symbol "::" MUST be used to its maximum capability.
+    //  * 4.2.2 The symbol "::" MUST NOT be used to shorten just one 16-bit 0 field.
+    //  * 4.2.3 When choosing placement of a "::", the longest run...MUST be shortened
+    //  * 4.3 The characters a-f in an IPv6 address MUST be represented in lowercase.
+
+    // 4.3 Lowercase and 4.1 remove leading zeros per segment
+    const segments = val
+      .toLowerCase()
+      .split(':')
+      .map((s) => s.replace(/^0+/, '') || '0')
+
+    let bestStart = -1
+    let bestLen = 0
+    let curStart = -1
+    let curLen = 0
+
+    // 4.2.1 & 4.2.3 Find the longest consecutive run of '0'
+    for (let i = 0; i < segments.length; i++) {
+      if (segments[i] === '0') {
+        if (curStart === -1) curStart = i
+        curLen++
+        if (curLen > bestLen) {
+          bestLen = curLen
+          bestStart = curStart
+        }
+      } else {
+        curStart = -1
+        curLen = 0
+      }
+    }
+
+    // 4.2.2 Don't shorten a single 16-bit 0 field
+    if (bestLen < 2) {
+      return segments.join(':')
+    }
+
+    const head = segments.slice(0, bestStart).join(':')
+    const tail = segments.slice(bestStart + bestLen).join(':')
+
+    return `${head}::${tail}`
+  }
+
   toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.getRdataFields()
       .map((f) => this.getQuoted(f))