@nictool/dns-resource-record 1.1.3

package/lib/tinydns.js

@@ -0,0 +1,186 @@
+
+export const SPECIALCHARS = {
+  '+': [ 'A' ],
+  '-': [ undefined ],  // disabled RR
+  '%': [ 'location' ],
+  '.': [ 'SOA', 'NS', 'A' ],
+  '&': [ 'NS', 'A' ],
+  '=': [ 'A', 'PTR' ],
+  '@': [ 'MX', 'A' ],
+  '#': [ 'comment' ],
+  "'": [ 'TXT' ],
+  '^': [ 'PTR' ],
+  'C': [ 'CNAME' ],
+  'Z': [ 'SOA' ],
+  ':': [ 'generic' ],
+  '3': [ 'AAAA' ],
+  '6': [ 'AAAA', 'PTR' ],
+  'S': [ 'SRV' ],
+}
+
+const octalRe = new RegExp(/\\(?:[1-7][0-7]{0,2}|[0-7]{2,3})/, 'g')
+
+export function escapeOctal (re, str) {
+  let escaped = ''
+  str.split(/(.{1})/g).map(c => {
+    escaped += re.test(c) ? charToOctal(c) : c
+  })
+  return escaped
+}
+
+export function octalToChar (str) {
+  // relace instances of \NNN with ASCII
+  return str.replace(octalRe, o => String.fromCharCode(parseInt(o.substring(1), 8)))
+}
+
+export function octalToHex (str) {
+  // relace instances of \NNN with Hex
+  return str.replace(octalRe, o => {
+    // parseInt(n, 8) -> from octal to decimal
+    //  .toString(16) -> decimal to hex
+    return parseInt(o.substring(1), 8).toString(16).padStart(2, 0)
+  })
+}
+
+export function octalToUInt8 (str) {
+  const b = Buffer.alloc(1)
+  b.writeUInt8(parseInt(str.substring(1,4), 8), 0)
+  return b.readUInt8()
+}
+
+export function octalToUInt16 (str) {
+  const b = Buffer.alloc(2)
+  b.writeUInt8(parseInt(str.substring(1,4), 8), 0)
+  b.writeUInt8(parseInt(str.substring(5,8), 8), 1)
+  return b.readUInt16BE()
+}
+
+export function octalToUInt32 (str) {
+  const b = Buffer.alloc(4)
+  b.writeUInt8(parseInt(str.substring(1,4), 8), 0)
+  b.writeUInt8(parseInt(str.substring(5,8), 8), 1)
+  b.writeUInt8(parseInt(str.substring(9,12), 8), 2)
+  b.writeUInt8(parseInt(str.substring(13,16), 8), 3)
+  return b.readUInt32BE()
+}
+
+export function packString (str) {
+  return str.match(/(.{1,255})/g).map(s => {
+    const len = Buffer.alloc(1)
+    len.writeUInt8(s.length)
+    return `${UInt8toOctal(len.readUInt8(0))}${s}`
+  }).join('')
+}
+
+export function unpackString (str) {
+  const asBuf = Buffer.from(octalToChar(str.toString()))
+  const res = []
+  let pos = 0
+  let len
+  while ((len = asBuf.readUInt8(pos))) {  // encoded length byte
+    pos++
+    res.push(asBuf.slice(pos, pos + len).toString())
+    pos = +(pos + len)
+    if (pos >= asBuf.length) break
+  }
+  return res
+}
+
+export function packDomainName (fqdn) {
+  const labelRegEx = new RegExp(/[^A-Za-z0-9-.]/, 'g')
+
+  // RFC 1035, 3.3 Standard RRs
+  // The standard wire format for DNS names. (1 octet length + octets)
+  let packed = ''
+  fqdn.split('.').map(label => {
+    if (label === undefined || !label.length) return
+
+    const len = Buffer.alloc(1)
+    len.writeUInt8(label.length)
+    packed += UInt8toOctal(len.readUInt8(0))
+
+    packed += escapeOctal(labelRegEx, label)
+  })
+  packed += '\\000' // terminates with a zero length label
+  return packed
+}
+
+export function unpackDomainName (fqdn) {
+
+  fqdn = Buffer.from(octalToChar(fqdn.toString()))
+
+  const labels = []
+  let pos = 0
+  let len
+  while ((len = fqdn.readUInt8(pos))) {  // encoded length byte
+    pos++
+    labels.push(fqdn.slice(pos, pos + len).toString())
+    pos = +(pos + len)
+  }
+  const r = `${labels.join('.')}.`
+  // char position + length of last label + label length chars + null byte
+  const strLen = pos + len + labels.length * 4 + 1
+  return [ r, strLen ]
+}
+
+export function packHex (str) {
+  let r = ''
+  for (let i = 0; i < str.length; i = i+2) {
+    // nibble off 2 hex bytes, encode to octal
+    r += UInt8toOctal(parseInt(str.slice(i, i+2), 16))
+  }
+  return r
+}
+
+export function charToOctal (c) {
+  if (typeof c === 'number') return UInt8toOctal(c)
+
+  return UInt8toOctal(c.charCodeAt(0))
+}
+
+export function UInt8toOctal (n) {
+  if (n > 255) throw new Error('UInt8toOctal does not work on numbers > 255')
+
+  return `\\${parseInt(n, 10).toString(8).padStart(3, 0)}`
+}
+
+export function UInt16toOctal (n) {
+  let r = ''
+  const pri = Buffer.alloc(2)
+  pri.writeUInt16BE(n)
+  r += UInt8toOctal(pri.readUInt8(0))
+  r += UInt8toOctal(pri.readUInt8(1))
+  return r
+}
+
+export function UInt32toOctal (n) {
+  let r = ''
+  const pri = Buffer.alloc(4)
+  pri.writeUInt32BE(n)
+  for (let i = 0; i < 4; i++) {
+    r += UInt8toOctal(pri.readUInt8(i))
+  }
+  return r
+}
+
+export function ipv4toOctal (ip) {
+  return UInt32toOctal(ip.split`.`.reduce((int, value) => int * 256 + +value))
+}
+
+export function octalToIPv4 (str) {
+  const asInt = octalToUInt32(str)
+  return [ 24,16,8,0 ].map(n => (asInt >> n) & 0xff).join('.')
+}
+
+export function base64toOctal (str) {
+  const bytes = Buffer.from(str, 'base64')
+  let escaped = ''
+  for (const b of bytes) {
+    escaped += /[A-Za-z0-9\-.]/.test(String.fromCharCode(b)) ? String.fromCharCode(b) : UInt8toOctal(b)
+  }
+  return escaped
+}
+
+export function octalToBase64 (str) {
+  return Buffer.from(octalToChar(str), 'binary').toString('base64')
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@nictool/dns-resource-record",
+  "version": "1.1.3",
+  "description": "DNS Resource Records",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "lint": "npx eslint *.js lib rr test",
+    "lintfix": "npx eslint --fix *.js lib rr test",
+    "test": "npx mocha",
+    "versions": "npx dependency-version-checker check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/NicTool/dns-resource-record.git"
+  },
+  "keywords": [
+    "DNS",
+    "resource",
+    "record",
+    "validator",
+    "validation",
+    "import",
+    "export",
+    "BIND",
+    "djbdns",
+    "tinydns",
+    "nictool"
+  ],
+  "author": "Matt Simerson <matt@tnpi.net>",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/NicTool/dns-resource-record/issues"
+  },
+  "homepage": "https://github.com/NicTool/dns-resource-record#readme",
+  "devDependencies": {
+    "eslint": "^8.11.0",
+    "mocha": "^9.2.2"
+  }
+}

package/rr/a.js

@@ -0,0 +1,65 @@
+
+import net from 'net'
+
+import RR from '../rr.js'
+
+export default class A extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setAddress (val) {
+    if (!val) throw new Error('A: address is required')
+    if (!net.isIPv4(val)) throw new Error('A address must be IPv4')
+    this.set('address', val)
+  }
+
+  getDescription () {
+    return 'Address'
+  }
+
+  getRdataFields (arg) {
+    return [ 'address' ]
+  }
+
+  getRFCs () {
+    return [ 1035 ]
+  }
+
+  getTypeId () {
+    return 1
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // +fqdn:ip:ttl:timestamp:lo
+    const [ owner, ip, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+
+    return new A({
+      owner    : this.fullyQualify(owner),
+      type     : 'A',
+      address  : ip,
+      ttl      : parseInt(ttl, 10),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  A  192.0.2.127
+    const [ owner, ttl, c, type, address ] = opts.bindline.split(/\s+/)
+    return new A({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type,
+      address,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+    return `+${this.getTinyFQDN('owner')}:${this.get('address')}:${this.getTinydnsPostamble()}\n`
+  }
+}

package/rr/aaaa.js

@@ -0,0 +1,137 @@
+
+import net from 'net'
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class AAAA extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setAddress (val) {
+    if (!val) throw new Error('AAAA: address is required')
+    if (!net.isIPv6(val)) throw new Error(`AAAA: address must be IPv6 (${val})`)
+
+    this.set('address', this.expand(val.toLowerCase())) // lower case: RFC 5952
+  }
+
+  getCompressed (val) {
+    this.compress(val || this.get('address'))
+  }
+
+  getDescription () {
+    return 'Address IPv6'
+  }
+
+  getRdataFields (arg) {
+    return [ 'address' ]
+  }
+
+  getRFCs () {
+    return [ 3596 ]
+  }
+
+  getTypeId () {
+    return 28
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    const str = opts.tinyline
+    let fqdn, ip, n, rdata, ttl, ts, loc
+
+    switch (str[0]) {
+      case ':':
+        // GENERIC  =>  :fqdn:28:rdata:ttl:timestamp:lo
+        [ fqdn, n, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+        if (n != 28) throw new Error('AAAA fromTinydns, invalid n')
+        ip = TINYDNS.octalToHex(rdata).match(/([0-9a-fA-F]{4})/g).join(':')
+        break
+      case '3':
+      case '6':
+        // AAAA     =>  3fqdn:ip:x:ttl:timestamp:lo
+        // AAAA,PTR =>  6fqdn:ip:x:ttl:timestamp:lo
+        [ fqdn, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+        ip = rdata.match(/(.{4})/g).join(':')
+        break
+    }
+
+    return new AAAA({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'AAAA',
+      address  : ip,
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  AAAA  ...
+    const [ owner, ttl, c, type, ip ] = opts.bindline.split(/\s+/)
+    return new AAAA({
+      owner,
+      ttl    : parseInt(ttl, 10),
+      class  : c,
+      type,
+      address: this.expand(ip),
+    })
+  }
+
+  compress (val) {
+    /*
+     * RFC 5952
+     * 4.1. Leading zeros MUST be suppressed...A single 16-bit 0000 field MUST be represented as 0.
+     * 4.2.1 The use of the symbol "::" MUST be used to its maximum capability.
+     * 4.2.2 The symbol "::" MUST NOT be used to shorten just one 16-bit 0 field.
+     * 4.2.3 When choosing placement of a "::", the longest run...MUST be shortened
+     * 4.3 The characters a-f in an IPv6 address MUST be represented in lowercase.
+    */
+    let r = val
+      .replace(/0000/g, '0')             // 4.1 0000 -> 0
+      .replace(/:0+([1-9a-fA-F])/g, ':$1')  // 4.1 remove leading zeros
+
+    const mostConsecutiveZeros = [
+      new RegExp(/0?(?::0){6,}:0?/),
+      new RegExp(/0?(?::0){5,}:0?/),
+      new RegExp(/0?(?::0){4,}:0?/),
+      new RegExp(/0?(?::0){3,}:0?/),
+      new RegExp(/0?(?::0){2,}:0?/),
+    ]
+
+    for (const re of mostConsecutiveZeros) {
+      if (re.test(r)) {
+        r = r.replace(re, '::')
+        break
+      }
+    }
+
+    return r
+  }
+
+  expand (val, delimiter) {
+    if (delimiter === undefined) delimiter = ':'
+
+    const colons = val.match(/:/g)
+    if (colons && colons.length < 7) {
+      // console.log(`AAAA: restoring compressed colons`)
+      val = val.replace(/::/, ':'.repeat(9 - colons.length))
+    }
+
+    // restore compressed leading zeros
+    return val.split(':').map(s => s.padStart(4, 0)).join(delimiter)
+  }
+
+  /******  EXPORTERS   *******/
+  toBind (zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t${this.compress(this.get('address'))}\n`
+  }
+
+  toTinydns () {
+    // from AAAA notation (8 groups of 4 hex digits) to 16 escaped octals
+    const rdata = TINYDNS.packHex(this.expand(this.get('address'), ''))
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/caa.js

@@ -0,0 +1,129 @@
+
+import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class CAA extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setFlags (val) {
+    this.is8bitInt('CAA', 'flags', val)
+
+    if (![ 0, 128 ].includes(val)) {
+      throw new Error(`CAA flags ${val} not recognized, ${this.citeRFC()}`)
+    }
+
+    this.set('flags', val)
+  }
+
+  setTag (val) {
+    if (typeof val !== 'string'
+      || val.length < 1
+      || /[^a-z0-9]/.test(val))
+      throw new Error(`CAA tag must be a sequence of ASCII letters and numbers in lowercase, ${this.citeRFC()}`)
+
+    if (![ 'issue', 'issuewild', 'iodef' ].includes(val)) {
+      throw new Error(`CAA tag ${val} not recognized: ${this.citeRFC()}`)
+    }
+    this.set('tag', val)
+  }
+
+  setValue (val) {
+    // either (2) a quoted string or
+    // (1) a contiguous set of characters without interior spaces
+    if (this.isQuoted(val)) {
+      val = val.replace(/^["']|["']$/g, '') // strip quotes
+    }
+    else {
+      // if (/\s/.test(val)) throw new Error(`CAA value may not have spaces unless quoted: RFC 8659`)
+    }
+
+    // check if val starts with one of iodefSchemes
+    if (this.get('tag') === 'iodef') {
+      const iodefSchemes = [ 'mailto:', 'http:', 'https:' ]
+      if (!iodefSchemes.filter(s => val.startsWith(s)).length) {
+        throw new Error(`CAA value must have valid iodefScheme prefix, ${this.citeRFC()}`)
+      }
+    }
+
+    this.set('value', val)
+  }
+
+  getDescription () {
+    return 'Certification Authority Authorization'
+  }
+
+  getQuotedFields () {
+    return [ 'value' ]
+  }
+
+  getRdataFields (arg) {
+    return [ 'flags', 'tag', 'value' ]
+  }
+
+  getRFCs () {
+    return [ 6844, 8659 ]
+  }
+
+  getTypeId () {
+    return 257
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // CAA via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 257) throw new Error('CAA fromTinydns, invalid n')
+
+    const flags  = TINYDNS.octalToUInt8(rdata.substring(0, 4))
+    const taglen = TINYDNS.octalToUInt8(rdata.substring(4, 8))
+
+    const unescaped   = TINYDNS.octalToChar(rdata.substring(8))
+    const tag         = unescaped.substring(0, taglen)
+    const fingerprint = unescaped.substring(taglen)
+
+    return new CAA({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'CAA',
+      flags,
+      tag,
+      value    : fingerprint,
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  CAA flags, tags, value
+    const fields = opts.bindline.match(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+(\w+)\s+("[^"]+"|[^\s]+?)\s*$/i)
+    if (!fields) throw new Error(`unable to parse: ${opts.bindline}`)
+
+    const [ owner, ttl, c, type, flags, tag, value ] = fields.slice(1)
+    return new CAA({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type,
+      flags: parseInt(flags, 10),
+      tag,
+      value,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+    let rdata = ''
+    rdata += TINYDNS.UInt8toOctal(this.get('flags'))
+
+    rdata += TINYDNS.UInt8toOctal(this.get('tag').length)
+    rdata += TINYDNS.escapeOctal(/[\r\n\t:\\/]/, this.get('tag'))
+
+    rdata += TINYDNS.escapeOctal(/[\r\n\t:\\/]/, this.getQuoted('value'))
+
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/cert.js

@@ -0,0 +1,75 @@
+
+import RR from '../rr.js'
+
+export default class CERT extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  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)
+
+    this.set('cert type', val)
+  }
+
+  setKeyTag (val) {
+    // The key tag field is the 16-bit value
+    // The key tag field is represented as an unsigned decimal integer.
+
+    this.is16bitInt('CERT', 'key tag', val)
+
+    this.set('key tag', val)
+  }
+
+  setAlgorithm (val) {
+    // The algorithm field has the same meaning as the algorithm field in DNSKEY
+    // The algorithm field is represented as an unsigned decimal integer
+    this.is8bitInt('CERT', 'algorithm', val)
+
+    this.set('algorithm', val)
+  }
+
+  setCertificate (val) {
+    // certificate/CRL portion is represented in base 64 [16] and may be
+    // divided into any number of white-space-separated substrings
+    this.set('certificate', val)
+  }
+
+  getDescription () {
+    return 'Certificate'
+  }
+
+  getRdataFields () {
+    return [ 'cert type', 'key tag', 'algorithm', 'certificate' ]
+  }
+
+  getRFCs () {
+    return [ 2538, 4398 ]
+  }
+
+  getTypeId () {
+    return 37
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  CERT  certtype, keytag, algo, cert
+    const [ owner, ttl, c, type, certtype, keytag, algo, certificate  ] = opts.bindline.split(/\s+/)
+    return new CERT({
+      owner,
+      ttl        : parseInt(ttl, 10),
+      class      : c,
+      type,
+      'cert type': /^[0-9]+$/.test(certtype) ? parseInt(certtype, 10) : certtype,
+      'key tag'  : parseInt(keytag,   10),
+      algorithm  : parseInt(algo, 10),
+      certificate,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}

package/rr/cname.js

@@ -0,0 +1,76 @@
+
+import net from 'net'
+
+import RR from '../rr.js'
+
+export default class CNAME extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setCname (val) {
+    // A <domain-name> which specifies the canonical or primary
+    // name for the owner.  The owner name is an alias.
+
+    if (!val) throw new Error('CNAME: cname is required')
+
+    if (net.isIPv4(val) || net.isIPv6(val))
+      throw new Error(`CNAME: cname must be a FQDN: RFC 2181`)
+
+    if (!this.isFullyQualified('CNAME', 'cname', val)) return
+    if (!this.isValidHostname('CNAME', 'cname', val)) return
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('cname', val.toLowerCase())
+  }
+
+  getDescription () {
+    return 'Canonical Name'
+  }
+
+  getRdataFields (arg) {
+    return [ 'cname' ]
+  }
+
+  getRFCs () {
+    return [ 1035, 2181 ]
+  }
+
+  getTypeId () {
+    return 5
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // Cfqdn:p:ttl:timestamp:lo
+    const [ fqdn, p, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+
+    return new CNAME({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'CNAME',
+      cname    : this.fullyQualify(p),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  CNAME  ...
+    const [ owner, ttl, c, type, cname ] = opts.bindline.split(/\s+/)
+    return new CNAME({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type,
+      cname,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+  toTinydns () {
+    return `C${this.getTinyFQDN('owner')}:${this.get('cname')}:${this.getTinydnsPostamble()}\n`
+  }
+}