@nictool/dns-resource-record 1.3.1 → 1.4.0

package/CHANGELOG.md

@@ -4,6 +4,17 @@ Notable changes to this project are documented in this file.
 
 #### Unreleased
 
+### [1.4.0] - 2026-03-21
+
+#### Changed
+
+- feat(toBind): added to nsec3param, rrsig
+- feat(toTinydns): added to key, nsec3param, nxt, openpgpkey
+- feat(fromTinydns): added to cert, https, key, nsec, nsec3param, nxt, openpgpkey, smimea, svcb
+- fix(naptr): fixed flags calc in fromTinydns
+- fix(tinydns): more robust unpackDomainName
+- test: switch test runner to node --test
+
 ### [1.3.1] - 2026-03-13
 
 - ci: update workflow triggers
@@ -338,3 +349,4 @@ Notable changes to this project are documented in this file.
 [1.2.4]: https://github.com/NicTool/dns-resource-record/releases/tag/1.2.4
 [1.3.0]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.3.0
 [1.3.1]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.3.1
+[1.4.0]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.4.0

package/lib/tinydns.js

@@ -27,6 +27,10 @@ export function escapeOctal(re, str) {
   return escaped
 }
 
+export function unescapeOctal(str) {
+  return this.octalToChar(str)
+}
+
 export function octalToChar(str) {
   // relace instances of \NNN with ASCII
   return str.replace(octalRe, (o) => String.fromCharCode(parseInt(o.substring(1), 8)))
@@ -108,22 +112,39 @@ export function packDomainName(fqdn) {
   return packed
 }
 
-export function unpackDomainName(fqdn) {
-  fqdn = Buffer.from(octalToChar(fqdn.toString()))
-
-  const labels = []
+export function unpackDomainName(escaped) {
   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)
+  let binaryLen = 0
+  const labels = []
+
+  // consume the next logical "byte" (char or octal escape)
+  const getNextByte = () => {
+    if (pos >= escaped.length) return null
+
+    let value
+    if (escaped[pos] === '\\') {
+      value = parseInt(escaped.slice(pos + 1, pos + 4), 8)
+      pos += 4
+    } else {
+      value = escaped.charCodeAt(pos++)
+    }
+
+    binaryLen++
+    return value
   }
-  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]
+
+  let lengthByte
+  while ((lengthByte = getNextByte()) && lengthByte !== 0) {
+    let label = ''
+    for (let i = 0; i < lengthByte; i++) {
+      const char = getNextByte()
+      if (char === null) break
+      label += String.fromCharCode(char)
+    }
+    labels.push(label)
+  }
+
+  return [`${labels.join('.')}.`, pos, binaryLen]
 }
 
 export function packHex(str) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nictool/dns-resource-record",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "DNS Resource Records",
   "main": "index.js",
   "files": [
@@ -17,10 +17,11 @@
     "lint:fix": "npm run lint -- --fix",
     "prettier": "npx prettier --ignore-path .gitignore --check .",
     "prettier:fix": "npx prettier --ignore-path .gitignore --write .",
-    "test": "npx mocha",
-    "versions": "npx dependency-version-checker check",
-    "watch": "npm run test -- --watch",
-    "versions:fix": "npx dependency-version-checker update"
+    "test": "node --test test/*.js",
+    "test:coverage": "npx c8 --reporter=text --reporter=text-summary npm test",
+    "versions": "npx npm-dep-mgr check",
+    "versions:fix": "npx npm-dep-mgr update",
+    "watch": "node --test --watch test/*.js"
   },
   "repository": {
     "type": "git",
@@ -47,9 +48,8 @@
   "homepage": "https://github.com/NicTool/dns-resource-record#readme",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "eslint": "^10.0.3",
-    "globals": "^17.4.0",
-    "mocha": "^11.7.5"
+    "eslint": "^10.1.0",
+    "globals": "^17.4.0"
   },
   "prettier": {
     "printWidth": 110,

package/rr/cert.js

@@ -75,6 +75,41 @@ export default class CERT extends RR {
 
   /******  IMPORTERS   *******/
 
+  fromTinydns(opts) {
+    const [owner, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 37) this.throwHelp('CERT fromTinydns, invalid n')
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const typeNum = bytes.readUInt16BE(0)
+    let certType = typeNum
+
+    const types = {
+      1: 'PKIX',
+      2: 'SPKI',
+      3: 'PGP',
+      4: 'IPKIX',
+      5: 'ISPKI',
+      6: 'IPGP',
+      7: 'ACPKIX',
+      8: 'IACPKIX',
+      253: 'URI',
+      254: 'OID',
+    }
+    if (types[typeNum]) certType = types[typeNum]
+
+    return new CERT({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'CERT',
+      'cert type': certType,
+      'key tag': bytes.readUInt16BE(2),
+      algorithm: bytes.readUInt8(4),
+      certificate: bytes.slice(5).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
   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+/)

package/rr/https.js

@@ -60,6 +60,27 @@ export default class HTTPS extends RR {
     })
   }
 
+  fromTinydns({ rd, owner, ttl }) {
+    if (rd.length < 6) {
+      this.throwHelp(`HTTPS: RDATA too short: ${rd}`)
+    }
+
+    const priority = TINYDNS.octalToUInt16(rd.substring(0, 6))
+    const remaining = rd.slice(6)
+
+    const [targetName, consumed] = TINYDNS.unpackDomainName(remaining)
+    const params = TINYDNS.escapeOctal(remaining.slice(consumed))
+
+    return new HTTPS({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'HTTPS',
+      priority,
+      'target name': targetName,
+      params,
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {

package/rr/key.js

@@ -1,4 +1,5 @@
 import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
 
 export default class KEY extends RR {
   constructor(opts) {
@@ -79,5 +80,39 @@ export default class KEY extends RR {
     })
   }
 
+  fromTinydns(opts) {
+    const rd = opts.rd
+
+    // RDATA format: Flags (6 octal chars) + Protocol (3 octal chars) + Algorithm (3 octal chars) + Public Key (escaped data)
+    if (rd.length < 12) {
+      this.throwHelp(`KEY: RDATA too short: ${rd}`)
+    }
+
+    const flags = TINYDNS.octalToUInt16(rd.substring(0, 6))
+    const protocol = TINYDNS.octalToUInt8(rd.substring(6, 9))
+    const algorithm = TINYDNS.octalToUInt8(rd.substring(9, 12))
+    const publicKeyData = TINYDNS.unescapeOctal(rd.substring(12))
+
+    return new KEY({
+      owner: this.fullyQualify(opts.owner),
+      ttl: parseInt(opts.ttl, 10),
+      type: 'KEY',
+      flags: flags,
+      protocol: protocol,
+      algorithm: algorithm,
+      publickey: publicKeyData,
+    })
+  }
+
   /******  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/naptr.js

@@ -82,7 +82,7 @@ export default class NAPTR extends RR {
     let idx = 4
     const flagsLength = binRdata.readUInt8(idx)
     idx++
-    rec.flags = binRdata.slice(idx, flagsLength).toString()
+    rec.flags = binRdata.slice(idx, idx + flagsLength).toString()
     idx += flagsLength
 
     const serviceLen = binRdata.readUInt8(idx)

package/rr/nsec.js

@@ -43,6 +43,22 @@ export default class NSEC extends RR {
 
   /******  IMPORTERS   *******/
 
+  fromTinydns(opts) {
+    const [owner, _typeId, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const [nextDomain, _escapedLen, binaryLen] = TINYDNS.unpackDomainName(rdata)
+
+    return new NSEC({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'NSEC',
+      'next domain': nextDomain,
+      'type bit maps': binaryRdata.slice(binaryLen).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
   fromBind(opts) {
     // test.example.com  3600  IN  NSEC NextDomain TypeBitMaps
     const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)

package/rr/nsec3.js

@@ -93,7 +93,7 @@ export default class NSEC3 extends RR {
       iterations: parseInt(iterations, 10),
       salt,
       'next hashed owner name': rdata.split(/\s+/)[0],
-      'type bit maps': rdata.split(/\s+/).slice(1).join('\t'),
+      'type bit maps': rdata.split(/\s+/).slice(1).join('	'),
     })
   }
 
@@ -103,16 +103,27 @@ export default class NSEC3 extends RR {
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
+    const hashAlgorithm = bytes.readUInt8(0)
+    const flags = bytes.readUInt8(1)
+    const iterations = bytes.readUInt16BE(2)
+
+    // The remaining bytes in the buffer contain:
+    // Salt Length (1 octet)
+    // Salt (variable length based on Salt Length)
+    // Next Hashed Owner Name (variable length)
+    // Type Bit Maps (variable length)
+    const { salt, nextHashedOwnerName, typeBitMaps } = TINYDNS.parseNSEC3Buffer(bytes)
+
     return new NSEC3({
       owner: this.fullyQualify(fqdn),
       ttl: parseInt(ttl, 10),
       type: 'NSEC3',
-      'hash algorithm': bytes.readUInt8(0),
-      flags: bytes.readUInt8(1),
-      iterations: bytes.readUInt16BE(2),
-      // salt                    : ,
-      // 'next hashed owner name': ,
-      // 'type bit maps'         : ,
+      'hash algorithm': hashAlgorithm,
+      flags: flags,
+      iterations: iterations,
+      salt: salt,
+      'next hashed owner name': nextHashedOwnerName,
+      'type bit maps': typeBitMaps,
       timestamp: ts,
       location: loc !== '' && loc !== '\n' ? loc : '',
     })
@@ -121,13 +132,14 @@ export default class NSEC3 extends RR {
   /******  EXPORTERS   *******/
 
   toBind(zone_opts) {
-    return `${this.getFQDN('owner', zone_opts)}\t${this.get('ttl')}\t${this.get('class')}\tNSEC3${this.getRdataFields()
+    return `${this.getFQDN('owner', zone_opts)}	${this.get('ttl')}	${this.get('class')}	NSEC3${this.getRdataFields()
       .slice(0, 4)
-      .map((f) => '\t' + this.get(f))
-      .join('')}\t(${this.getRdataFields()
+      .map((f) => '	' + this.get(f))
+      .join('')}	(${this.getRdataFields()
       .slice(4)
       .map((f) => this.get(f))
-      .join('\t')})\n`
+      .join('	')})
+`
   }
 
   toTinydns() {

package/rr/nsec3param.js

@@ -1,4 +1,5 @@
 import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
 
 export default class NSEC3PARAM extends RR {
   constructor(opts) {
@@ -62,21 +63,57 @@ export default class NSEC3PARAM extends RR {
   /******  IMPORTERS   *******/
 
   fromBind(str) {
-    // test.example.com  3600  IN  NSEC3PARAM
-    const [owner, ttl, c, type] = str.split(/\s+/)
+    // test.example.com  3600  IN  NSEC3PARAM  <hash> <flags> <iterations> <salt>
+    // Example: test.example.com. 3600 IN NSEC3PARAM 1 1 12 aabbccdd
+    const [owner, ttl, c, type, ha, flags, iterations, salt] = str.split(/\s+/)
     return new NSEC3PARAM({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
-      'hash algorithm': '',
-      flags: '',
-      iterations: '',
-      salt: '',
-      'next hashed owner name': '',
-      'type bit maps': '',
+      'hash algorithm': parseInt(ha, 10),
+      flags: parseInt(flags, 10),
+      iterations: parseInt(iterations, 10),
+      salt: salt,
+    })
+  }
+
+  fromTinydns(opts) {
+    const rd = opts.rd
+
+    // RDATA format: Hash Algorithm (3 octal chars) + Flags (3 octal chars) + Iterations (6 octal chars) + Salt (escaped hex string)
+    if (rd.length < 12) {
+      this.throwHelp(`NSEC3PARAM: RDATA too short: ${rd}`)
+    }
+
+    return new NSEC3PARAM({
+      owner: this.fullyQualify(opts.owner),
+      ttl: parseInt(opts.ttl, 10),
+      type: 'NSEC3PARAM',
+      'hash algorithm': TINYDNS.octalToUInt8(rd.substring(0, 3)),
+      flags: TINYDNS.octalToUInt8(rd.substring(3, 6)),
+      iterations: TINYDNS.octalToUInt16(rd.substring(6, 12)),
+      salt: TINYDNS.unescapeOctal(rd.substring(12)),
     })
   }
 
   /******  EXPORTERS   *******/
+
+  toBind(zone_opts) {
+    // Example: test.example.com. 3600 IN NSEC3PARAM 1 1 12 aabbccdd
+    return `${this.getFQDN('owner', zone_opts)}	${this.get('ttl')}	${this.get('class')}	NSEC3PARAM	${this.get('hash algorithm')}	${this.get('flags')}	${this.get('iterations')}	${this.get('salt')}
+`
+  }
+
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    let rdata = ''
+    rdata += TINYDNS.UInt8toOctal(this.get('hash algorithm'))
+    rdata += TINYDNS.UInt8toOctal(this.get('flags'))
+    rdata += TINYDNS.UInt16toOctal(this.get('iterations'))
+    rdata += TINYDNS.escapeOctal(dataRe, this.get('salt'))
+
+    return this.getTinydnsGeneric(rdata)
+  }
 }

package/rr/nxt.js

@@ -1,5 +1,7 @@
 import RR from '../rr.js'
 
+import * as TINYDNS from '../lib/tinydns.js'
+
 export default class NXT extends RR {
   constructor(opts) {
     super(opts)
@@ -41,6 +43,24 @@ export default class NXT extends RR {
 
   /******  IMPORTERS   *******/
 
+  fromTinydns(opts) {
+    const [owner, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 30) this.throwHelp('NXT fromTinydns, invalid n')
+
+    const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const [nextDomain, _escapedLen, binaryLen] = TINYDNS.unpackDomainName(rdata)
+
+    return new NXT({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'NXT',
+      'next domain': nextDomain,
+      'type bit map': binaryRdata.slice(binaryLen).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
   fromBind(opts) {
     // test.example.com  3600  IN  NXT NextDomain TypeBitMap
     const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)
@@ -55,6 +75,14 @@ export default class NXT extends RR {
   }
 
   /******  EXPORTERS   *******/
+
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.packDomainName(this.get('next domain')) + TINYDNS.escapeOctal(dataRe, this.get('type bit map')),
+    )
+  }
 }
 
 const removeParens = (a) => !['(', ')'].includes(a)

package/rr/openpgpkey.js

@@ -1,4 +1,5 @@
 import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
 
 export default class OPENPGPKEY extends RR {
   constructor(opts) {
@@ -42,5 +43,22 @@ export default class OPENPGPKEY extends RR {
     })
   }
 
+  fromTinydns(opts) {
+    return new OPENPGPKEY({
+      owner: this.fullyQualify(opts.owner),
+      ttl: parseInt(opts.ttl, 10),
+      type: 'OPENPGPKEY',
+      'public key': Buffer.from(TINYDNS.unescapeOctal(opts.rd), 'base64').toString('utf-8'),
+    })
+  }
+
   /******  EXPORTERS   *******/
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+    const escapedPublicKey = TINYDNS.escapeOctal(
+      dataRe,
+      Buffer.from(this.get('public key'), 'utf-8').toString('base64'),
+    )
+    return this.getTinydnsGeneric(escapedPublicKey)
+  }
 }

package/rr/sig.js

@@ -102,4 +102,14 @@ export default class SIG extends RR {
   // }
 
   /******  EXPORTERS   *******/
+
+  toBind(zone_opts) {
+    return `${this.getFQDN('owner', zone_opts)}	${this.get('ttl')}	${this.get('class')}	SIG${this.getRdataFields()
+      .slice(0, 4)
+      .map((f) => '	' + this.get(f))
+      .join('')}	${this.getRdataFields()
+      .slice(4, 8)
+      .map((f) => this.get(f))
+      .join('	')}	( ${this.get('signature')} )`
+  }
 }

package/rr/smimea.js

@@ -91,6 +91,23 @@ export default class SMIMEA extends RR {
     })
   }
 
+  fromTinydns(opts) {
+    const [owner, _typeId, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+
+    return new SMIMEA({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'SMIMEA',
+      'certificate usage': binaryRdata.readUInt8(0),
+      selector: binaryRdata.readUInt8(1),
+      'matching type': binaryRdata.readUInt8(2),
+      'certificate association data': binaryRdata.slice(3).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
   /******  EXPORTERS   *******/
   toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')

package/rr/svcb.js

@@ -62,6 +62,29 @@ export default class SVCB extends RR {
     })
   }
 
+  fromTinydns({ rd, owner, ttl }) {
+    if (rd.length < 6) {
+      this.throwHelp(`SVCB: RDATA too short: ${rd}`)
+    }
+
+    const priority = TINYDNS.octalToUInt16(rd.substring(0, 6))
+    const remainingRdata = rd.slice(6)
+
+    const [targetName, consumedLength] = TINYDNS.unpackDomainName(remainingRdata)
+
+    const params = remainingRdata.slice(consumedLength)
+    const unescapedParams = TINYDNS.unescapeOctal(params)
+
+    return new SVCB({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'SVCB',
+      priority: priority,
+      'target name': targetName,
+      params: unescapedParams,
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {

package/rr/tlsa.js

@@ -111,7 +111,7 @@ export default class TLSA extends RR {
       'matching type': bytes.readUInt8(2),
       'certificate association data': bytes.slice(3).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc.trim() || '',
     })
   }
 

package/rr/uri.js

@@ -40,7 +40,7 @@ export default class URI extends RR {
       target: TINYDNS.octalToChar(rdata.substring(16)),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc.trim() || '',
     })
   }