@nictool/dns-resource-record 1.1.3

package/rr.js

@@ -0,0 +1,291 @@
+
+export default class RR extends Map {
+  constructor (opts) {
+    super()
+
+    if (opts === null) return
+
+    if (opts.default) this.default = opts.default
+
+    if (opts.bindline) return this.fromBind(opts)
+    if (opts.tinyline) return this.fromTinydns(opts)
+
+    // tinydns specific
+    this.setLocation(opts?.location)
+    this.setTimestamp(opts?.timestamp)
+
+    this.setOwner(opts?.owner)
+    this.setType (opts?.type)
+    this.setTtl  (opts?.ttl)
+    this.setClass(opts?.class)
+
+    for (const f of this.getFields('rdata')) {
+      const fnName = `set${this.ucfirst(f)}`
+      if (this[fnName] === undefined) throw new Error(`Missing ${fnName} in class ${this.get('type')}`)
+      this[fnName](opts[f])
+    }
+
+    if (opts.comment) this.set('comment', opts.comment)
+  }
+
+  ucfirst (str) {
+    return str.split(/\s/).map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('')
+  }
+
+  setClass (c) {
+    switch (c) {
+      case 'IN':    // 1
+      case undefined:
+      case null:
+      case '':
+        this.set('class', 'IN')
+        break
+      case 'CS':    // 2
+      case 'CH':    // 3
+      case 'HS':    // 4
+      case 'NONE':  // 254
+      case 'ANY':   // 255
+        this.set('class', c)
+        break
+      default:
+        throw new Error(`invalid class ${c}`)
+    }
+  }
+
+  setLocation (l) {
+    switch (l) {
+      case undefined:
+        return
+      default:
+        this.set('location', l)
+    }
+  }
+
+  setTimestamp (l) {
+    switch (l) {
+      case undefined:
+        return
+      default:
+        this.set('timestamp', l)
+    }
+  }
+
+  setOwner (n) {
+    if (n === undefined) throw new Error(`owner is required`)
+
+    if (n.length < 1 || n.length > 255)
+      throw new Error('Domain names must have 1-255 octets (characters): RFC 2181')
+
+    this.isFullyQualified('', 'owner', n)
+    this.hasValidLabels(n)
+
+    // wildcard records: RFC 1034, 4592
+    if (/\*/.test(n)) {
+      if (!/^\*\./.test(n) && !/\.\*\./.test(n)) throw new Error('only *.something or * (by itself) is a valid wildcard')
+    }
+
+    this.set('owner', n.toLowerCase())
+  }
+
+  setTtl (t) {
+
+    if (t === undefined) t = this?.default?.ttl
+    if (t === undefined) {
+      if ([ 'SOA', 'SSHPF' ].includes(this.get('type'))) return
+      throw new Error('TTL is required, no default available')
+    }
+
+    if (typeof t !== 'number') throw new Error(`TTL must be numeric (${typeof t})`)
+
+    // RFC 1035, 2181
+    this.is32bitInt(this.owner, 'TTL', t)
+
+    this.set('ttl', t)
+  }
+
+  setType (t) {
+    if ([ undefined, '' ].includes(t))
+      throw new Error(`type ${t} not supported (yet)`)
+
+    if (t.toUpperCase() !== this.constructor.name)
+      throw new Error(`type ${t} doesn't match ${this.constructor.name}`)
+
+    this.set('type', t.toUpperCase())
+  }
+
+  citeRFC () {
+    return `see RFC ${this.getRFCs()}`
+  }
+
+  fullyQualify (hostname, origin) {
+    if (!hostname) return hostname
+    if (hostname === '@' && origin) hostname = origin
+    if (hostname.endsWith('.')) return hostname.toLowerCase()
+    if (origin) return `${hostname}.${origin}`.toLowerCase()
+    return `${hostname}.`
+  }
+
+  getPrefix (zone_opts = {}) {
+    const classVal = zone_opts.hide?.class ? '' : this.get('class')
+
+    let rrTTL = this.get('ttl')
+    if (zone_opts.hide?.ttl && rrTTL === zone_opts.ttl) rrTTL = ''
+
+    let owner = this.get('owner')
+    if (zone_opts.hide?.sameOwner && zone_opts.previousOwner === owner) {
+      owner = ''
+    }
+    else {
+      owner = this.getFQDN('owner', zone_opts)
+    }
+
+    return `${owner}\t${rrTTL}\t${classVal}\t${this.get('type')}`
+  }
+
+  getEmpty (prop) {
+    return this.get(prop) === undefined ? '' : this.get(prop)
+  }
+
+  getComment (prop) {
+    const c = this.get('comment')
+    if (!c || !c[prop]) return ''
+    return c[prop]
+  }
+
+  getQuoted (prop) {
+    // if prop is not in quoted list, return bare
+    if (!this.getQuotedFields().includes(prop)) return this.get(prop)
+
+    // if it's already quoted, return as-is
+    if (/['"]/.test(this.get(prop)[0])) return this.get(prop)
+
+    return `"${this.get(prop)}"` // add double quotes
+  }
+
+  getQuotedFields () {
+    return []
+  }
+
+  getRdataFields () {
+    return []
+  }
+
+  getFields (arg) {
+    const commonFields = [ 'owner', 'ttl', 'class', 'type' ]
+    Object.freeze(commonFields)
+
+    switch (arg) {
+      case 'common':
+        return commonFields
+      case 'rdata':
+        return this.getRdataFields()
+      default:
+        return commonFields.concat(this.getRdataFields())
+    }
+  }
+
+  getFQDN (field, zone_opts = {}) {
+    let fqdn = this.get(field)
+    if (!fqdn) throw new Error(`empty value for field ${field}`)
+    if (!fqdn.endsWith('.')) fqdn += '.'
+
+    if (zone_opts.hide?.origin && zone_opts.origin) {
+      if (fqdn === zone_opts.origin) return '@'
+      if (fqdn.endsWith(zone_opts.origin)) return fqdn.slice(0, fqdn.length - zone_opts.origin.length - 1)
+    }
+
+    return fqdn
+  }
+
+  getTinyFQDN (field) {
+    const val = this.get(field)
+    if (val === '') return val   // empty
+    if (val === '.') return val  // null MX
+
+    // strip off trailing ., tinydns doesn't require it for FQDN
+    if (val.endsWith('.')) return val.slice(0, -1)
+
+    return val
+  }
+
+  getTinydnsGeneric (rdata) {
+    return `:${this.getTinyFQDN('owner')}:${this.getTypeId()}:${rdata}:${this.getTinydnsPostamble()}\n`
+  }
+
+  getTinydnsPostamble () {
+    return [ 'ttl', 'timestamp', 'location' ].map(f => this.getEmpty(f)).join(':')
+  }
+
+  hasValidLabels (hostname) {
+    // RFC  952 defined valid hostnames
+    // RFC 1035 limited domain label chars to letters, digits, and hyphen
+    // RFC 1123 allowed hostnames to start with a digit
+    // RFC 2181 'any binary string can be used as the label'
+    const fq = hostname.endsWith('.') ? hostname.slice(0, -1) : hostname
+    for (const label of fq.split('.')) {
+      if (label.length < 1 || label.length > 63)
+        throw new Error('Labels must have 1-63 octets (characters), RFC 2181')
+    }
+  }
+
+  is8bitInt (type, field, value) {
+    if (typeof value === 'number'
+      && parseInt(value, 10) === value  // assure integer
+      && value >= 0
+      && value <= 255) return true
+
+    throw new Error(`${type} ${field} must be a 8-bit integer (in the range 0-255)`)
+  }
+
+  is16bitInt (type, field, value) {
+    if (typeof value === 'number'
+      && parseInt(value, 10) === value  // assure integer
+      && value >= 0
+      && value <= 65535) return true
+
+    throw new Error(`${type} ${field} must be a 16-bit integer (in the range 0-65535)`)
+  }
+
+  is32bitInt (type, field, value) {
+    if (typeof value === 'number'
+      && parseInt(value, 10) === value  // assure integer
+      && value >= 0
+      && value <= 2147483647) return true
+
+    throw new Error(`${type} ${field} must be a 32-bit integer (in the range 0-2147483647)`)
+  }
+
+  isQuoted (val) {
+    return /^["']/.test(val) && /["']$/.test(val)
+  }
+
+  isFullyQualified (type, blah, hostname) {
+    if (hostname.endsWith('.')) return true
+
+    throw new Error(`${type}: ${blah} must be fully qualified`)
+  }
+
+  isValidHostname (type, field, hostname) {
+    const allowed = new RegExp(/[^a-zA-Z0-9\-._/\\]/)
+    if (!allowed.test(hostname)) return true
+
+    const matches = allowed.exec(hostname)
+    throw new Error(`${type}, ${field} has invalid hostname character (${matches[0]})`)
+  }
+
+  toBind (zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t${this.getRdataFields().map(f => this.getQuoted(f)).join('\t')}\n`
+  }
+
+  toMaraDNS () {
+    const type = this.get('type')
+    const supportedTypes = 'A PTR MX AAAA SRV NAPTR NS SOA TXT SPF RAW FQDN4 FQDN6 CNAME HINFO WKS LOC'.split(/\s+/g)
+    if (!supportedTypes.includes(type)) return this.toMaraGeneric()
+    return `${this.get('owner')}\t+${this.get('ttl')}\t${type}\t${this.getRdataFields().map(f => this.getQuoted(f)).join('\t')} ~\n`
+  }
+
+  toMaraGeneric () {
+    // throw new Error(`\nMaraDNS does not support ${type} records yet and this package does not support MaraDNS generic records. Yet.\n`)
+    return `${this.get('owner')}\t+${this.get('ttl')}\tRAW ${this.getTypeId()}\t'${this.getRdataFields().map(f => this.getQuoted(f)).join(' ')}' ~\n`
+  }
+}

package/test/a.js

@@ -0,0 +1,76 @@
+
+import A    from '../rr/a.js'
+import * as base from './base.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'A', address: '192.0.2.127' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner: 'test.example.com.',
+    testB: 'test.example.com.\t3600\tIN\tA\t192.0.2.127\n',
+    testT: '+test.example.com:192.0.2.127:3600::\n',
+  },
+  {
+    ...defaults,
+    owner: 'test.example.com.',
+    ttl  : 2147483647,
+    testB: 'test.example.com.\t2147483647\tIN\tA\t192.0.2.127\n',
+    testT: '+test.example.com:192.0.2.127:2147483647::\n',
+  },
+  {
+    ...defaults,
+    owner: 'a.',
+    ttl  : 86400,
+    testB: 'a.\t86400\tIN\tA\t192.0.2.127\n',
+    testT: '+a:192.0.2.127:86400::\n',
+  },
+  {
+    ...defaults,
+    owner: '*.example.com.',
+    testB: '*.example.com.\t3600\tIN\tA\t192.0.2.127\n',
+    testT: '+*.example.com:192.0.2.127:3600::\n',
+  },
+]
+
+const invalidRecords = [
+  { ...defaults, owner: '', msg: /RFC/ },
+  { ...defaults, owner: 'something*', msg: /fully/ },
+  { ...defaults, owner: 'some*thing', msg: /fully/ },
+  { ...defaults, owner: '*something', msg: /fully/ },
+  { ...defaults, owner: 'something.*', msg: /fully/ },
+  { ...defaults, address: 'hosts.not.valid.here', msg: /address must be IPv4/ },
+  { ...defaults, address: '', msg: /address is required/ },
+  { ...defaults, address: undefined, msg: /address is required/ },
+  { ...defaults, address: '1.x.2.3', msg: /address must be IPv4/ },
+  { ...defaults, address: '.1.2.3', msg: /address must be IPv4/ },
+  { ...defaults, type: '', msg: /not supported/ },
+  { ...defaults, type: undefined, msg: /type undefined not supported/ },
+  { ...defaults, ttl: '', msg: /TTL must be numeric/ },
+  { ...defaults, ttl: -299, msg: /TTL must be a 32-bit integer/ },
+  { ...defaults, ttl: 2147483648, msg: /TTL must be a 32-bit integer/ },
+]
+
+// copy invalid properties to a valid object
+for (let i = 0; i < invalidRecords.length; i++) {
+  const temp = JSON.parse(JSON.stringify(validRecords[0]))
+  Object.assign(temp, invalidRecords[i])
+  invalidRecords[i] = temp
+}
+
+describe('A record', function () {
+  base.valid(A, validRecords)
+  base.invalid(A, invalidRecords)
+
+  base.getDescription(A)
+  base.getRFCs(A, validRecords[0])
+  base.getRdataFields(A, [ 'address' ])
+  base.getFields(A, [ 'address' ])
+  base.getTypeId(A, 1)
+
+  base.toBind(A, validRecords)
+  base.toTinydns(A, validRecords)
+
+  base.fromBind(A, validRecords)
+  base.fromTinydns(A, validRecords)
+})

package/test/aaaa.js

@@ -0,0 +1,79 @@
+
+import assert from 'assert'
+
+import * as base from './base.js'
+import AAAA from '../rr/aaaa.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'AAAA' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner  : 'test.example.com.',
+    address: '2001:0db8:0020:000a:0000:0000:0000:0004',
+    testB  : 'test.example.com.\t3600\tIN\tAAAA\t2001:db8:20:a::4\n',
+    testT  : ':test.example.com:28:\\040\\001\\015\\270\\000\\040\\000\\012\\000\\000\\000\\000\\000\\000\\000\\004:3600::\n',
+  },
+]
+
+const invalidRecords = [
+  {
+    ...defaults,
+    owner  : 'test.example.com.',
+    address: '192.0.2.204',
+    msg    : /address must be IPv6/,
+  },
+]
+
+describe('AAAA record', function () {
+  base.valid(AAAA, validRecords)
+  base.invalid(AAAA, invalidRecords)
+
+  base.getDescription(AAAA)
+  base.getRFCs(AAAA, validRecords[0])
+  base.getFields(AAAA, [ 'address' ])
+  base.getTypeId(AAAA, 28)
+
+  base.toBind(AAAA, validRecords)
+  base.toTinydns(AAAA, validRecords)
+
+  base.fromBind(AAAA, validRecords)
+  base.fromTinydns(AAAA, validRecords)
+
+  for (const val of validRecords) {
+    it(`imports tinydns AAAA (generic) record (${val.owner})`, async function () {
+      const r = new AAAA({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of [ 'owner', 'address', 'ttl' ]) {
+        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
+      }
+    })
+  }
+
+  const tests = [
+    { e: '2001:0db8:0020:000a:0000:0000:0000:0004', c: '2001:db8:20:a::4' },
+    { e: '0000:0000:0000:0000:0000:0000:0000:0000', c: '::' },
+    { e: '0000:0000:0000:0000:0000:0000:0000:0001', c: '::1' },
+    { e: '2001:0db8:0000:0000:0000:0000:0002:0001', c: '2001:db8::2:1' },
+    { e: '2001:0db8:0000:0001:0001:0001:0001:0001', c: '2001:db8:0:1:1:1:1:1' },
+    { e: '2001:0DB8:0000:0000:0008:0800:200C:417A', c: '2001:DB8::8:800:200C:417A' },
+  ]
+
+  describe('compress', function () {
+    const r = new AAAA(null)
+    for (const t of tests) {
+      it(`compresses IPv6 address (${t.e})`, function () {
+        assert.equal(r.compress(t.e), t.c)
+      })
+    }
+  })
+
+  describe('expand', function () {
+    const r = new AAAA(null)
+    for (const t of tests) {
+      it(`expands IPv6 address (${t.c})`, function () {
+        assert.equal(r.expand(t.c), t.e)
+      })
+    }
+  })
+})

package/test/base.js

@@ -0,0 +1,138 @@
+
+import assert from 'assert'
+
+export function valid (type, validRecords, defaults) {
+  describe('valid', function () {
+    for (const val of validRecords) {
+      // console.log(val)
+      it(`parses record: ${val.owner}`, async function () {
+        if (defaults) val.default = defaults
+        const r = new type(val)
+        if (defaults) delete val.default
+        if (process.env.DEBUG) console.dir(r)
+
+        for (const k of Object.keys(val)) {
+          if (/^test/.test(k)) continue
+          assert.strictEqual(r.get(k), val[k], `${type.name} ${k} ${r.get(k)} !== ${val[k]}`)
+        }
+      })
+    }
+  })
+}
+
+export function invalid (type, invalidRecords, defaults) {
+  describe('invalid', function () {
+    for (const inv of invalidRecords) {
+      if (defaults) inv.default = defaults
+      it(`throws on record (${inv.owner})`, async function () {
+        assert.throws(() => {
+          new type(inv)
+        },
+        {
+          message: inv.msg,
+        })
+      })
+    }
+  })
+}
+
+export function toBind (type, validRecords) {
+  describe('toBind', function () {
+    for (const val of validRecords) {
+      it(`exports to BIND: ${val.owner}`, async function () {
+        const r = new type(val).toBind()
+        if (process.env.DEBUG) console.dir(r)
+        assert.strictEqual(r, val.testB)
+      })
+    }
+  })
+}
+
+export function toTinydns (type, validRecords) {
+  describe('toTinydns', function () {
+    for (const val of validRecords) {
+      if (val.testT === undefined) continue
+      it(`exports to tinydns: ${val.owner}`, async function () {
+        const r = new type(val).toTinydns()
+        if (process.env.DEBUG) console.dir(r)
+        assert.strictEqual(r, val.testT)
+      })
+    }
+  })
+}
+
+export function getDescription (type) {
+  describe('getDescription', function () {
+    const desc = new type(null).getDescription()
+    it(`gets description: ${desc}`, async function () {
+      assert.ok(desc)
+    })
+  })
+}
+
+export function getRFCs (type, valid) {
+  describe('getRFCs', function () {
+    const r = new type(null)
+    const rfcs = r.getRFCs()
+    it(`can retrieve RFCs: ${rfcs.join(',')}`, async function () {
+      assert.ok(rfcs.length)
+    })
+  })
+}
+
+function checkFromNS (type, validRecords, nsName, nsLineName) {
+  for (const val of validRecords) {
+    const testLine = nsLineName === 'bindline' ? val.testB : val.testT
+    if (testLine == undefined) continue
+    it(`imports ${nsName} record: ${val.owner}`, async function () {
+      const r = new type({ [nsLineName]: testLine })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of r.getFields()) {
+        if (f === 'class') continue
+        let expected = val[f]
+        if (f === 'data' && Array.isArray(expected)) expected = expected.join('') // TXT
+        assert.deepStrictEqual(r.get(f), expected, `${f}: ${r.get(f)} !== ${expected}`)
+      }
+    })
+  }
+}
+
+export function fromTinydns (type, validRecords) {
+  describe('fromTinydns', function () {
+    checkFromNS(type, validRecords, 'tinydns', 'tinyline')
+  })
+}
+
+export function fromBind (type, validRecords) {
+  describe('fromBind', function () {
+    checkFromNS(type, validRecords, 'BIND', 'bindline')
+  })
+}
+
+export function getRdataFields (type, rdataFields) {
+  describe('getRdataFields', function () {
+    const r = new type(null)
+    it(`can retrieve rdata fields: (${r.getRdataFields('rdata')})`, async function () {
+      assert.deepEqual(r.getRdataFields('rdata'), rdataFields)
+    })
+  })
+}
+
+export function getFields (type, rdataFields) {
+  describe('getFields', function () {
+    const r = new type(null)
+    it(`can retrieve record fields`, async function () {
+      assert.deepEqual(r.getFields('rdata'), rdataFields)
+      assert.deepEqual(r.getFields(), r.getFields('common').concat(rdataFields))
+    })
+  })
+}
+
+export function getTypeId (type, val) {
+  describe('getTypeId', function () {
+    const r = new type(null)
+    it(`can retrieve record type ID (${r.getTypeId()})`, async function () {
+      assert.deepEqual(r.getTypeId(), val)
+    })
+  })
+}

package/test/caa.js

@@ -0,0 +1,104 @@
+
+import assert from 'assert'
+
+import * as base from './base.js'
+
+import CAA from '../rr/caa.js'
+
+const validRecords = [
+  {
+    owner: 'ns1.example.com.',
+    ttl  : 3600,
+    class: 'IN',
+    type : 'CAA',
+    flags: 0,
+    tag  : 'issue',
+    value: 'http://letsencrypt.org',
+    testB: `ns1.example.com.\t3600\tIN\tCAA\t0\tissue\t"http://letsencrypt.org"\n`,
+    testT: ':ns1.example.com:257:\\000\\005issue"http\\072\\057\\057letsencrypt.org":3600::\n',
+  },
+  {
+    owner: 'ns2.example.com.',
+    ttl  : 3600,
+    class: 'IN',
+    type : 'CAA',
+    flags: 0,
+    tag  : 'issue',
+    value: 'mailto:lets-crypt.org',
+    testB: `ns2.example.com.\t3600\tIN\tCAA\t0\tissue\t"mailto:lets-crypt.org"\n`,
+    testT: ':ns2.example.com:257:\\000\\005issue"mailto\\072lets-crypt.org":3600::\n',
+  },
+  {
+    owner: 'example.net.',
+    ttl  : 86400,
+    type : 'CAA',
+    flags: 0,
+    tag  : 'issuewild',
+    value: 'https://letsencrypt.org',
+    testB: 'example.net.\t86400\tIN\tCAA\t0\tissuewild\t"https://letsencrypt.org"\n',
+    testT: ':example.net:257:\\000\\011issuewild"https\\072\\057\\057letsencrypt.org":86400::\n',
+  },
+  {
+    owner: 'certs.example.com.',
+    ttl  : 86400,
+    type : 'CAA',
+    flags: 0,
+    tag  : 'issue',
+    value: 'ca1.example.net',
+    testB: 'certs.example.com.\t86400\tIN\tCAA\t0\tissue\t"ca1.example.net"\n',
+    testT: ':certs.example.com:257:\\000\\005issue"ca1.example.net":86400::\n',
+  },
+]
+
+const invalidRecords = [
+  {
+    owner: 'example.com.',
+    type : 'CAA',
+    flags: 128,
+    tag  : 'iodef',
+    value: 'letsencrypt.org', // missing iodef prefix
+    msg  : /RFC/,
+  },
+  {
+    owner: 'example.com.',
+    type : 'CAA',
+    flags: 128,
+    tag  : 'invalid', // invalid
+    value: 'http://letsencrypt.org',
+    msg  : /RFC/,
+  },
+  {
+    owner: 'example.com.',
+    type : 'CAA',
+    flags: 15,  // invalid
+    tag  : 'issue',
+    value: 'http://letsencrypt.org',
+    msg  : /RFC/,
+  },
+]
+
+describe('CAA record', function () {
+  base.valid(CAA, validRecords)
+  base.invalid(CAA, invalidRecords, { ttl: 3600 })
+
+  base.getDescription(CAA)
+  base.getRFCs(CAA, validRecords[0])
+  base.getFields(CAA, [ 'flags', 'tag', 'value' ])
+  base.getTypeId(CAA, 257)
+
+  base.toBind(CAA, validRecords)
+  base.toTinydns(CAA, validRecords)
+
+  base.fromBind(CAA, validRecords)
+  base.fromTinydns(CAA, validRecords)
+
+  for (const val of validRecords) {
+    it(`imports tinydns CAA (generic) record`, async function () {
+      const r = new CAA({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of [ 'owner', 'flags', 'tag', 'value', 'ttl' ]) {
+        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
+      }
+    })
+  }
+})