@nictool/dns-resource-record 1.6.1 → 1.7.0

package/rr/cert.js

@@ -1,8 +1,34 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
 
 export default class CERT extends RR {
+  static typeName = 'CERT'
+  static typeId = 37
+  static RFCs = [2538, 4398]
+  static rdataFields = [
+    ['cert type', 'certtype'],
+    ['key tag', 'u16'],
+    ['algorithm', 'u8'],
+    ['certificate', 'base64'],
+  ]
+
+  static CERT_TYPES = {
+    PKIX: 1,
+    SPKI: 2,
+    PGP: 3,
+    IPKIX: 4,
+    ISPKI: 5,
+    IPGP: 6,
+    ACPKIX: 7,
+    IACPKIX: 8,
+    URI: 253,
+    OID: 254,
+  }
+
+  static CERT_TYPES_REVERSE = Object.fromEntries(Object.entries(CERT.CERT_TYPES).map(([k, v]) => [v, k]))
+
   constructor(opts) {
     super(opts)
   }
@@ -15,20 +41,8 @@ export default class CERT extends RR {
       this.throwHelp('cert type is required')
     }
     // Accept both mnemonic and numeric, but validate mnemonic
-    if (typeof val === 'string') {
-      const types = {
-        PKIX: 1,
-        SPKI: 2,
-        PGP: 3,
-        IPKIX: 4,
-        ISPKI: 5,
-        IPGP: 6,
-        ACPKIX: 7,
-        IACPKIX: 8,
-        URI: 253,
-        OID: 254,
-      }
-      if (!Object.hasOwn(types, val)) {
+    if (typeof val === 'string' && !/^[0-9]+$/.test(val)) {
+      if (!Object.hasOwn(CERT.CERT_TYPES, val)) {
         this.throwHelp(`CERT: unknown cert type mnemonic: ${val}`)
       }
     } else {
@@ -39,45 +53,18 @@ export default class CERT extends RR {
 
   getCertTypeValue(val) {
     if (typeof val === 'number') return val
-    const types = {
-      PKIX: 1,
-      SPKI: 2,
-      PGP: 3,
-      IPKIX: 4,
-      ISPKI: 5,
-      IPGP: 6,
-      ACPKIX: 7,
-      IACPKIX: 8,
-      URI: 253,
-      OID: 254,
-    }
-    if (Object.hasOwn(types, val)) return types[val]
+    if (/^[0-9]+$/.test(val)) return parseInt(val, 10)
+    if (Object.hasOwn(CERT.CERT_TYPES, val)) return CERT.CERT_TYPES[val]
     this.throwHelp(`CERT: unknown cert type mnemonic: ${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
     if (val === undefined || val === null || val === '') {
       this.throwHelp('certificate is required and cannot be empty')
     }
+    this.isBase64('CERT', 'certificate', val.replace(/[\s()]/g, ''))
     this.set('certificate', val)
   }
 
@@ -85,18 +72,6 @@ export default class CERT extends RR {
     return 'Certificate'
   }
 
-  getRdataFields() {
-    return ['cert type', 'key tag', 'algorithm', 'certificate']
-  }
-
-  getRFCs() {
-    return [2538, 4398]
-  }
-
-  getTypeId() {
-    return 37
-  }
-
   getCanonical() {
     return {
       owner: 'mail.example.com.',
@@ -106,44 +81,31 @@ export default class CERT extends RR {
       'cert type': 'PGP',
       'key tag': 0,
       algorithm: 0,
-      certificate: 'hexidecimalkeystring1',
+      certificate: 'AQIDBA==',
     }
   }
 
   /******  IMPORTERS   *******/
 
   fromTinydns({ tinyline }) {
-    const [owner, n, rdata, ttl, ts, loc] = tinyline.slice(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]
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('CERT fromTinydns, invalid n')
+
+    const bytes = TINYDNS.octalRdataToBytes(rdata)
+    const typeNum = (bytes[0] << 8) | bytes[1]
+
+    const certType = CERT.CERT_TYPES_REVERSE[typeNum] ?? typeNum
 
     return new CERT({
-      owner: this.fullyQualify(owner),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'CERT',
       'cert type': certType,
-      'key tag': bytes.readUInt16BE(2),
-      algorithm: bytes.readUInt8(4),
-      certificate: bytes.slice(5).toString(),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      'key tag': (bytes[2] << 8) | bytes[3],
+      algorithm: bytes[4],
+      certificate: BINARY.bytesToBase64(bytes.subarray(5)),
+      timestamp,
+      location,
     })
   }
 
@@ -165,13 +127,22 @@ export default class CERT extends RR {
   /******  EXPORTERS   *******/
 
   toTinydns() {
-    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
-
     return this.getTinydnsGeneric(
       TINYDNS.UInt16toOctal(this.getCertTypeValue(this.get('cert type'))) +
         TINYDNS.UInt16toOctal(this.get('key tag')) +
         TINYDNS.UInt8toOctal(this.get('algorithm')) +
-        TINYDNS.escapeOctal(dataRe, this.get('certificate')),
+        TINYDNS.base64toOctal(this.get('certificate').replace(/[\s()]/g, '')),
     )
   }
+
+  getWireRdata() {
+    const certBytes = BINARY.base64ToBytes(this.get('certificate').replace(/[\s()]/g, ''))
+    const bytes = new Uint8Array(5 + certBytes.length)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+    dv.setUint16(0, this.getCertTypeValue(this.get('cert type')))
+    dv.setUint16(2, this.get('key tag'))
+    bytes[4] = this.get('algorithm')
+    bytes.set(certBytes, 5)
+    return bytes
+  }
 }

package/rr/cname.js

@@ -1,46 +1,21 @@
 import RR from '../rr.js'
 
 export default class CNAME extends RR {
+  static typeName = 'CNAME'
+  static typeId = 5
+  static RFCs = [1035, 2181]
+  static tinydnsType = 'C'
+  static rdataFields = [['cname', 'fqdn']]
+  static tags = ['common']
+
   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) this.throwHelp('CNAME: cname is required')
-
-    if (this.isIPv4(val) || this.isIPv6(val)) this.throwHelp(`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'
   }
 
-  getTags() {
-    return ['common']
-  }
-
-  getRdataFields(arg) {
-    return ['cname']
-  }
-
-  getRFCs() {
-    return [1035, 2181]
-  }
-
-  getTypeId() {
-    return 5
-  }
-
   getCanonical() {
     return {
       owner: 'www.example.com.',
@@ -51,39 +26,8 @@ export default class CNAME extends RR {
     }
   }
 
-  /******  IMPORTERS   *******/
-  fromTinydns({ tinyline }) {
-    // Cfqdn:p:ttl:timestamp:lo
-    const [fqdn, p, ttl, ts, loc] = tinyline.slice(1).split(':')
-
-    return new CNAME({
-      owner: this.fullyQualify(fqdn),
-      ttl: parseInt(ttl, 10),
-      type: 'CNAME',
-      cname: this.fullyQualify(p),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
-    })
-  }
-
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  CNAME  ...
-    const [owner, ttl, c, type, cname] = bindline.split(/\s+/)
-    return new CNAME({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      cname,
-    })
-  }
-
   /******  EXPORTERS   *******/
   getWireRdata() {
     return this.wirePackDomain(this.get('cname'))
   }
-
-  toTinydns() {
-    return `C${this.getTinyFQDN('owner')}:${this.get('cname')}:${this.getTinydnsPostamble()}\n`
-  }
 }

package/rr/dhcid.js

@@ -3,6 +3,11 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DHCID extends RR {
+  static typeName = 'DHCID'
+  static typeId = 49
+  static RFCs = [4701]
+  static rdataFields = [['data', 'base64']]
+
   constructor(opts) {
     super(opts)
   }
@@ -10,6 +15,7 @@ export default class DHCID extends RR {
   /****** Resource record specific setters   *******/
   setData(val) {
     if (!val) this.throwHelp('DHCID: data is required')
+    this.isBase64('DHCID', 'data', val)
     this.set('data', val)
   }
 
@@ -17,18 +23,6 @@ export default class DHCID extends RR {
     return 'DHCP Identifier'
   }
 
-  getRdataFields(arg) {
-    return ['data']
-  }
-
-  getRFCs() {
-    return [4701]
-  }
-
-  getTypeId() {
-    return 49
-  }
-
   getCanonical() {
     return {
       owner: 'host.example.com.',
@@ -42,33 +36,29 @@ export default class DHCID extends RR {
   /******  IMPORTERS   *******/
   fromTinydns({ tinyline }) {
     // DHCID via generic, :fqdn:49:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
-    if (n != 49) this.throwHelp('DHCID fromTinydns, invalid n')
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('DHCID fromTinydns, invalid n')
 
     return new DHCID({
-      owner: this.fullyQualify(fqdn),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'DHCID',
       data: TINYDNS.octalToBase64(rdata),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      timestamp,
+      location,
     })
   }
 
-  fromBind({ bindline }) {
-    // host.example.com  3600  IN  DHCID  <base64data>
-    const parts = bindline.split(/\s+/)
-    const [owner, ttl, c, type] = parts
-    return new DHCID({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      data: parts.slice(4).join(''),
-    })
+  /******  EXPORTERS   *******/
+
+  getWireRdata() {
+    return new Uint8Array(
+      atob(this.get('data'))
+        .split('')
+        .map((c) => c.charCodeAt(0)),
+    )
   }
 
-  /******  EXPORTERS   *******/
   toTinydns() {
     return this.getTinydnsGeneric(TINYDNS.base64toOctal(this.get('data')))
   }

package/rr/dname.js

@@ -2,39 +2,19 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DNAME extends RR {
+  static typeName = 'DNAME'
+  static typeId = 39
+  static RFCs = [2672, 6672]
+  static rdataFields = [['target', 'fqdn']]
+
   constructor(opts) {
     super(opts)
   }
 
-  /****** Resource record specific setters   *******/
-  setTarget(val) {
-    if (!val) this.throwHelp('DNAME: target is required')
-
-    if (this.isIPv4(val) || this.isIPv6(val)) this.throwHelp(`DNAME: target must be a domain name`)
-
-    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
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -61,19 +41,12 @@ export default class DNAME extends RR {
     })
   }
 
-  fromBind({ bindline }) {
-    // test.example.com  3600  IN  DNAME  ...
-    const [owner, ttl, c, type, target] = bindline.split(/\s+/)
-    return new DNAME({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type,
-      target,
-    })
+  /******  EXPORTERS   *******/
+
+  getWireRdata() {
+    return this.wirePackDomain(this.get('target'))
   }
 
-  /******  EXPORTERS   *******/
   toTinydns() {
     const rdata = TINYDNS.packDomainName(this.get('target'))
     return this.getTinydnsGeneric(rdata)

package/rr/dnskey.js

@@ -1,8 +1,20 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
 
 export default class DNSKEY extends RR {
+  static typeName = 'DNSKEY'
+  static typeId = 48
+  static RFCs = [4034, 6014, 8624, 9619, 9905]
+  static rdataFields = [
+    ['flags', 'u16'],
+    ['protocol', 'u8'],
+    ['algorithm', 'u8'],
+    ['publickey', 'base64'],
+  ]
+  static tags = ['dnssec']
+
   constructor(opts) {
     super(opts)
   }
@@ -71,7 +83,7 @@ export default class DNSKEY extends RR {
 
   setPublickey(val) {
     if (!val) this.throwHelp(`DNSKEY: publickey is required`)
-
+    this.isBase64('DNSKEY', 'publickey', val.replace(/[\s()]/g, ''))
     this.set('publickey', val)
   }
 
@@ -79,22 +91,6 @@ export default class DNSKEY extends RR {
     return 'DNS Public Key'
   }
 
-  getTags() {
-    return ['dnssec']
-  }
-
-  getRdataFields(arg) {
-    return ['flags', 'protocol', 'algorithm', 'publickey']
-  }
-
-  getRFCs() {
-    return [4034, 6014, 8624]
-  }
-
-  getTypeId() {
-    return 48
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -104,7 +100,8 @@ export default class DNSKEY extends RR {
       flags: 256,
       protocol: 3,
       algorithm: 5,
-      publickey: 'AQPSKAsj8...',
+      publickey:
+        'AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwIXAqcOTiW7iHnQt5hwVAAAAA==',
     }
   }
 
@@ -136,34 +133,43 @@ export default class DNSKEY extends RR {
   }
 
   fromTinydns({ tinyline }) {
-    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.substring(1).split(':')
-    if (n != 48) this.throwHelp('DNSKEY fromTinydns, invalid n')
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('DNSKEY fromTinydns, invalid n')
 
-    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const bytes = TINYDNS.octalRdataToBytes(rdata)
 
     return new DNSKEY({
-      owner: this.fullyQualify(fqdn),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'DNSKEY',
-      flags: bytes.readUInt16BE(0),
-      protocol: bytes.readUInt8(2),
-      algorithm: bytes.readUInt8(3),
-      publickey: bytes.slice(4).toString(),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      flags: (bytes[0] << 8) | bytes[1],
+      protocol: bytes[2],
+      algorithm: bytes[3],
+      publickey: BINARY.bytesToBase64(bytes.subarray(4)),
+      timestamp,
+      location,
     })
   }
 
   /******  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')),
+        TINYDNS.base64toOctal(this.get('publickey').replace(/[\s()]/g, '')),
     )
   }
+
+  getWireRdata() {
+    const keyBytes = BINARY.base64ToBytes(this.get('publickey').replace(/[\s()]/g, ''))
+    const bytes = new Uint8Array(4 + keyBytes.length)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+    dv.setUint16(0, this.get('flags'))
+    bytes[2] = this.get('protocol')
+    bytes[3] = this.get('algorithm')
+    bytes.set(keyBytes, 4)
+    return bytes
+  }
 }