@nictool/dns-resource-record 1.1.3

package/rr/srv.js

@@ -0,0 +1,122 @@
+
+import net from 'net'
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class SRV extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPriority (val) {
+    this.is16bitInt('SRV', 'priority', val)
+
+    this.set('priority', val)
+  }
+
+  setPort (val) {
+    this.is16bitInt('SRV', 'port', val)
+
+    this.set('port', 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()}`)
+
+    if (net.isIPv4(val) || net.isIPv6(val))
+      throw new Error(`SRV: target must be a FQDN, ${this.citeRFC()}`)
+
+    this.isFullyQualified('SRV', 'target', val)
+    this.isValidHostname('SRV', 'target', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('target', val.toLowerCase())
+  }
+
+  getDescription () {
+    return 'Service'
+  }
+
+  getRdataFields (arg) {
+    return [ 'priority', 'weight', 'port', 'target' ]
+  }
+
+  getRFCs () {
+    return [ 2782 ]
+  }
+
+  getTypeId () {
+    return 33
+  }
+
+  /******  IMPORTERS   *******/
+  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 {
+      // tinydns generic record format
+      [ fqdn, n, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+      if (n != 33) throw new Error('SRV fromTinydns: invalid n')
+
+      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]
+    }
+
+    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),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  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+/)
+    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,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+
+    let rdata = ''
+
+    for (const e of [ 'priority', 'weight', 'port' ]) {
+      rdata += TINYDNS.UInt16toOctal(this.get(e))
+    }
+
+    rdata += TINYDNS.packDomainName(this.get('target'))
+
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/sshfp.js

@@ -0,0 +1,86 @@
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class SSHFP extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  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) {
+    // 0: reserved, 1: SHA-1, 2: SHA-256
+    this.is8bitInt('SSHFP', 'type', val)
+
+    this.set('fptype', val)
+  }
+
+  setFingerprint (val) {
+    this.set('fingerprint', val)
+  }
+
+  getDescription () {
+    return 'Secure Shell Key Fingerprints'
+  }
+
+  getRdataFields () {
+    return [ 'algorithm', 'fptype', 'fingerprint' ]
+  }
+
+  getRFCs () {
+    return [ 4255 ]
+  }
+
+  getTypeId () {
+    return 44
+  }
+
+  /******  IMPORTERS   *******/
+  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')
+
+    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)),
+      fingerprint: TINYDNS.octalToHex(rdata.substring(8)),
+      timestamp  : ts,
+      location   : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  SSHFP  algo fptype fp
+    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),
+      fingerprint: fp,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt8toOctal(this.get('algorithm')) +
+      TINYDNS.UInt8toOctal(this.get('fptype')) +
+      TINYDNS.packHex(this.get('fingerprint'))
+    )
+  }
+}

package/rr/tlsa.js

@@ -0,0 +1,106 @@
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class TLSA extends RR {
+  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()}`)
+
+    this.set('certificate usage', val)
+  }
+
+  setSelector (val) {
+    if (![ 0,1 ].includes(val))
+      throw new Error(`TLSA: selector invalid, ${this.citeRFC()}`)
+
+    this.set('selector', val)
+  }
+
+  setMatchingType (val) {
+    if (![ 0,1,2 ].includes(val))
+      throw new Error(`TLSA: matching type, ${this.citeRFC()}`)
+
+    this.set('matching type', val)
+  }
+
+  setCertificateAssociationData (val) {
+    this.set('certificate association data', val)
+  }
+
+  getDescription () {
+    return 'TLSA certificate association'
+  }
+
+  getRdataFields (arg) {
+    return [ 'certificate usage', 'selector', 'matching type', 'certificate association data' ]
+  }
+
+  getRFCs () {
+    return [ 6698 ]
+  }
+
+  getTypeId () {
+    return 52
+  }
+
+  getQuotedFields () {
+    return [  ]
+  }
+
+  /******  IMPORTERS   *******/
+
+  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)
+    return new TLSA({
+      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 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')
+
+    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),
+      'certificate association data': bytes.slice(3).toString(),
+      timestamp                     : ts,
+      location                      : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  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'))
+    )
+  }
+}

