@nictool/dns-resource-record 1.4.0 → 1.6.0

package/rr/cert.js

@@ -11,8 +11,29 @@ export default class CERT extends RR {
   setCertType(val) {
     // The type field is the certificate type
     // the type field as an unsigned decimal integer or as a mnemonic symbol
-    // this.is16bitInt('CERT', 'type', val)
-
+    if (val === undefined || val === null || val === '') {
+      this.throwHelp('cert type is required')
+    }
+    // Accept both mnemonic and numeric, but validate mnemonic
+    if (typeof val === 'string') {
+      const types = {
+        PKIX: 1,
+        SPKI: 2,
+        PGP: 3,
+        IPKIX: 4,
+        ISPKI: 5,
+        IPGP: 6,
+        ACPKIX: 7,
+        IACPKIX: 8,
+        URI: 253,
+        OID: 254,
+      }
+      if (!Object.hasOwn(types, val)) {
+        this.throwHelp(`CERT: unknown cert type mnemonic: ${val}`)
+      }
+    } else {
+      this.is16bitInt('CERT', 'cert type', val)
+    }
     this.set('cert type', val)
   }
 
@@ -54,6 +75,9 @@ export default class CERT extends RR {
   setCertificate(val) {
     // certificate/CRL portion is represented in base 64 [16] and may be
     // divided into any number of white-space-separated substrings
+    if (val === undefined || val === null || val === '') {
+      this.throwHelp('certificate is required and cannot be empty')
+    }
     this.set('certificate', val)
   }
 
@@ -73,10 +97,23 @@ export default class CERT extends RR {
     return 37
   }
 
+  getCanonical() {
+    return {
+      owner: 'mail.example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'CERT',
+      'cert type': 'PGP',
+      'key tag': 0,
+      algorithm: 0,
+      certificate: 'hexidecimalkeystring1',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromTinydns(opts) {
-    const [owner, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [owner, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 37) this.throwHelp('CERT fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -106,13 +143,13 @@ export default class CERT extends RR {
       algorithm: bytes.readUInt8(4),
       certificate: bytes.slice(5).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  CERT  certtype, keytag, algo, cert
-    const [owner, ttl, c, type, certtype, keytag, algo, certificate] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, certtype, keytag, algo, certificate] = bindline.split(/\s+/)
     return new CERT({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/cname.js

@@ -25,6 +25,10 @@ export default class CNAME extends RR {
     return 'Canonical Name'
   }
 
+  getTags() {
+    return ['common']
+  }
+
   getRdataFields(arg) {
     return ['cname']
   }
@@ -37,10 +41,20 @@ export default class CNAME extends RR {
     return 5
   }
 
+  getCanonical() {
+    return {
+      owner: 'www.example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'CNAME',
+      cname: 'web.example.com.',
+    }
+  }
+
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // Cfqdn:p:ttl:timestamp:lo
-    const [fqdn, p, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, p, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new CNAME({
       owner: this.fullyQualify(fqdn),
@@ -48,13 +62,13 @@ export default class CNAME extends RR {
       type: 'CNAME',
       cname: this.fullyQualify(p),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  CNAME  ...
-    const [owner, ttl, c, type, cname] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, cname] = bindline.split(/\s+/)
     return new CNAME({
       owner,
       ttl: parseInt(ttl, 10),
@@ -65,6 +79,9 @@ export default class CNAME extends RR {
   }
 
   /******  EXPORTERS   *******/
+  getWireRdata() {
+    return this.wirePackDomain(this.get('cname'))
+  }
 
   toTinydns() {
     return `C${this.getTinyFQDN('owner')}:${this.get('cname')}:${this.getTinydnsPostamble()}\n`

package/rr/dhcid.js

@@ -40,9 +40,24 @@ export default class DHCID extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // DHCID via generic, :fqdn:49:rdata:ttl:timestamp:lo
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (n != 49) this.throwHelp('DHCID fromTinydns, invalid n')
+
+    return new DHCID({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'DHCID',
+      data: TINYDNS.octalToBase64(rdata),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // host.example.com  3600  IN  DHCID  <base64data>
-    const parts = opts.bindline.split(/\s+/)
+    const parts = bindline.split(/\s+/)
     const [owner, ttl, c, type] = parts
     return new DHCID({
       owner,

package/rr/dname.js

@@ -35,10 +35,20 @@ export default class DNAME extends RR {
     return 39
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'DNAME',
+      target: 'example.net.',
+    }
+  }
+
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // DNAME 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 != 39) this.throwHelp('DNAME fromTinydns, invalid n')
 
     return new DNAME({
@@ -47,13 +57,13 @@ export default class DNAME extends RR {
       target: TINYDNS.unpackDomainName(rdata)[0],
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  DNAME  ...
-    const [owner, ttl, c, type, target] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, target] = bindline.split(/\s+/)
     return new DNAME({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/dnskey.js

@@ -79,6 +79,10 @@ export default class DNSKEY extends RR {
     return 'DNS Public Key'
   }
 
+  getTags() {
+    return ['dnssec']
+  }
+
   getRdataFields(arg) {
     return ['flags', 'protocol', 'algorithm', 'publickey']
   }
@@ -91,14 +95,33 @@ export default class DNSKEY extends RR {
     return 48
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'DNSKEY',
+      flags: 256,
+      protocol: 3,
+      algorithm: 5,
+      publickey: 'AQPSKAsj8...',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  DNSKEY Flags Protocol Algorithm PublicKey
-    const regex = /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/
-    const match = opts.bindline.match(regex)
-    if (!match) this.throwHelp(`unable to parse DNSKEY: ${opts.bindline}`)
-    const [owner, ttl, c, type, flags, protocol, algorithm, publickey] = match.slice(1)
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d+)\s+(?<cls>\w+)\s+(?<type>DNSKEY)\s+(?<flags>\d+)\s+(?<protocol>\d+)\s+(?<algorithm>\d+)\s+(?<publickey>\S.*)$/i
+
+    const match = bindline.trim().match(regex)
+
+    if (!match) {
+      this.throwHelp(`unable to parse DNSKEY: ${bindline}`)
+    }
+
+    const { owner, ttl, c, type, flags, protocol, algorithm, publickey } = match.groups
 
     return new DNSKEY({
       owner,
@@ -112,8 +135,8 @@ export default class DNSKEY 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.substring(1).split(':')
     if (n != 48) this.throwHelp('DNSKEY fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -127,7 +150,7 @@ export default class DNSKEY extends RR {
       algorithm: bytes.readUInt8(3),
       publickey: bytes.slice(4).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/ds.js

@@ -50,6 +50,10 @@ export default class DS extends RR {
     return 'Delegation Signer'
   }
 
+  getTags() {
+    return ['dnssec']
+  }
+
   getRdataFields(arg) {
     return ['key tag', 'algorithm', 'digest type', 'digest']
   }
@@ -62,11 +66,24 @@ export default class DS extends RR {
     return 43
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'DS',
+      'key tag': 12345,
+      algorithm: 5,
+      'digest type': 1,
+      digest: 'ABCDEF123...',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  DS Key Tag Algorithm, Digest Type, Digest
-    const [owner, ttl, c, type, keytag, algorithm, digesttype] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, keytag, algorithm, digesttype] = bindline.split(/\s+/)
     return new DS({
       owner,
       ttl: parseInt(ttl, 10),
@@ -75,12 +92,12 @@ export default class DS extends RR {
       'key tag': parseInt(keytag, 10),
       algorithm: parseInt(algorithm, 10),
       'digest type': parseInt(digesttype, 10),
-      digest: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+      digest: bindline.split(/\s+/).slice(7).join(' ').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 != 43) this.throwHelp('DS fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -94,7 +111,7 @@ export default class DS extends RR {
       'digest type': binRdata.readUInt8(3),
       digest: binRdata.slice(4).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/hinfo.js

@@ -22,6 +22,10 @@ export default class HINFO extends RR {
     return 'Host Info'
   }
 
+  getTags() {
+    return ['obsolete']
+  }
+
   getRdataFields(arg) {
     return ['cpu', 'os']
   }
@@ -34,31 +38,45 @@ export default class HINFO extends RR {
     return 13
   }
 
+  getCanonical() {
+    return {
+      owner: 'test.example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'HINFO',
+      cpu: 'DEC-2060',
+      os: 'TOPS20',
+    }
+  }
+
   getQuotedFields() {
     return ['cpu', 'os']
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const regex = /^([\S]+)\s+([0-9]{1,10})\s+(IN)\s+(HINFO)\s+("[^"]+"|[\S]+)\s+("[^"]+"|[\S]+)/i
-    const match = opts.bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse HINFO: ${opts.bindline}`)
-    const [owner, ttl, c, type, cpu, os] = match.slice(1)
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<class>IN)\s+(?<type>HINFO)\s+(?:"(?<qCPU>[^"]*)"|(?<uCPU>\S+))\s+(?:"(?<qOS>[^"]*)"|(?<uOS>\S+))$/i
+
+    const match = bindline.trim().match(regex)
+    if (!match) this.throwHelp(`unable to parse HINFO: ${bindline}`)
+
+    const { owner, ttl, class: c, type, qCPU, uCPU, qOS, uOS } = match.groups
 
     return new HINFO({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type,
-      cpu,
-      os,
+      cpu: qCPU ?? uCPU,
+      os: qOS ?? uOS,
     })
   }
 
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // HINFO via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, , rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, , rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     const [cpu, os] = [...TINYDNS.unpackString(rdata)]
 
     return new this.constructor({
@@ -68,7 +86,7 @@ export default class HINFO extends RR {
       cpu,
       os,
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/hip.js

@@ -59,9 +59,50 @@ export default class HIP extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // HIP via generic, :fqdn:55:rdata:ttl:timestamp:lo
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (n != 55) this.throwHelp('HIP fromTinydns, invalid n')
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const hitLen = bytes.readUInt8(0)
+    const pkAlgorithm = bytes.readUInt8(1)
+    const pkLen = bytes.readUInt16BE(2)
+
+    const hit = bytes
+      .slice(4, 4 + hitLen)
+      .toString('hex')
+      .toUpperCase()
+    const publicKey = bytes.slice(4 + hitLen, 4 + hitLen + pkLen).toString('base64')
+
+    const rvsNames = []
+    let pos = 4 + hitLen + pkLen
+    while (pos < bytes.length) {
+      const [name, newPos] = TINYDNS.unpackDomainName(
+        [...bytes.slice(pos)]
+          .map((b) => (b < 32 || b > 126 ? TINYDNS.UInt8toOctal(b) : String.fromCharCode(b)))
+          .join(''),
+      )
+      pos += newPos
+      if (name !== '.') rvsNames.push(name)
+    }
+
+    return new HIP({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'HIP',
+      'pk algorithm': pkAlgorithm,
+      hit,
+      'public key': publicKey,
+      'rendezvous servers': rvsNames.join(' '),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // owner  ttl  IN  HIP  pk-algorithm HIT public-key [rendezvous-server...]
-    const parts = opts.bindline.split(/\s+/)
+    const parts = bindline.split(/\s+/)
     const [owner, ttl, c, type, pkAlgorithm, hit, publicKey] = parts
     return new HIP({
       owner,

package/rr/https.js

@@ -32,6 +32,10 @@ export default class HTTPS extends RR {
     return 'HTTP Semantics'
   }
 
+  getTags() {
+    return ['common']
+  }
+
   getRdataFields(arg) {
     return ['priority', 'target name', 'params']
   }
@@ -44,11 +48,23 @@ export default class HTTPS extends RR {
     return 65
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'HTTPS',
+      priority: 1,
+      'target name': 'example.com.',
+      params: 'alpn="h2,h3"',
+    }
+  }
+
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  HTTPS Priority TargetName Params
-    const [owner, ttl, c, type, pri, fqdn] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pri, fqdn] = bindline.split(/\s+/)
     return new HTTPS({
       owner,
       ttl: parseInt(ttl, 10),
@@ -56,20 +72,31 @@ export default class HTTPS 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(`HTTPS: RDATA too short: ${rd}`)
     }
 
-    const priority = TINYDNS.octalToUInt16(rd.substring(0, 6))
-    const remaining = rd.slice(6)
-
-    const [targetName, consumed] = TINYDNS.unpackDomainName(remaining)
-    const params = TINYDNS.escapeOctal(remaining.slice(consumed))
+    const binary = Buffer.from(TINYDNS.octalToChar(rd), 'binary')
+    const priority = binary.readUInt16BE(0)
+
+    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('.')}.`
+    const params = binary.slice(pos).toString()
 
     return new HTTPS({
       owner: this.fullyQualify(owner),
@@ -78,6 +105,8 @@ export default class HTTPS extends RR {
       priority,
       'target name': targetName,
       params,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/ipseckey.js

@@ -71,6 +71,10 @@ export default class IPSECKEY extends RR {
     return 'IPsec Keying'
   }
 
+  getTags() {
+    return ['security']
+  }
+
   getRdataFields(arg) {
     return ['precedence', 'gateway type', 'algorithm', 'gateway', 'publickey']
   }
@@ -98,9 +102,9 @@ export default class IPSECKEY extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // FQDN TTL CLASS IPSECKEY Precedence GatewayType Algorithm Gateway PublicKey
-    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] = bindline.split(/\s+/)
     return new IPSECKEY({
       owner,
       ttl: parseInt(ttl, 10),
@@ -114,32 +118,32 @@ export default class IPSECKEY 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 != 45) this.throwHelp('IPSECKEY fromTinydns, invalid n')
 
-    const precedence = TINYDNS.octalToUInt8(rdata.substring(0, 4))
-    const gwType = TINYDNS.octalToUInt8(rdata.substring(4, 8))
-    const algorithm = TINYDNS.octalToUInt8(rdata.substring(8, 12))
+    const precedence = TINYDNS.octalToUInt8(rdata.slice(0, 4))
+    const gwType = TINYDNS.octalToUInt8(rdata.slice(4, 8))
+    const algorithm = TINYDNS.octalToUInt8(rdata.slice(8, 12))
 
     let len, gateway, octalKey
 
     switch (gwType) {
       case 0: // no gateway
-        gateway = rdata.substring(12, 13) // should always be: '.'
-        octalKey = rdata.substring(13)
+        gateway = rdata.slice(12, 13) // should always be: '.'
+        octalKey = rdata.slice(13)
         break
       case 1: // 4-byte IPv4 address
-        gateway = TINYDNS.octalToIPv4(rdata.substring(12, 28))
-        octalKey = rdata.substring(28)
+        gateway = TINYDNS.octalToIPv4(rdata.slice(12, 28))
+        octalKey = rdata.slice(28)
         break
       case 2: // 16-byte IPv6
-        gateway = TINYDNS.octalToHex(rdata.substring(12, 76))
-        octalKey = rdata.substring(76)
+        gateway = TINYDNS.octalToIPv6(rdata.slice(12, 76))
+        octalKey = rdata.slice(76)
         break
       case 3: // wire encoded domain name
-        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.substring(12))
-        octalKey = rdata.substring(12 + len)
+        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.slice(12))
+        octalKey = rdata.slice(12 + len)
         break
     }
 
@@ -153,7 +157,7 @@ export default class IPSECKEY extends RR {
       gateway,
       publickey: TINYDNS.octalToBase64(octalKey),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }