@nictool/dns-resource-record 1.6.1 → 1.7.0

package/rr/ds.js

@@ -1,21 +1,20 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
 
 export default class DS extends RR {
+  static typeName = 'DS'
+  static typeId = 43
+  static RFCs = [4034, 4509, 9619]
+  static rdataFields = [['key tag', 'u16'], 'algorithm', 'digest type', ['digest', 'str']]
+  static tags = ['dnssec']
+
   constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setKeyTag(val) {
-    // a 2 octet Key Tag field...in network byte order
-    if (!val) this.throwHelp(`DS: key tag is required`)
-    if (val.length > 2) this.throwHelp(`DS: key tag is too long`)
-
-    this.set('key tag', val)
-  }
-
   setAlgorithm(val) {
     if (!this.getAlgorithmOptions().has(val)) this.throwHelp(`DS: algorithm invalid`)
 
@@ -40,32 +39,10 @@ export default class DS extends RR {
     this.set('digest type', val)
   }
 
-  setDigest(val) {
-    if (!val) this.throwHelp(`DS: digest is required`)
-
-    this.set('digest', val)
-  }
-
   getDescription() {
     return 'Delegation Signer'
   }
 
-  getTags() {
-    return ['dnssec']
-  }
-
-  getRdataFields(arg) {
-    return ['key tag', 'algorithm', 'digest type', 'digest']
-  }
-
-  getRFCs() {
-    return [4034, 4509]
-  }
-
-  getTypeId() {
-    return 43
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -81,50 +58,59 @@ export default class DS extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  DS Key Tag Algorithm, Digest Type, Digest
-    const [owner, ttl, c, type, keytag, algorithm, digesttype] = bindline.split(/\s+/)
+  fromTinydns(opts) {
+    const { tinyline } = opts
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('DS fromTinydns, invalid n')
+
+    const binRdata = TINYDNS.octalRdataToBytes(rdata)
+
     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: bindline.split(/\s+/).slice(7).join(' ').trim(),
+      ttl,
+      type: 'DS',
+      'key tag': (binRdata[0] << 8) | binRdata[1],
+      algorithm: binRdata[2],
+      'digest type': binRdata[3],
+      digest: BINARY.bytesToHex(binRdata.subarray(4)).toUpperCase(),
+      timestamp,
+      location,
     })
   }
 
-  fromTinydns({ tinyline }) {
-    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
-    if (n != 43) this.throwHelp('DS fromTinydns, invalid n')
-
-    const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
-
+  fromWire({ owner, cls, ttl, rdata }) {
+    const dv = new DataView(rdata.buffer, rdata.byteOffset)
     return new DS({
-      owner: this.fullyQualify(fqdn),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
+      class: cls,
       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?.trim() ?? '',
+      'key tag': dv.getUint16(0),
+      algorithm: rdata[2],
+      'digest type': rdata[3],
+      digest: BINARY.bytesToHex(rdata.subarray(4)).toUpperCase(),
     })
   }
 
   /******  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')),
+        TINYDNS.packHex(this.get('digest').replace(/\s+/g, '')),
     )
   }
+
+  getWireRdata() {
+    const digestBytes = BINARY.hexToBytes(this.get('digest').replace(/\s+/g, ''))
+    const bytes = new Uint8Array(4 + digestBytes.length)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+    dv.setUint16(0, this.get('key tag'))
+    bytes[2] = this.get('algorithm')
+    bytes[3] = this.get('digest type')
+    bytes.set(digestBytes, 4)
+    return bytes
+  }
 }

package/rr/hinfo.js

@@ -3,6 +3,15 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class HINFO extends RR {
+  static typeName = 'HINFO'
+  static typeId = 13
+  static RFCs = [1034, 1035, 8482]
+  static rdataFields = [
+    ['cpu', 'qcharstr'],
+    ['os', 'qcharstr'],
+  ]
+  static tags = ['obsolete']
+
   constructor(opts) {
     super(opts)
   }
@@ -22,22 +31,6 @@ export default class HINFO extends RR {
     return 'Host Info'
   }
 
-  getTags() {
-    return ['obsolete']
-  }
-
-  getRdataFields(arg) {
-    return ['cpu', 'os']
-  }
-
-  getRFCs() {
-    return [1034, 1035, 8482]
-  }
-
-  getTypeId() {
-    return 13
-  }
-
   getCanonical() {
     return {
       owner: 'test.example.com.',
@@ -49,31 +42,7 @@ export default class HINFO extends RR {
     }
   }
 
-  getQuotedFields() {
-    return ['cpu', 'os']
-  }
-
   /******  IMPORTERS   *******/
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const regex =
-      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<class>IN)\s+(?<type>HINFO)\s+(?:"(?<qCPU>[^"]*)"|(?<uCPU>\S+))\s+(?:"(?<qOS>[^"]*)"|(?<uOS>\S+))$/i
-
-    const match = bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse HINFO: ${bindline}`)
-
-    const { owner, ttl, class: c, type, qCPU, uCPU, qOS, uOS } = match.groups
-
-    return new HINFO({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      cpu: qCPU ?? uCPU,
-      os: qOS ?? uOS,
-    })
-  }
-
   fromTinydns({ tinyline }) {
     // HINFO via generic, :fqdn:n:rdata:ttl:timestamp:lo
     const [fqdn, , rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
@@ -91,6 +60,18 @@ export default class HINFO extends RR {
   }
 
   /******  EXPORTERS   *******/
+
+  getWireRdata() {
+    const cpu = new TextEncoder().encode(this.get('cpu'))
+    const os = new TextEncoder().encode(this.get('os'))
+    const result = new Uint8Array(2 + cpu.length + os.length)
+    result[0] = cpu.length
+    result.set(cpu, 1)
+    result[1 + cpu.length] = os.length
+    result.set(os, 2 + cpu.length)
+    return result
+  }
+
   toTinydns() {
     return this.getTinydnsGeneric(
       [TINYDNS.packString(this.get('cpu')), TINYDNS.packString(this.get('os'))].join(''),

package/rr/hip.js

@@ -1,8 +1,15 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
+import * as WIRE from '../lib/wire.js'
 
 export default class HIP extends RR {
+  static typeName = 'HIP'
+  static typeId = 55
+  static RFCs = [8005]
+  static rdataFields = ['pk algorithm', 'hit', 'public key', 'rendezvous servers']
+
   constructor(opts) {
     super(opts)
   }
@@ -32,18 +39,6 @@ export default class HIP extends RR {
     return 'Host Identity Protocol'
   }
 
-  getRdataFields(arg) {
-    return ['pk algorithm', 'hit', 'public key', 'rendezvous servers']
-  }
-
-  getRFCs() {
-    return [8005]
-  }
-
-  getTypeId() {
-    return 55
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -64,22 +59,19 @@ export default class HIP extends RR {
     const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 55) this.throwHelp('HIP fromTinydns, invalid n')
 
-    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
-    const hitLen = bytes.readUInt8(0)
-    const pkAlgorithm = bytes.readUInt8(1)
-    const pkLen = bytes.readUInt16BE(2)
+    const bytes = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
+    const hitLen = bytes[0]
+    const pkAlgorithm = bytes[1]
+    const pkLen = (bytes[2] << 8) | bytes[3]
 
-    const hit = bytes
-      .slice(4, 4 + hitLen)
-      .toString('hex')
-      .toUpperCase()
-    const publicKey = bytes.slice(4 + hitLen, 4 + hitLen + pkLen).toString('base64')
+    const hit = BINARY.bytesToHex(bytes.subarray(4, 4 + hitLen)).toUpperCase()
+    const publicKey = BINARY.bytesToBase64(bytes.subarray(4 + hitLen, 4 + hitLen + pkLen))
 
     const rvsNames = []
     let pos = 4 + hitLen + pkLen
     while (pos < bytes.length) {
       const [name, newPos] = TINYDNS.unpackDomainName(
-        [...bytes.slice(pos)]
+        [...bytes.subarray(pos)]
           .map((b) => (b < 32 || b > 126 ? TINYDNS.UInt8toOctal(b) : String.fromCharCode(b)))
           .join(''),
       )
@@ -102,8 +94,20 @@ export default class HIP extends RR {
 
   fromBind({ bindline }) {
     // owner  ttl  IN  HIP  pk-algorithm HIT public-key [rendezvous-server...]
+    // The public key may be split across multiple lines and joined with spaces
+    // by the zone parser. Base64 chars are [A-Za-z0-9+/=]; domain names contain '.'.
     const parts = bindline.split(/\s+/)
-    const [owner, ttl, c, type, pkAlgorithm, hit, publicKey] = parts
+    const [owner, ttl, c, type, pkAlgorithm, hit] = parts
+    const rest = parts.slice(6)
+    const keyParts = []
+    const rvsParts = []
+    for (const token of rest) {
+      if (/^[A-Za-z0-9+/=]+$/.test(token)) {
+        keyParts.push(token)
+      } else {
+        rvsParts.push(token)
+      }
+    }
     return new HIP({
       owner,
       ttl: parseInt(ttl, 10),
@@ -111,8 +115,34 @@ export default class HIP extends RR {
       type,
       'pk algorithm': parseInt(pkAlgorithm, 10),
       hit,
+      'public key': keyParts.join(''),
+      'rendezvous servers': rvsParts.join(' ').trim(),
+    })
+  }
+
+  fromWire({ owner, cls, ttl, rdata }) {
+    const dv = new DataView(rdata.buffer, rdata.byteOffset)
+    const hitLen = rdata[0]
+    const pkAlgorithm = rdata[1]
+    const pkLen = dv.getUint16(2)
+    const hit = BINARY.bytesToHex(rdata.subarray(4, 4 + hitLen)).toUpperCase()
+    const publicKey = BINARY.bytesToBase64(rdata.subarray(4 + hitLen, 4 + hitLen + pkLen))
+    const rvsNames = []
+    let pos = 4 + hitLen + pkLen
+    while (pos < rdata.length) {
+      const { fqdn, end } = this.wireUnpackDomain(rdata, pos)
+      rvsNames.push(fqdn)
+      pos = end
+    }
+    return new HIP({
+      owner,
+      ttl,
+      class: cls,
+      type: 'HIP',
+      'pk algorithm': pkAlgorithm,
+      hit,
       'public key': publicKey,
-      'rendezvous servers': parts.slice(7).join(' ').trim(),
+      'rendezvous servers': rvsNames.join(' '),
     })
   }
 
@@ -124,8 +154,9 @@ export default class HIP extends RR {
   }
 
   toTinydns() {
-    const hitBytes = Buffer.from(this.get('hit'), 'hex')
-    const pkBytes = Buffer.from(this.get('public key'), 'base64')
+    const hitHex = this.get('hit')
+    const hitBytes = BINARY.hexToBytes(hitHex)
+    const pkBytes = BINARY.base64ToBytes(this.get('public key'))
     const rs = this.get('rendezvous servers')
 
     let rdata = ''
@@ -140,4 +171,35 @@ export default class HIP extends RR {
 
     return this.getTinydnsGeneric(rdata)
   }
+
+  getWireRdata() {
+    const hitHex = this.get('hit')
+    const hitBytes = BINARY.hexToBytes(hitHex)
+    const pkBytes = BINARY.base64ToBytes(this.get('public key'))
+    const rs = this.get('rendezvous servers')
+
+    const rsNames = rs ? rs.split(/\s+/) : []
+    const rsDomains = rsNames.map((name) => WIRE.wirePackDomain(name))
+    const rsTotalLen = rsDomains.reduce((sum, b) => sum + b.length, 0)
+
+    const totalLen = 1 + 1 + 2 + hitBytes.length + pkBytes.length + rsTotalLen
+    const bytes = new Uint8Array(totalLen)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+
+    let pos = 0
+    bytes[pos++] = hitBytes.length
+    bytes[pos++] = this.get('pk algorithm')
+    dv.setUint16(pos, pkBytes.length)
+    pos += 2
+    bytes.set(hitBytes, pos)
+    pos += hitBytes.length
+    bytes.set(pkBytes, pos)
+    pos += pkBytes.length
+    for (const rdomain of rsDomains) {
+      bytes.set(rdomain, pos)
+      pos += rdomain.length
+    }
+
+    return bytes
+  }
 }

package/rr/https.js

@@ -1,8 +1,19 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import * as WIRE from '../lib/wire.js'
 
 export default class HTTPS extends RR {
+  static typeName = 'HTTPS'
+  static typeId = 65
+  static RFCs = [9460]
+  static tags = ['common']
+  static rdataFields = [
+    ['priority', 'u16'],
+    ['target name', 'fqdn'],
+    ['params', 'svcparams'],
+  ]
+
   constructor(opts) {
     super(opts)
   }
@@ -32,22 +43,6 @@ export default class HTTPS extends RR {
     return 'HTTP Semantics'
   }
 
-  getTags() {
-    return ['common']
-  }
-
-  getRdataFields(arg) {
-    return ['priority', 'target name', 'params']
-  }
-
-  getRFCs() {
-    return [9460]
-  }
-
-  getTypeId() {
-    return 65
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -77,36 +72,19 @@ export default class HTTPS extends RR {
   }
 
   fromTinydns({ tinyline }) {
-    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
-
-    if (rd.length < 6) {
-      this.throwHelp(`HTTPS: RDATA too short: ${rd}`)
-    }
-
-    const binary = Buffer.from(TINYDNS.octalToChar(rd), 'binary')
-    const priority = binary.readUInt16BE(0)
-
-    let pos = 2
-    const labels = []
-    while (true) {
-      const len = binary.readUInt8(pos)
-      pos += 1
-      if (len === 0) break
-      labels.push(binary.slice(pos, pos + len).toString())
-      pos += len
-    }
-    const targetName = `${labels.join('.')}.`
-    const params = binary.slice(pos).toString()
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('HTTPS fromTinydns, invalid n')
+    const { priority, targetName, params } = TINYDNS.parseSvcbLikeRdata(rdata, 'HTTPS')
 
     return new HTTPS({
-      owner: this.fullyQualify(owner),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'HTTPS',
       priority,
       'target name': targetName,
       params,
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      timestamp,
+      location,
     })
   }
 
@@ -121,4 +99,14 @@ export default class HTTPS extends RR {
         TINYDNS.escapeOctal(dataRe, this.get('params')),
     )
   }
+
+  getWireRdata() {
+    const targetBytes = this.wirePackDomain(this.get('target name'))
+    const paramsBytes = WIRE.svcParamsToWire(this.get('params'))
+    const result = new Uint8Array(2 + targetBytes.length + paramsBytes.length)
+    new DataView(result.buffer).setUint16(0, this.get('priority'))
+    result.set(targetBytes, 2)
+    result.set(paramsBytes, 2 + targetBytes.length)
+    return result
+  }
 }

package/rr/ipseckey.js

@@ -1,8 +1,16 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
+import * as WIRE from '../lib/wire.js'
 
 export default class IPSECKEY extends RR {
+  static typeName = 'IPSECKEY'
+  static typeId = 45
+  static RFCs = [4025]
+  static rdataFields = ['precedence', 'gateway type', 'algorithm', 'gateway', 'publickey']
+  static tags = ['security']
+
   constructor(opts) {
     super(opts)
   }
@@ -62,8 +70,7 @@ export default class IPSECKEY extends RR {
   }
 
   setPublickey(val) {
-    // if (val) this.throwHelp(`IPSECKEY: publickey is optional`)
-
+    if (val) this.isBase64('IPSECKEY', 'publickey', val)
     this.set('publickey', val)
   }
 
@@ -71,22 +78,6 @@ export default class IPSECKEY extends RR {
     return 'IPsec Keying'
   }
 
-  getTags() {
-    return ['security']
-  }
-
-  getRdataFields(arg) {
-    return ['precedence', 'gateway type', 'algorithm', 'gateway', 'publickey']
-  }
-
-  getRFCs() {
-    return [4025]
-  }
-
-  getTypeId() {
-    return 45
-  }
-
   getCanonical() {
     return {
       owner: '38.2.0.192.in-addr.arpa.',
@@ -161,6 +152,49 @@ export default class IPSECKEY extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const precedence = rdata[0]
+    const gwType = rdata[1]
+    const algorithm = rdata[2]
+    let gateway, keyStart
+    switch (gwType) {
+      case 0:
+        gateway = '.'
+        keyStart = 3
+        break
+      case 1:
+        gateway = [...rdata.subarray(3, 7)].join('.')
+        keyStart = 7
+        break
+      case 2: {
+        const dv = new DataView(rdata.buffer, rdata.byteOffset + 3)
+        const groups = []
+        for (let i = 0; i < 16; i += 2) groups.push(dv.getUint16(i).toString(16).padStart(4, '0'))
+        gateway = groups.join(':')
+        keyStart = 19
+        break
+      }
+      case 3: {
+        const { fqdn, end } = this.wireUnpackDomain(rdata, 3)
+        gateway = fqdn
+        keyStart = end
+        break
+      }
+    }
+    const publickey = BINARY.bytesToBase64(rdata.subarray(keyStart))
+    return new IPSECKEY({
+      owner,
+      ttl,
+      class: cls,
+      type: 'IPSECKEY',
+      precedence,
+      'gateway type': gwType,
+      algorithm,
+      gateway,
+      publickey,
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {
@@ -190,4 +224,49 @@ export default class IPSECKEY extends RR {
 
     return this.getTinydnsGeneric(rdata)
   }
+
+  getWireRdata() {
+    const pubkeyBytes = BINARY.base64ToBytes(this.get('publickey'))
+    const gwType = this.get('gateway type')
+
+    let gwBytes
+    switch (gwType) {
+      case 0:
+        gwBytes = new Uint8Array(0)
+        break
+      case 1:
+        gwBytes = new Uint8Array(4)
+        this.get('gateway')
+          .split('.')
+          .forEach((part, i) => {
+            gwBytes[i] = parseInt(part, 10)
+          })
+        break
+      case 2:
+        gwBytes = new Uint8Array(16)
+        {
+          const parts = this.get('gateway').split(':')
+          let pos = 0
+          for (const part of parts) {
+            if (part === '') continue
+            const val = parseInt(part, 16)
+            gwBytes[pos++] = (val >>> 8) & 0xff
+            gwBytes[pos++] = val & 0xff
+          }
+        }
+        break
+      case 3:
+        gwBytes = WIRE.wirePackDomain(this.get('gateway'))
+        break
+    }
+
+    const bytes = new Uint8Array(3 + gwBytes.length + pubkeyBytes.length)
+    bytes[0] = this.get('precedence')
+    bytes[1] = gwType
+    bytes[2] = this.get('algorithm')
+    bytes.set(gwBytes, 3)
+    bytes.set(pubkeyBytes, 3 + gwBytes.length)
+
+    return bytes
+  }
 }