@nictool/dns-resource-record 1.1.7 → 1.2.1

package/rr/srv.js

@@ -1,38 +1,37 @@
-
-import net from 'net'
+import net from 'node:net'
 
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class SRV extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPriority (val) {
+  setPriority(val) {
     this.is16bitInt('SRV', 'priority', val)
 
     this.set('priority', val)
   }
 
-  setPort (val) {
+  setPort(val) {
     this.is16bitInt('SRV', 'port', val)
 
     this.set('port', val)
   }
 
-  setWeight (val) {
+  setWeight(val) {
     this.is16bitInt('SRV', 'weight', val)
 
     this.set('weight', val)
   }
 
-  setTarget (val) {
-    if (!val) throw new Error(`SRV: target is required, ${this.citeRFC()}`)
+  setTarget(val) {
+    if (!val) this.throwHelp(`SRV: target is required`)
 
     if (net.isIPv4(val) || net.isIPv6(val))
-      throw new Error(`SRV: target must be a FQDN, ${this.citeRFC()}`)
+      this.throwHelp(`SRV: target must be a FQDN`)
 
     this.isFullyQualified('SRV', 'target', val)
     this.isValidHostname('SRV', 'target', val)
@@ -41,77 +40,78 @@ export default class SRV extends RR {
     this.set('target', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Service'
   }
 
-  getRdataFields (arg) {
-    return [ 'priority', 'weight', 'port', 'target' ]
+  getRdataFields(arg) {
+    return ['priority', 'weight', 'port', 'target']
   }
 
-  getRFCs () {
-    return [ 2782 ]
+  getRFCs() {
+    return [2782]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 33
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     const str = opts.tinyline
     let fqdn, addr, port, pri, weight, ttl, ts, loc, n, rdata
 
     if (str[0] === 'S') {
       // patched tinydns with S records
-      [ fqdn, addr, port, pri, weight, ttl, ts, loc ] = str.substring(1).split(':')
-    }
-    else {
+      ;[fqdn, addr, port, pri, weight, ttl, ts, loc] = str
+        .substring(1)
+        .split(':')
+    } else {
       // tinydns generic record format
-      [ fqdn, n, rdata, ttl, ts, loc ] = str.substring(1).split(':')
-      if (n != 33) throw new Error('SRV fromTinydns: invalid n')
+      ;[fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
+      if (n != 33) this.throwHelp('SRV fromTinydns: invalid n')
 
-      pri    = TINYDNS.octalToUInt16(rdata.substring(0, 8))
+      pri = TINYDNS.octalToUInt16(rdata.substring(0, 8))
       weight = TINYDNS.octalToUInt16(rdata.substring(8, 16))
-      port   = TINYDNS.octalToUInt16(rdata.substring(16, 24))
-      addr   = (TINYDNS.unpackDomainName(rdata.substring(24)))[0]
+      port = TINYDNS.octalToUInt16(rdata.substring(16, 24))
+      addr = TINYDNS.unpackDomainName(rdata.substring(24))[0]
     }
 
     return new SRV({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl,    10),
-      type     : 'SRV',
-      priority : parseInt(pri,    10),
-      weight   : parseInt(weight, 10),
-      port     : parseInt(port,   10),
-      target   : this.fullyQualify(addr),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'SRV',
+      priority: parseInt(pri, 10),
+      weight: parseInt(weight, 10),
+      port: parseInt(port, 10),
+      target: this.fullyQualify(addr),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  SRV Priority Weight Port Target
-    const [ owner, ttl, c, type, pri, weight, port, target ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pri, weight, port, target] =
+      opts.bindline.split(/\s+/)
     return new SRV({
-      owner   : owner,
-      ttl     : parseInt(ttl,    10),
-      class   : c,
-      type    : type,
-      priority: parseInt(pri,    10),
-      weight  : parseInt(weight, 10),
-      port    : parseInt(port,   10),
-      target  : target,
+      owner: owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      priority: parseInt(pri, 10),
+      weight: parseInt(weight, 10),
+      port: parseInt(port, 10),
+      target: target,
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
-
+  toTinydns() {
     let rdata = ''
 
-    for (const e of [ 'priority', 'weight', 'port' ]) {
+    for (const e of ['priority', 'weight', 'port']) {
       rdata += TINYDNS.UInt16toOctal(this.get(e))
     }
 

package/rr/sshfp.js

@@ -1,86 +1,85 @@
-
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class SSHFP extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // 0: reserved  1: RSA  2: DSA  3: ECDSA  4: Ed25519  6: Ed448
     this.is8bitInt('SSHFP', 'algorithm', val)
 
     this.set('algorithm', val)
   }
 
-  setFptype (val) {
+  setFptype(val) {
     // 0: reserved, 1: SHA-1, 2: SHA-256
     this.is8bitInt('SSHFP', 'type', val)
 
     this.set('fptype', val)
   }
 
-  setFingerprint (val) {
+  setFingerprint(val) {
     this.set('fingerprint', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Secure Shell Key Fingerprints'
   }
 
-  getRdataFields () {
-    return [ 'algorithm', 'fptype', 'fingerprint' ]
+  getRdataFields() {
+    return ['algorithm', 'fptype', 'fingerprint']
   }
 
-  getRFCs () {
-    return [ 4255, 7479, 8709 ]
+  getRFCs() {
+    return [4255, 7479, 8709]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 44
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // SSHFP via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 44) throw new Error('SSHFP fromTinydns, invalid n')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 44) this.throwHelp('SSHFP fromTinydns, invalid n')
 
     return new SSHFP({
-      owner      : this.fullyQualify(fqdn),
-      ttl        : parseInt(ttl, 10),
-      type       : 'SSHFP',
-      algorithm  : TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      fptype     : TINYDNS.octalToUInt8(rdata.substring(4, 8)),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'SSHFP',
+      algorithm: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
+      fptype: TINYDNS.octalToUInt8(rdata.substring(4, 8)),
       fingerprint: TINYDNS.octalToHex(rdata.substring(8)),
-      timestamp  : ts,
-      location   : loc !== '' && loc !== '\n' ? loc : '',
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  SSHFP  algo fptype fp
-    const [ owner, ttl, c, type, algo, fptype, fp ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, algo, fptype, fp] = opts.bindline.split(/\s+/)
     return new SSHFP({
       owner,
-      ttl        : parseInt(ttl, 10),
-      class      : c,
-      type       : type,
-      algorithm  : parseInt(algo, 10),
-      fptype     : parseInt(fptype, 10),
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      algorithm: parseInt(algo, 10),
+      fptype: parseInt(fptype, 10),
       fingerprint: fp,
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('algorithm')) +
-      TINYDNS.UInt8toOctal(this.get('fptype')) +
-      TINYDNS.packHex(this.get('fingerprint'))
+        TINYDNS.UInt8toOctal(this.get('fptype')) +
+        TINYDNS.packHex(this.get('fingerprint')),
     )
   }
 }

package/rr/svcb.js

@@ -0,0 +1,64 @@
+import RR from '../rr.js'
+
+export default class SVCB extends RR {
+  constructor(opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPriority(val) {
+    this.is16bitInt('SVCB', 'priority', val)
+
+    this.set('priority', val)
+  }
+
+  setTargetName(val) {
+    // this.isFullyQualified('SVCB', 'target name', val)
+    // this.isValidHostname('SVCB', 'target name', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('target name', val.toLowerCase())
+  }
+
+  setParams(val) {
+    // if (!val) throw new Error(`SVCB: params is required`)
+
+    this.set('params', val)
+  }
+
+  getDescription() {
+    return 'Service Binding'
+  }
+
+  getRdataFields(arg) {
+    return ['priority', 'target name', 'params']
+  }
+
+  getRFCs() {
+    return [9460]
+  }
+
+  getTypeId() {
+    return 64
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind(opts) {
+    // 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+/)
+    return new SVCB({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type,
+      priority: parseInt(pri, 10),
+      'target name': fqdn,
+      params: opts.bindline.split(/\s+/).slice(6).join(' ').trim(),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}

package/rr/tlsa.js

@@ -1,106 +1,111 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class TLSA extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCertificateUsage (val) {
-    if (![ 0,1,2,3 ].includes(val))
-      throw new Error(`TLSA: certificate usage invalid, ${this.citeRFC()}`)
+  setCertificateUsage(val) {
+    if (![0, 1, 2, 3].includes(val))
+      this.throwHelp(`TLSA: certificate usage invalid`)
 
     this.set('certificate usage', val)
   }
 
-  setSelector (val) {
-    if (![ 0,1 ].includes(val))
-      throw new Error(`TLSA: selector invalid, ${this.citeRFC()}`)
+  setSelector(val) {
+    if (![0, 1].includes(val)) this.throwHelp(`TLSA: selector invalid`)
 
     this.set('selector', val)
   }
 
-  setMatchingType (val) {
-    if (![ 0,1,2 ].includes(val))
-      throw new Error(`TLSA: matching type, ${this.citeRFC()}`)
+  setMatchingType(val) {
+    if (![0, 1, 2].includes(val)) this.throwHelp(`TLSA: matching type`)
 
     this.set('matching type', val)
   }
 
-  setCertificateAssociationData (val) {
+  setCertificateAssociationData(val) {
     this.set('certificate association data', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'TLSA certificate association'
   }
 
-  getRdataFields (arg) {
-    return [ 'certificate usage', 'selector', 'matching type', 'certificate association data' ]
+  getRdataFields(arg) {
+    return [
+      'certificate usage',
+      'selector',
+      'matching type',
+      'certificate association data',
+    ]
   }
 
-  getRFCs () {
-    return [ 6698 ]
+  getRFCs() {
+    return [6698]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 52
   }
 
-  getQuotedFields () {
-    return [  ]
+  getQuotedFields() {
+    return []
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  TLSA, usage, selector, match, data
-    const match = opts.bindline.split(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*?)\s*$/)
-    if (!match) throw new Error(`unable to parse TLSA: ${opts.bindline}`)
-    const [ owner, ttl, c, type, usage, selector, matchtype, cad ] = match.slice(1)
+    const match = opts.bindline.split(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*?)\s*$/,
+    )
+    if (!match) this.throwHelp(`unable to parse TLSA: ${opts.bindline}`)
+    const [owner, ttl, c, type, usage, selector, matchtype, cad] =
+      match.slice(1)
     return new TLSA({
-      owner                         : this.fullyQualify(owner),
-      ttl                           : parseInt(ttl, 10),
-      class                         : c,
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
-      'certificate usage'           : parseInt(usage,     10),
-      selector                      : parseInt(selector,  10),
-      'matching type'               : parseInt(matchtype, 10),
+      'certificate usage': parseInt(usage, 10),
+      selector: parseInt(selector, 10),
+      'matching type': parseInt(matchtype, 10),
       'certificate association data': cad,
     })
   }
 
-  fromTinydns (opts) {
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 52) throw new Error('TLSA fromTinydns, invalid n')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 52) this.throwHelp('TLSA fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     return new TLSA({
-      owner                         : this.fullyQualify(fqdn),
-      ttl                           : parseInt(ttl, 10),
-      type                          : 'TLSA',
-      'certificate usage'           : bytes.readUInt8(0),
-      selector                      : bytes.readUInt8(1),
-      'matching type'               : bytes.readUInt8(2),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'TLSA',
+      'certificate usage': bytes.readUInt8(0),
+      selector: bytes.readUInt8(1),
+      'matching type': bytes.readUInt8(2),
       'certificate association data': bytes.slice(3).toString(),
-      timestamp                     : ts,
-      location                      : loc !== '' && loc !== '\n' ? loc : '',
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('certificate usage')) +
-      TINYDNS.UInt8toOctal(this.get('selector')) +
-      TINYDNS.UInt8toOctal(this.get('matching type')) +
-      TINYDNS.escapeOctal(dataRe, this.get('certificate association data'))
+        TINYDNS.UInt8toOctal(this.get('selector')) +
+        TINYDNS.UInt8toOctal(this.get('matching type')) +
+        TINYDNS.escapeOctal(dataRe, this.get('certificate association data')),
     )
   }
 }

package/rr/tsig.js

@@ -0,0 +1,56 @@
+import RR from '../rr.js'
+
+export default class TSIG extends RR {
+  constructor(opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+
+  getDescription() {
+    return 'Transaction Signature'
+  }
+
+  getRdataFields(arg) {
+    return [
+      'algorithm name',
+      'time signed',
+      'fudge',
+      'mac',
+      'original id',
+      'error',
+      'other',
+    ]
+  }
+
+  getRFCs() {
+    return [2845]
+  }
+
+  getTypeId() {
+    return 250
+  }
+
+  /******  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+/)
+    return new TSIG({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      algorithm: algorithm,
+      // 'time signed': opts.bindline,
+      // fudge
+      // mac
+      // original id
+      // error
+      // other
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}