@nictool/dns-resource-record 1.4.0 → 1.6.0

package/rr/key.js

@@ -63,11 +63,24 @@ export default class KEY extends RR {
     return 25
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'KEY',
+      flags: 256,
+      protocol: 3,
+      algorithm: 5,
+      publickey: 'AQPSKAsj8...',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  KEY Flags Protocol Algorithm PublicKey
-    const [owner, ttl, c, type, flags, protocol, algorithm] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, flags, protocol, algorithm] = bindline.split(/\s+/)
     return new KEY({
       owner,
       ttl: parseInt(ttl, 10),
@@ -76,31 +89,27 @@ export default class KEY extends RR {
       flags: parseInt(flags, 10),
       protocol: parseInt(protocol, 10),
       algorithm: parseInt(algorithm, 10),
-      publickey: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+      publickey: bindline.split(/\s+/).slice(7).join(' ').trim(),
     })
   }
 
-  fromTinydns(opts) {
-    const rd = opts.rd
-
+  fromTinydns({ tinyline }) {
     // RDATA format: Flags (6 octal chars) + Protocol (3 octal chars) + Algorithm (3 octal chars) + Public Key (escaped data)
+    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (rd.length < 12) {
       this.throwHelp(`KEY: RDATA too short: ${rd}`)
     }
 
-    const flags = TINYDNS.octalToUInt16(rd.substring(0, 6))
-    const protocol = TINYDNS.octalToUInt8(rd.substring(6, 9))
-    const algorithm = TINYDNS.octalToUInt8(rd.substring(9, 12))
-    const publicKeyData = TINYDNS.unescapeOctal(rd.substring(12))
-
     return new KEY({
-      owner: this.fullyQualify(opts.owner),
-      ttl: parseInt(opts.ttl, 10),
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
       type: 'KEY',
-      flags: flags,
-      protocol: protocol,
-      algorithm: algorithm,
-      publickey: publicKeyData,
+      flags: TINYDNS.octalToUInt16(rd.slice(0, 6)),
+      protocol: TINYDNS.octalToUInt8(rd.slice(6, 9)),
+      algorithm: TINYDNS.octalToUInt8(rd.slice(9, 12)),
+      publickey: TINYDNS.unescapeOctal(rd.slice(12)),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/kx.js

@@ -51,9 +51,25 @@ export default class KX extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // KX via generic, :fqdn:36:rdata:ttl:timestamp:lo
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (n != 36) this.throwHelp('KX fromTinydns, invalid n')
+
+    return new KX({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'KX',
+      preference: TINYDNS.octalToUInt16(rdata.slice(0, 8)),
+      exchanger: TINYDNS.unpackDomainName(rdata.slice(8))[0],
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  KX  preference exchanger
-    const [owner, ttl, c, type, preference, exchanger] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchanger] = bindline.split(/\s+/)
     return new KX({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/loc.js

@@ -48,6 +48,16 @@ export default class LOC extends RR {
     return 29
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'LOC',
+      address: '52 22 23.000 N 4 53 32.000 E 10m 100m 10m 2m',
+    }
+  }
+
   parseLoc(string) {
     // d1 [m1 [s1]]
     const dms = '(\\d+)\\s+(?:(\\d+)\\s+)?(?:([\\d.]+)\\s+)?'
@@ -85,22 +95,22 @@ export default class LOC extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // LOC 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 != 29) this.throwHelp('LOC fromTinydns, invalid n')
 
     // divide by 100 is to convert cm to meters
     const l = {
-      version: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
+      version: TINYDNS.octalToUInt8(rdata.slice(0, 4)),
+      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(4, 8))),
       precision: {
-        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(8, 12))),
-        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(12, 16))),
+        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(8, 12))),
+        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(12, 16))),
       },
-      latitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(16, 32)), 'lat'),
-      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(32, 48)), 'lon'),
-      altitude: TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
+      latitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.slice(16, 32)), 'lat'),
+      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.slice(32, 48)), 'lon'),
+      altitude: TINYDNS.octalToUInt32(rdata.slice(48, 64)) - REF.ALTITUDE,
     }
 
     return new LOC({
@@ -109,24 +119,24 @@ export default class LOC extends RR {
       address: this.toHuman(l),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
-    const [owner, ttl, c, type] = opts.bindline.split(/\s+/)
+  fromBind({ bindline }) {
+    const [owner, ttl, c, type] = bindline.split(/\s+/)
 
     return new LOC({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
-      address: opts.bindline.split(/\s+/).slice(4).join(' ').trim(),
+      address: bindline.split(/\s+/).slice(4).join(' ').trim(),
     })
   }
 
   dmsToArcSec(obj) {
-    let retval = obj.degrees * CONV.deg + (obj.minutes || 0) * CONV.min + (obj.seconds || 0) * CONV.sec
+    let retval = obj.degrees * CONV.deg + (obj.minutes ?? 0) * CONV.min + (obj.seconds ?? 0) * CONV.sec
     switch (obj.hemisphere.toUpperCase()) {
       case 'W':
       case 'S':

package/rr/mx.js

@@ -29,6 +29,10 @@ export default class MX extends RR {
     return 'Mail Exchanger'
   }
 
+  getTags() {
+    return ['common']
+  }
+
   getRdataFields(arg) {
     return ['preference', 'exchange']
   }
@@ -47,16 +51,16 @@ export default class MX extends RR {
       ttl: 43200,
       class: 'IN',
       type: 'MX',
-      preference: 0,
+      preference: 10,
       exchange: 'mail.example.com.',
     }
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // @fqdn:ip:x:dist:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [owner, ip, x, preference, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [owner, ip, x, preference, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new MX({
       type: 'MX',
@@ -65,13 +69,13 @@ export default class MX extends RR {
       preference: parseInt(preference, 10) || 0,
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  MX  preference exchange
-    const [owner, ttl, c, type, preference, exchange] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchange] = bindline.split(/\s+/)
 
     return new MX({
       owner,
@@ -84,6 +88,12 @@ export default class MX extends RR {
   }
 
   /******  EXPORTERS   *******/
+  getWireRdata() {
+    const pref = Buffer.alloc(2)
+    pref.writeUInt16BE(this.get('preference'))
+    return Buffer.concat([pref, this.wirePackDomain(this.get('exchange'))])
+  }
+
   toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.get('preference')}\t${this.getFQDN('exchange', zone_opts)}\n`
   }

package/rr/naptr.js

@@ -21,13 +21,28 @@ export default class NAPTR extends RR {
   }
 
   getRFCs() {
-    return [2915, 3403]
+    return [2915, 3403, 4848]
   }
 
   getTypeId() {
     return 35
   }
 
+  getCanonical() {
+    return {
+      owner: 'cid.urn.arpa.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'NAPTR',
+      order: 100,
+      preference: 10,
+      flags: 'S',
+      service: 'z3950+N2L+N2R',
+      regexp: '',
+      replacement: 'gatekeeper.example.com.',
+    }
+  }
+
   /****** Resource record specific setters   *******/
   setOrder(val) {
     this.is16bitInt('NAPTR', 'order', val)
@@ -62,9 +77,9 @@ export default class NAPTR extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // NAPTR 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 != 35) this.throwHelp('NAPTR fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -74,7 +89,7 @@ export default class NAPTR extends RR {
       owner: this.fullyQualify(fqdn),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
       order: binRdata.readUInt16BE(0, 2),
       preference: binRdata.readUInt16BE(2, 4),
     }
@@ -102,26 +117,30 @@ export default class NAPTR extends RR {
     return new NAPTR(rec)
   }
 
-  fromBind(opts) {
-    const str = opts.bindline
-    // test.example.com  3600  IN  NAPTR order, preference, "flags", "service", "regexp", replacement
-    const [owner, ttl, c, type, order, preference] = str.split(/\s+/)
-    const [flags, service, regexp] = str.match(/(?:").*?(?:"\s)/g)
-    const replacement = str.trim().split(/\s+/).pop()
+  fromBind({ bindline }) {
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d+)\s+(?<class>\S+)\s+(?<type>NAPTR)\s+(?<order>\d+)\s+(?<preference>\d+)\s+["'](?<flags>[^"']*)["']\s+["'](?<service>[^"']*)["']\s+["'](?<regexp>[^"']*)["']\s+(?<replacement>\S+)$/
+
+    const match = bindline.trim().match(regex)
 
-    const bits = {
-      owner: owner,
+    if (!match) {
+      throw new Error(`Invalid NAPTR BIND line: ${bindline}`)
+    }
+
+    const { owner, ttl, type, order, preference, flags, service, regexp, replacement } = match.groups
+
+    return new NAPTR({
+      owner: this.fullyQualify(owner),
       ttl: parseInt(ttl, 10),
-      class: c,
-      type: type,
+      class: match.groups.class,
+      type,
       order: parseInt(order, 10),
       preference: parseInt(preference, 10),
-      flags: flags.trim().replace(/^['"]|['"]$/g, ''),
-      service: service.trim().replace(/^['"]|['"]$/g, ''),
-      regexp: regexp.trim().replace(/^['"]|['"]/g, ''),
-      replacement: replacement,
-    }
-    return new NAPTR(bits)
+      flags,
+      service,
+      regexp,
+      replacement,
+    })
   }
 
   /******  EXPORTERS   *******/

package/rr/ns.js

@@ -21,6 +21,10 @@ export default class NS extends RR {
     return 'Name Server'
   }
 
+  getTags() {
+    return ['common']
+  }
+
   getRdataFields(arg) {
     return ['dname']
   }
@@ -33,11 +37,21 @@ export default class NS extends RR {
     return 2
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'NS',
+      dname: 'ns1.example.com.',
+    }
+  }
+
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // &fqdn:ip:x:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [fqdn, ip, dname, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, ip, dname, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new NS({
       type: 'NS',
@@ -45,13 +59,13 @@ export default class NS extends RR {
       dname: this.fullyQualify(/\./.test(dname) ? dname : `${dname}.ns.${fqdn}`),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  NS dname
-    const [owner, ttl, c, type, dname] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, dname] = bindline.split(/\s+/)
 
     return new NS({
       owner,
@@ -63,6 +77,10 @@ export default class NS extends RR {
   }
 
   /******  EXPORTERS   *******/
+  getWireRdata() {
+    return this.wirePackDomain(this.get('dname'))
+  }
+
   toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.getFQDN('dname', zone_opts)}\n`
   }

package/rr/nsec.js

@@ -29,6 +29,10 @@ export default class NSEC extends RR {
     return 'Next Secure'
   }
 
+  getTags() {
+    return ['dnssec']
+  }
+
   getRdataFields(arg) {
     return ['next domain', 'type bit maps']
   }
@@ -41,10 +45,21 @@ export default class NSEC extends RR {
     return 47
   }
 
+  getCanonical() {
+    return {
+      owner: 'alfa.example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'NSEC',
+      'next domain': 'host.example.com.',
+      'type bit maps': 'A MX RRSIG NSEC TYPE1234',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromTinydns(opts) {
-    const [owner, _typeId, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
     const [nextDomain, _escapedLen, binaryLen] = TINYDNS.unpackDomainName(rdata)
 
@@ -55,20 +70,20 @@ export default class NSEC extends RR {
       'next domain': nextDomain,
       'type bit maps': binaryRdata.slice(binaryLen).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  NSEC NextDomain TypeBitMaps
-    const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, next] = bindline.split(/\s+/)
     return new NSEC({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
       'next domain': next,
-      'type bit maps': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
+      'type bit maps': bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
     })
   }
 

package/rr/nsec3.js

@@ -64,6 +64,10 @@ export default class NSEC3 extends RR {
     return 'Next Secure'
   }
 
+  getTags() {
+    return ['dnssec']
+  }
+
   getRdataFields(arg) {
     return ['hash algorithm', 'flags', 'iterations', 'salt', 'next hashed owner name', 'type bit maps']
   }
@@ -76,12 +80,27 @@ export default class NSEC3 extends RR {
     return 50
   }
 
+  getCanonical() {
+    return {
+      owner: 'test.example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'NSEC3',
+      'hash algorithm': 1,
+      flags: 1,
+      iterations: 12,
+      salt: 'aabbccdd',
+      'next hashed owner name': '2vptu5timamqttgl4luu9kg21e0aor3s',
+      'type bit maps': 'A RRSIG',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com. 3600 IN NSEC3 1 1 12 aabbccdd (2vptu5timamqttgl4luu9kg21e0aor3s A RRSIG)
-    const [owner, ttl, c, type, ha, flags, iterations, salt] = opts.bindline.split(/\s+/)
-    const rdata = opts.bindline.split(/\(|\)/)[1]
+    const [owner, ttl, c, type, ha, flags, iterations, salt] = bindline.split(/\s+/)
+    const rdata = bindline.split(/\(|\)/)[1]
 
     return new NSEC3({
       owner,
@@ -97,8 +116,8 @@ export default class NSEC3 extends RR {
     })
   }
 
-  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 != 50) this.throwHelp('NSEC3 fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -112,7 +131,7 @@ export default class NSEC3 extends RR {
     // Salt (variable length based on Salt Length)
     // Next Hashed Owner Name (variable length)
     // Type Bit Maps (variable length)
-    const { salt, nextHashedOwnerName, typeBitMaps } = TINYDNS.parseNSEC3Buffer(bytes)
+    const { salt, nextHashedOwnerName, typeBitMaps } = parseNSEC3Buffer(bytes)
 
     return new NSEC3({
       owner: this.fullyQualify(fqdn),
@@ -125,7 +144,7 @@ export default class NSEC3 extends RR {
       'next hashed owner name': nextHashedOwnerName,
       'type bit maps': typeBitMaps,
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
@@ -155,3 +174,48 @@ export default class NSEC3 extends RR {
     )
   }
 }
+
+function parseNSEC3Buffer(bytes) {
+  // bytes is a Buffer containing the full RDATA binary (hash alg, flags, iterations, then ASCII salt + next-hashed + type bit maps)
+  // Start after the first 4 bytes (hash alg, flags, iterations)
+  const rest = bytes.slice(4).toString('utf8')
+
+  // determine expected next hashed owner name length from hash algorithm
+  const hashAlgorithm = bytes.readUInt8(0)
+  // common mapping: algorithm 1 => SHA-1 => 20 bytes => base32 length 32
+  const expectedLen = hashAlgorithm === 1 ? 32 : hashAlgorithm === 2 ? 52 : 32
+
+  // salt length is ambiguous in this representation; try to find a split where
+  // the following segment matches expected base32 length
+  let salt = ''
+  let nextHashedOwnerName = ''
+  let typeBitMaps = ''
+
+  const maxSl = Math.min(64, rest.length)
+  for (let sl = maxSl; sl >= 1; sl--) {
+    const candNext = rest.slice(sl, sl + expectedLen)
+    if (candNext.length !== expectedLen) continue
+    if (!/^[0-9a-z]+$/.test(candNext)) continue
+    // candidate looks like a base32 name; accept and treat remainder as type bit maps
+    const saltCandidate = rest.slice(0, sl)
+    if (!/^[0-9A-Fa-f]+$/.test(saltCandidate)) continue
+    salt = saltCandidate
+    nextHashedOwnerName = candNext
+    typeBitMaps = rest.slice(sl + expectedLen)
+    break
+  }
+
+  // fallback: if we couldn't find a split, treat everything up to first non-hex as salt
+  if (!nextHashedOwnerName) {
+    const saltMatch = rest.match(/^([0-9A-Fa-f]*)/)
+    salt = saltMatch ? saltMatch[1] : ''
+    nextHashedOwnerName = rest.slice(salt.length)
+    typeBitMaps = ''
+  }
+
+  return {
+    salt,
+    nextHashedOwnerName,
+    typeBitMaps,
+  }
+}