package/rr/txt.js

@@ -0,0 +1,122 @@
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class TXT extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setData (val) {
+    this.set('data', val)
+  }
+
+  getDescription () {
+    return 'Text'
+  }
+
+  getRdataFields (arg) {
+    return [ 'data' ]
+  }
+
+  getRFCs () {
+    return [ 1035 ]
+  }
+
+  getTypeId () {
+    return 16
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    const str = opts.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(':')
+      rdata = TINYDNS.octalToChar(s)
+    }
+    else {
+      [ fqdn, rdata, ttl, ts, loc ] = this.fromTinydnsGeneric(str)
+    }
+
+    return new this.constructor({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'TXT',
+      data     : rdata,
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  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(':')
+    if (n != 16) throw new Error('TXT fromTinydns, invalid n')
+
+    rdata = TINYDNS.octalToChar(rdata)
+    let s = ''
+    let len = rdata[0].charCodeAt(0)
+    let pos = 1
+    while (pos < rdata.length) {
+      s += rdata.substring(pos, +(len + pos))
+      pos = len + pos
+      len = rdata.charCodeAt(pos + 1)
+    }
+    return [ fqdn, s, ttl, ts, loc ]
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  TXT  "..."
+    const match = opts.bindline.split(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+?\s*(.*?)\s*$/)
+    if (!match) throw new Error(`unable to parse TXT: ${opts.bindline}`)
+    const [ owner, ttl, c, type, rdata ] = match.slice(1)
+
+    return new this.constructor({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type,
+      data : rdata.match(/"([^"]+?)"/g).map(s => s.replace(/^"|"$/g, '')).join(''),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toBind (zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t"${asQuotedStrings(this.get('data'))}"\n`
+  }
+
+  toMaraDNS () {
+    const data = asQuotedStrings(this.get('data')).replace(/"/g, "'")
+    return `${this.get('owner')}\t+${this.get('ttl')}\t${this.get('type')}\t'${data}' ~\n`
+  }
+
+  toTinydns () {
+    let data = this.get('data')
+    if (Array.isArray(data)) data = data.join('')
+    const rdata = TINYDNS.escapeOctal(new RegExp(/[\r\n\t:\\/]/, 'g'), data)
+    return `'${this.getTinyFQDN('owner')}:${rdata}:${this.getTinydnsPostamble()}\n`
+  }
+}
+
+function asQuotedStrings (data) {
+
+  // BIND croaks when any string in the TXT RR data is longer than 255
+  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('" "')
+  }
+
+  if (data.length > 255) {
+    return data.match(/(.{1,255})/g).join('" "')
+  }
+
+  return data
+}

package/rr/uri.js

@@ -0,0 +1,95 @@
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class URI extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPriority (val) {
+    this.is16bitInt('URI', 'priority', val)
+
+    this.set('priority', val)
+  }
+
+  setWeight (val) {
+    this.is16bitInt('URI', 'weight', val)
+
+    this.set('weight', val)
+  }
+
+  setTarget (val) {
+    if (!val) throw new Error(`URI: target is required, ${this.citeRFC()}`)
+
+    this.set('target', val)
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // URI via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 256) throw new Error('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)),
+      ttl      : parseInt(ttl, 10),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  URI  priority, weight, target
+    const [ owner, ttl, c, type, priority, weight, target ] = opts.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
+  }
+
+  getQuotedFields () {
+    return [ 'target' ]
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+    let rdata = ''
+
+    for (const e of [ 'priority', 'weight' ]) {
+      rdata += TINYDNS.UInt16toOctal(this.get(e))
+    }
+
+    rdata += TINYDNS.escapeOctal(dataRe, this.get('target'))
+    return this.getTinydnsGeneric(rdata)
+  }
+}