@nictool/dns-resource-record 1.1.3

package/rr/dname.js

@@ -0,0 +1,74 @@
+import net from 'net'
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class DNAME extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setTarget (val) {
+    if (!val) throw new Error('DNAME: target is required')
+
+    if (net.isIPv4(val) || net.isIPv6(val))
+      throw new Error(`DNAME: target must be a domain name, ${this.citeRFC()}`)
+
+    this.isFullyQualified('DNAME', 'target', val)
+    this.isValidHostname('DNAME', 'target', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('target', val.toLowerCase())
+  }
+
+  getDescription () {
+    return 'Delegation Name'
+  }
+
+  getRdataFields (arg) {
+    return [ 'target' ]
+  }
+
+  getRFCs () {
+    return [ 2672, 6672 ]
+  }
+
+  getTypeId () {
+    return 39
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // DNAME via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 39) throw new Error('DNAME fromTinydns, invalid n')
+
+    return new DNAME({
+      type     : 'DNAME',
+      owner    : this.fullyQualify(fqdn),
+      target   : (TINYDNS.unpackDomainName(rdata))[0],
+      ttl      : parseInt(ttl, 10),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  DNAME  ...
+    const [ owner, ttl, c, type, target ] = opts.bindline.split(/\s+/)
+    return new DNAME({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type,
+      target,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+    const rdata = TINYDNS.packDomainName(this.get('target'))
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/dnskey.js

@@ -0,0 +1,117 @@
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class DNSKEY extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setFlags (val) {
+    // a 2 octet Flags Field
+    this.is16bitInt('DNSKEY', 'flags', val)
+
+    // the possible values are: 0, 256, and 257; RFC 4034
+    if (![ 0, 256, 257 ].includes(val)) throw new Error(`DNSKEY: flags invalid, ${this.citeRFC()}`)
+
+    this.set('flags', val)
+  }
+
+  setProtocol (val) {
+    // 1 octet
+    this.is8bitInt('DNSKEY', 'protocol', val)
+
+    // The Protocol Field MUST be represented as an unsigned decimal integer with a value of 3.
+    if (![ 3 ].includes(val)) throw new Error(`DNSKEY: protocol invalid, ${this.citeRFC()}`)
+
+    this.set('protocol', val)
+  }
+
+  setAlgorithm (val) {
+    // 1 octet
+    this.is8bitInt('DNSKEY', 'algorithm', val)
+
+    // https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
+    // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
+    if (![ ...Array(16).keys(),253,254 ].includes(val))
+      console.error(`DNSKEY: algorithm (${val}) not recognized, ${this.citeRFC()}`)
+
+    this.set('algorithm', val)
+  }
+
+  setPublickey (val) {
+    if (!val) throw new Error(`DNSKEY: publickey is required, ${this.citeRFC()}`)
+
+    this.set('publickey', val)
+  }
+
+  getDescription () {
+    return 'DNS Public Key'
+  }
+
+  getRdataFields (arg) {
+    return [ 'flags', 'protocol', 'algorithm', 'publickey' ]
+  }
+
+  getRFCs () {
+    return [ 4034, 6014, 8624 ]
+  }
+
+  getTypeId () {
+    return 48
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  DNSKEY Flags Protocol Algorithm PublicKey
+    const match = opts.bindline.match(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/)
+    if (!match) throw new Error(`unable to parse DNSKEY: ${opts.bindline}`)
+    const [ owner, ttl, c, type, flags, protocol, algorithm, publickey ] = match.slice(1)
+
+    return new DNSKEY({
+      owner,
+      ttl      : parseInt(ttl, 10),
+      class    : c,
+      type     : type,
+      flags    : parseInt(flags,     10),
+      protocol : parseInt(protocol, 10),
+      algorithm: parseInt(algorithm,  10),
+      publickey: publickey,
+    })
+  }
+
+  fromTinydns (opts) {
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 48) throw new Error('DNSKEY fromTinydns, invalid n')
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+
+    return new DNSKEY({
+      owner      : this.fullyQualify(fqdn),
+      ttl        : parseInt(ttl, 10),
+      type       : 'DNSKEY',
+      flags      : bytes.readUInt16BE(0),
+      protocol   : bytes.readUInt8(2),
+      'algorithm': bytes.readUInt8(3),
+      'publickey': bytes.slice(4).toString(),
+      timestamp  : ts,
+      location   : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('flags')) +
+      TINYDNS.UInt8toOctal(this.get('protocol')) +
+      TINYDNS.UInt8toOctal(this.get('algorithm')) +
+      TINYDNS.escapeOctal(dataRe, this.get('publickey'))
+    )
+  }
+}

package/rr/ds.js

@@ -0,0 +1,104 @@
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class DS extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setKeyTag (val) {
+    // a 2 octet Key Tag field...in network byte order
+    if (!val) throw new Error(`DS: key tag is required`)
+    if (val.length > 2) throw new Error(`DS: key tag is too long, ${this.citeRFC()}`)
+
+    this.set('key tag', val)
+  }
+
+  setAlgorithm (val) {
+    // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
+    if (![ 1,2,3,4,5,253,254 ].includes(val))
+      throw new Error(`DS: algorithm invalid, ${this.citeRFC()}`)
+
+    this.set('algorithm', val)
+  }
+
+  setDigestType (val) {
+    if (![ 1,2 ].includes(val)) throw new Error(`DS: digest type invalid, ${this.citeRFC()}`)
+
+    this.set('digest type', val)
+  }
+
+  setDigest (val) {
+    if (!val) throw new Error(`DS: digest is required, ${this.citeRFC()}`)
+
+    this.set('digest', val)
+  }
+
+  getDescription () {
+    return 'Delegation Signer'
+  }
+
+  getRdataFields (arg) {
+    return [ 'key tag', 'algorithm', 'digest type', 'digest' ]
+  }
+
+  getRFCs () {
+    return [ 4034, 4509 ]
+  }
+
+  getTypeId () {
+    return 43
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  DS Key Tag Algorithm, Digest Type, Digest
+    const [ owner, ttl, c, type, keytag, algorithm, digesttype ] = opts.bindline.split(/\s+/)
+    return new DS({
+      owner,
+      ttl          : parseInt(ttl, 10),
+      class        : c,
+      type,
+      'key tag'    : parseInt(keytag,     10),
+      algorithm    : parseInt(algorithm,  10),
+      'digest type': parseInt(digesttype, 10),
+      digest       : opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+    })
+  }
+
+  fromTinydns (opts) {
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 43) throw new Error('DS fromTinydns, invalid n')
+
+    const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+
+    return new DS({
+      owner        : this.fullyQualify(fqdn),
+      ttl          : parseInt(ttl, 10),
+      type         : 'DS',
+      'key tag'    : binRdata.readUInt16BE(0),
+      algorithm    : binRdata.readUInt8(2),
+      'digest type': binRdata.readUInt8(3),
+      digest       : binRdata.slice(4).toString(),
+      timestamp    : ts,
+      location     : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+    const rdataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('key tag')) +
+      TINYDNS.UInt8toOctal(this.get('algorithm')) +
+      TINYDNS.UInt8toOctal(this.get('digest type')) +
+      TINYDNS.escapeOctal(rdataRe, this.get('digest'))
+    )
+  }
+}

package/rr/hinfo.js

@@ -0,0 +1,84 @@
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class HINFO extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setCpu (val) {
+    if (val.length > 255) throw new Error('HINFO cpu cannot exceed 255 chars')
+    this.set('cpu', val.replace(/^["']|["']$/g, ''))
+  }
+
+  setOs (val) {
+    if (val.length > 255) throw new Error('HINFO os cannot exceed 255 chars')
+    this.set('os', val.replace(/^["']|["']$/g, ''))
+  }
+
+  getDescription () {
+    return 'Host Info'
+  }
+
+  getRdataFields (arg) {
+    return [ 'cpu', 'os' ]
+  }
+
+  getRFCs () {
+    return [ 1034, 1035, 8482 ]
+  }
+
+  getTypeId () {
+    return 13
+  }
+
+  getQuotedFields () {
+    return [ 'cpu', 'os' ]
+  }
+
+  /******  IMPORTERS   *******/
+  fromBind (opts) {
+    // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
+    const match = opts.bindline.match(/([^\s]+)\s+([0-9]+)\s+(IN)\s+(HINFO)\s+("[^"]+"|[^\s]+)\s+("[^"]+"|[^\s]+)/i)
+    if (!match) throw new Error(`unable to parse HINFO: ${opts.bindline}`)
+    const [ owner, ttl, c, type, cpu, os ] = match.slice(1)
+
+    return new HINFO({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type,
+      cpu,
+      os,
+    })
+  }
+
+  fromTinydns (opts) {
+    // HINFO via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    const [ fqdn, , rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [ cpu, os ] = [ ...TINYDNS.unpackString(rdata) ]
+
+    return new this.constructor({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'HINFO',
+      cpu,
+      os,
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+    return this.getTinydnsGeneric(
+      [
+        TINYDNS.packString(this.get('cpu')),
+        TINYDNS.packString(this.get('os')),
+      ].join('')
+    )
+  }
+}

package/rr/ipseckey.js

@@ -0,0 +1,159 @@
+
+import net from 'net'
+
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class IPSECKEY extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPrecedence (val) {
+    // an 8-bit precedence for this record.
+    this.is8bitInt('IPSECKEY', 'precedence', val)
+
+    this.set('precedence', val)
+  }
+
+  setGatewayType (val) {
+    // 0 (none), 1 (4-byte IPv4), 2 (16-byte IPv6), 3 (wire encoded domain name)
+    if (![ 0,1,2,3 ].includes(val))
+      throw new Error(`IPSECKEY: Gateway Type is invalid, ${this.citeRFC()}`)
+
+    this.set('gateway type', val)
+  }
+
+  setAlgorithm (val) {
+    // unsigned int, 1 octet, values: 1=DSA, 2=RSA
+    if (![ 1,2 ].includes(val))
+      throw new Error(`IPSECKEY: Algorithm invalid, ${this.citeRFC()}`)
+
+    this.set('algorithm', val)
+  }
+
+  setGateway (val) {
+    const gwErr = new Error(`IPSECKEY: gateway invalid (${val}), ${this.citeRFC()}`)
+    switch (this.get('gateway type')) {
+      case 0: if (val !== '.') throw gwErr; break
+      case 1: if (!net.isIPv4(val)) throw gwErr; break
+      case 2: if (!net.isIPv6(val)) throw gwErr; break
+    }
+
+    this.set('gateway', val)
+  }
+
+  setPublickey (val) {
+    // if (val) throw new Error(`IPSECKEY: publickey is optional, ${this.citeRFC()}`)
+
+    this.set('publickey', val)
+  }
+
+  getDescription () {
+    return 'IPsec Keying'
+  }
+
+  getRdataFields (arg) {
+    return [ 'precedence', 'gateway type', 'algorithm', 'gateway', 'publickey' ]
+  }
+
+  getRFCs () {
+    return [ 4025 ]
+  }
+
+  getTypeId () {
+    return 45
+  }
+
+  /******  IMPORTERS   *******/
+  fromBind (opts) {
+    // FQDN TTL CLASS IPSECKEY Precedence GatewayType Algorithm Gateway PublicKey
+    const [ owner, ttl, c, type, prec, gwt, algo, gateway, publickey ] = opts.bindline.split(/\s+/)
+    return new IPSECKEY({
+      owner,
+      ttl           : parseInt(ttl, 10),
+      class         : c,
+      type,
+      precedence    : parseInt(prec, 10),
+      'gateway type': parseInt(gwt,  10),
+      algorithm     : parseInt(algo, 10),
+      gateway,
+      publickey,
+    })
+  }
+
+  fromTinydns (opts) {
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 45) throw new Error('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))
+
+    let len, gateway, octalKey
+
+    switch (gwType) {
+      case 0:     // no gateway
+        gateway  = rdata.substring(12, 13) // should always be: '.'
+        octalKey = rdata.substring(13)
+        break
+      case 1:     // 4-byte IPv4 address
+        gateway  = TINYDNS.octalToIPv4(rdata.substring(12, 28))
+        octalKey = rdata.substring(28)
+        break
+      case 2:     // 16-byte IPv6
+        gateway  = TINYDNS.octalToHex(rdata.substring(12, 76))
+        octalKey = rdata.substring(76)
+        break
+      case 3:     // wire encoded domain name
+        [ gateway, len ] = TINYDNS.unpackDomainName(rdata.substring(12))
+        octalKey = rdata.substring(12 + len)
+        break
+    }
+
+    return new IPSECKEY({
+      owner         : this.fullyQualify(fqdn),
+      ttl           : parseInt(ttl, 10),
+      type          : 'IPSECKEY',
+      precedence,
+      'gateway type': gwType,
+      algorithm,
+      gateway,
+      publickey     : TINYDNS.octalToBase64(octalKey),
+      timestamp     : ts,
+      location      : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+    const rdataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    let rdata = ''
+    rdata += TINYDNS.UInt8toOctal(this.get('precedence'))
+    rdata += TINYDNS.UInt8toOctal(this.get('gateway type'))
+    rdata += TINYDNS.UInt8toOctal(this.get('algorithm'))
+
+    switch (this.get('gateway type')) {
+      case 0:
+        rdata += TINYDNS.escapeOctal(rdataRe, '.')
+        break
+      case 1:
+        rdata += TINYDNS.ipv4toOctal(this.get('gateway'))
+        break
+      case 2:
+        rdata += TINYDNS.ipv6toOctal(this.get('gateway'))
+        break
+      case 3:
+        rdata += TINYDNS.packDomainName(this.get('gateway'))
+        break
+    }
+
+    rdata += TINYDNS.base64toOctal(this.get('publickey'))
+
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/key.js

@@ -0,0 +1,73 @@
+
+import RR from '../rr.js'
+
+export default class KEY extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setFlags (val) {
+    // a 2 octet Flags Field
+    this.is16bitInt('KEY', 'flags', val)
+
+    this.set('flags', val)
+  }
+
+  setProtocol (val) {
+    // 1 octet
+    this.is8bitInt('KEY', 'protocol', val)
+
+    this.set('protocol', val)
+  }
+
+  setAlgorithm (val) {
+    // 1 octet
+    // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
+    if (![ 1,2,3,4,5,253,254 ].includes(val))
+      throw new Error(`KEY: algorithm invalid, ${this.citeRFC()}`)
+
+    this.set('algorithm', val)
+  }
+
+  setPublickey (val) {
+    if (!val) throw new Error(`KEY: publickey is required, ${this.citeRFC()}`)
+
+    this.set('publickey', val)
+  }
+
+  getDescription () {
+    return 'DNS Public Key'
+  }
+
+  getRdataFields (arg) {
+    return [ 'flags', 'protocol', 'algorithm', 'publickey' ]
+  }
+
+  getRFCs () {
+    return [ 2535, 3445 ]
+  }
+
+  getTypeId () {
+    return 25
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  KEY Flags Protocol Algorithm PublicKey
+    const [ owner, ttl, c, type, flags, protocol, algorithm ] = opts.bindline.split(/\s+/)
+    return new KEY({
+      owner,
+      ttl      : parseInt(ttl, 10),
+      class    : c,
+      type     : type,
+      flags    : parseInt(flags,     10),
+      protocol : parseInt(protocol, 10),
+      algorithm: parseInt(algorithm,  10),
+      publickey: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}