@nictool/dns-resource-record 1.6.0 → 1.7.0

package/rr/nsec.js

@@ -1,8 +1,15 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import { DNS_TYPE_IDS } from '../lib/binary.js'
 
 export default class NSEC extends RR {
+  static typeName = 'NSEC'
+  static typeId = 47
+  static RFCs = [4034]
+  static rdataFields = ['next domain', 'type bit maps']
+  static tags = ['dnssec']
+
   constructor(opts) {
     super(opts)
     if (opts === null) return
@@ -29,22 +36,6 @@ export default class NSEC extends RR {
     return 'Next Secure'
   }
 
-  getTags() {
-    return ['dnssec']
-  }
-
-  getRdataFields(arg) {
-    return ['next domain', 'type bit maps']
-  }
-
-  getRFCs() {
-    return [4034]
-  }
-
-  getTypeId() {
-    return 47
-  }
-
   getCanonical() {
     return {
       owner: 'alfa.example.com.',
@@ -60,7 +51,7 @@ export default class NSEC extends RR {
 
   fromTinydns({ tinyline }) {
     const [owner, _typeId, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
-    const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const binaryRdata = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
     const [nextDomain, _escapedLen, binaryLen] = TINYDNS.unpackDomainName(rdata)
 
     return new NSEC({
@@ -68,7 +59,7 @@ export default class NSEC extends RR {
       ttl: parseInt(ttl, 10),
       type: 'NSEC',
       'next domain': nextDomain,
-      'type bit maps': binaryRdata.slice(binaryLen).toString(),
+      'type bit maps': new TextDecoder().decode(binaryRdata.subarray(binaryLen)),
       timestamp: ts,
       location: loc?.trim() ?? '',
     })
@@ -87,6 +78,19 @@ export default class NSEC extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const { fqdn: nextDomain, end } = this.wireUnpackDomain(rdata, 0)
+    const typeBitMaps = nsecBitmapToTypes(rdata.subarray(end))
+    return new NSEC({
+      owner,
+      ttl,
+      class: cls,
+      type: 'NSEC',
+      'next domain': nextDomain,
+      'type bit maps': typeBitMaps,
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {
@@ -97,6 +101,73 @@ export default class NSEC extends RR {
         TINYDNS.escapeOctal(dataRe, this.get('type bit maps')),
     )
   }
+
+  getWireRdata() {
+    const nameBytes = this.wirePackDomain(this.get('next domain'))
+    const bitmapBytes = typesToNsecBitmap(this.get('type bit maps'))
+    const result = new Uint8Array(nameBytes.length + bitmapBytes.length)
+    result.set(nameBytes)
+    result.set(bitmapBytes, nameBytes.length)
+    return result
+  }
 }
 
 const removeParens = (a) => !['(', ')'].includes(a)
+
+function nsecBitmapToTypes(bitmap) {
+  const DNS_TYPE_NAMES = Object.fromEntries(Object.entries(DNS_TYPE_IDS).map(([k, v]) => [v, k]))
+  const types = []
+  let pos = 0
+  while (pos + 2 <= bitmap.length) {
+    const windowNum = bitmap[pos]
+    const bitmapLen = bitmap[pos + 1]
+    pos += 2
+    for (let i = 0; i < bitmapLen; i++) {
+      const byte = bitmap[pos + i]
+      for (let bit = 0; bit < 8; bit++) {
+        if (byte & (0x80 >> bit)) {
+          const typeId = windowNum * 256 + i * 8 + bit
+          types.push(DNS_TYPE_NAMES[typeId] ?? `TYPE${typeId}`)
+        }
+      }
+    }
+    pos += bitmapLen
+  }
+  return types.join(' ')
+}
+
+function typesToNsecBitmap(typeNamesStr) {
+  const typeIds = typeNamesStr
+    .trim()
+    .split(/\s+/)
+    .map((t) => {
+      if (/^TYPE\d+$/i.test(t)) return parseInt(t.slice(4), 10)
+      return DNS_TYPE_IDS[t.toUpperCase()]
+    })
+    .filter((id) => id !== undefined && id >= 0)
+
+  const windows = new Map()
+  for (const id of typeIds) {
+    const w = Math.floor(id / 256)
+    if (!windows.has(w)) windows.set(w, [])
+    windows.get(w).push(id % 256)
+  }
+
+  const blocks = []
+  for (const [wNum, bits] of [...windows.entries()].sort((a, b) => a[0] - b[0])) {
+    const maxBit = Math.max(...bits)
+    const bitmapLen = Math.floor(maxBit / 8) + 1
+    const bitmap = new Uint8Array(bitmapLen)
+    for (const b of bits) bitmap[Math.floor(b / 8)] |= 0x80 >> (b % 8)
+    blocks.push(new Uint8Array([wNum, bitmapLen, ...bitmap]))
+  }
+
+  const total = blocks.reduce((s, b) => s + b.length, 0)
+  const result = new Uint8Array(total)
+  let pos = 0
+  for (const b of blocks) {
+    result.set(b, pos)
+    pos += b.length
+  }
+  return result
+}

package/rr/nsec3.js

@@ -3,6 +3,19 @@ import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class NSEC3 extends RR {
+  static typeName = 'NSEC3'
+  static typeId = 50
+  static RFCs = [5155, 9077]
+  static rdataFields = [
+    'hash algorithm',
+    'flags',
+    'iterations',
+    'salt',
+    'next hashed owner name',
+    'type bit maps',
+  ]
+  static tags = ['dnssec']
+
   constructor(opts) {
     super(opts)
     if (opts === null) return
@@ -64,22 +77,6 @@ export default class NSEC3 extends RR {
     return 'Next Secure'
   }
 
-  getTags() {
-    return ['dnssec']
-  }
-
-  getRdataFields(arg) {
-    return ['hash algorithm', 'flags', 'iterations', 'salt', 'next hashed owner name', 'type bit maps']
-  }
-
-  getRFCs() {
-    return [5155, 9077]
-  }
-
-  getTypeId() {
-    return 50
-  }
-
   getCanonical() {
     return {
       owner: 'test.example.com.',
@@ -100,7 +97,10 @@ export default class NSEC3 extends RR {
   fromBind({ bindline }) {
     // test.example.com. 3600 IN NSEC3 1 1 12 aabbccdd (2vptu5timamqttgl4luu9kg21e0aor3s A RRSIG)
     const [owner, ttl, c, type, ha, flags, iterations, salt] = bindline.split(/\s+/)
-    const rdata = bindline.split(/\(|\)/)[1]
+    // rdata may be parenthesized or inline
+    const rdataStr = bindline.includes('(')
+      ? bindline.split(/\(|\)/)[1]
+      : bindline.split(/\s+/).slice(8).join(' ')
 
     return new NSEC3({
       owner,
@@ -111,8 +111,8 @@ export default class NSEC3 extends RR {
       flags: parseInt(flags, 10),
       iterations: parseInt(iterations, 10),
       salt,
-      'next hashed owner name': rdata.split(/\s+/)[0],
-      'type bit maps': rdata.split(/\s+/).slice(1).join('	'),
+      'next hashed owner name': rdataStr.trim().split(/\s+/)[0],
+      'type bit maps': rdataStr.trim().split(/\s+/).slice(1).join('\t'),
     })
   }
 
@@ -120,11 +120,12 @@ export default class NSEC3 extends RR {
     const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 50) this.throwHelp('NSEC3 fromTinydns, invalid n')
 
-    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const bytes = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
 
-    const hashAlgorithm = bytes.readUInt8(0)
-    const flags = bytes.readUInt8(1)
-    const iterations = bytes.readUInt16BE(2)
+    const hashAlgorithm = bytes[0]
+    const flags = bytes[1]
+    const iterations = dv.getUint16(2)
 
     // The remaining bytes in the buffer contain:
     // Salt Length (1 octet)
@@ -148,6 +149,23 @@ export default class NSEC3 extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const dv = new DataView(rdata.buffer, rdata.byteOffset)
+    const { salt, nextHashedOwnerName, typeBitMaps } = parseNSEC3Buffer(rdata)
+    return new NSEC3({
+      owner,
+      ttl,
+      class: cls,
+      type: 'NSEC3',
+      'hash algorithm': rdata[0],
+      flags: rdata[1],
+      iterations: dv.getUint16(2),
+      salt,
+      'next hashed owner name': nextHashedOwnerName,
+      'type bit maps': typeBitMaps,
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toBind(zone_opts) {
@@ -173,15 +191,33 @@ export default class NSEC3 extends RR {
         TINYDNS.escapeOctal(dataRe, this.get('type bit maps')),
     )
   }
+
+  getWireRdata() {
+    const tail = `${this.get('salt')}${this.get('next hashed owner name')}${this.get('type bit maps')}`
+    const tailBytes = new TextEncoder().encode(tail)
+
+    const totalLen = 4 + tailBytes.length
+    const bytes = new Uint8Array(totalLen)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+
+    let pos = 0
+    bytes[pos++] = this.get('hash algorithm')
+    bytes[pos++] = this.get('flags')
+    dv.setUint16(pos, this.get('iterations'))
+    pos += 2
+    bytes.set(tailBytes, pos)
+
+    return bytes
+  }
 }
 
 function parseNSEC3Buffer(bytes) {
-  // bytes is a Buffer containing the full RDATA binary (hash alg, flags, iterations, then ASCII salt + next-hashed + type bit maps)
+  // bytes is a Uint8Array containing the full RDATA binary (hash alg, flags, iterations, then ASCII salt + next-hashed + type bit maps)
   // Start after the first 4 bytes (hash alg, flags, iterations)
-  const rest = bytes.slice(4).toString('utf8')
+  const rest = new TextDecoder().decode(bytes.subarray(4))
 
   // determine expected next hashed owner name length from hash algorithm
-  const hashAlgorithm = bytes.readUInt8(0)
+  const hashAlgorithm = bytes[0]
   // common mapping: algorithm 1 => SHA-1 => 20 bytes => base32 length 32
   const expectedLen = hashAlgorithm === 1 ? 32 : hashAlgorithm === 2 ? 52 : 32
 

package/rr/nsec3param.js

@@ -1,7 +1,14 @@
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
 
 export default class NSEC3PARAM extends RR {
+  static typeName = 'NSEC3PARAM'
+  static typeId = 51
+  static RFCs = [5155]
+  static rdataFields = ['hash algorithm', 'flags', 'iterations', 'salt']
+  static tags = ['dnssec']
+
   constructor(opts) {
     super(opts)
     if (opts === null) return
@@ -57,22 +64,6 @@ export default class NSEC3PARAM extends RR {
     return 'Next Secure Parameters'
   }
 
-  getTags() {
-    return ['dnssec']
-  }
-
-  getRdataFields(arg) {
-    return ['hash algorithm', 'flags', 'iterations', 'salt']
-  }
-
-  getRFCs() {
-    return [5155]
-  }
-
-  getTypeId() {
-    return 51
-  }
-
   getCanonical() {
     return {
       owner: 'example.com.',
@@ -88,62 +79,74 @@ export default class NSEC3PARAM extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind({ bindline }) {
-    // 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] = bindline.split(/\s+/)
-    return new NSEC3PARAM({
-      owner,
-      ttl: parseInt(ttl, 10),
-      class: c,
-      type: type,
-      'hash algorithm': parseInt(ha, 10),
-      flags: parseInt(flags, 10),
-      iterations: parseInt(iterations, 10),
-      salt: salt,
-    })
-  }
-
   fromTinydns({ tinyline }) {
     // RDATA format: Hash Algorithm (3 octal chars) + Flags (3 octal chars) + Iterations (6 octal chars) + Salt (escaped hex string)
-    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
-    if (rd.length < 4) {
-      this.throwHelp(`NSEC3PARAM: RDATA too short: ${rd}`)
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('NSEC3PARAM fromTinydns, invalid n')
+    if (rdata.length < 4) {
+      this.throwHelp(`NSEC3PARAM: RDATA too short: ${rdata}`)
     }
 
     // rd may contain actual binary characters (from JS string '\\001' -> char 0x01),
-    // so convert via octalToChar and read bytes from a Buffer for robust parsing.
-    const bytes = Buffer.from(TINYDNS.octalToChar(rd), 'binary')
+    // so convert via octalToChar and read bytes from a Uint8Array for robust parsing.
+    const bytes = TINYDNS.octalRdataToBytes(rdata)
 
     return new NSEC3PARAM({
-      owner: this.fullyQualify(owner),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'NSEC3PARAM',
-      'hash algorithm': bytes.readUInt8(0),
-      flags: bytes.readUInt8(1),
-      iterations: bytes.readUInt16BE(2),
-      salt: bytes.slice(4).toString('utf8'),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      'hash algorithm': bytes[0],
+      flags: bytes[1],
+      iterations: (bytes[2] << 8) | bytes[3],
+      salt: bytes[4] === 0 ? '-' : BINARY.bytesToHex(bytes.subarray(5, 5 + bytes[4])),
+      timestamp,
+      location,
     })
   }
 
-  /******  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')}
-`
+  fromWire({ owner, cls, ttl, rdata }) {
+    const dv = new DataView(rdata.buffer, rdata.byteOffset)
+    const saltLen = rdata[4]
+    const salt = saltLen === 0 ? '-' : BINARY.bytesToHex(rdata.subarray(5, 5 + saltLen))
+    return new NSEC3PARAM({
+      owner,
+      ttl,
+      class: cls,
+      type: 'NSEC3PARAM',
+      'hash algorithm': rdata[0],
+      flags: rdata[1],
+      iterations: dv.getUint16(2),
+      salt,
+    })
   }
 
+  /******  EXPORTERS   *******/
+
   toTinydns() {
-    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+    const salt = this.get('salt')
+    const saltOctal =
+      salt === '-' ? TINYDNS.UInt8toOctal(0) : TINYDNS.UInt8toOctal(salt.length / 2) + TINYDNS.packHex(salt)
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('hash algorithm')) +
         TINYDNS.UInt8toOctal(this.get('flags')) +
         TINYDNS.UInt16toOctal(this.get('iterations')) +
-        TINYDNS.escapeOctal(dataRe, this.get('salt')),
+        saltOctal,
     )
   }
+
+  getWireRdata() {
+    const salt = this.get('salt')
+    const saltBytes = salt === '-' ? new Uint8Array(0) : BINARY.hexToBytes(salt)
+    const bytes = new Uint8Array(4 + 1 + saltBytes.length)
+    const dv = new DataView(bytes.buffer, bytes.byteOffset)
+
+    bytes[0] = this.get('hash algorithm')
+    bytes[1] = this.get('flags')
+    dv.setUint16(2, this.get('iterations'))
+    bytes[4] = saltBytes.length
+    bytes.set(saltBytes, 5)
+
+    return bytes
+  }
 }

package/rr/nxt.js

@@ -1,8 +1,15 @@
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
+import { DNS_TYPE_IDS } from '../lib/binary.js'
 
 export default class NXT extends RR {
+  static typeName = 'NXT'
+  static typeId = 30
+  static RFCs = [2065]
+  static rdataFields = ['next domain', 'type bit map']
+  static tags = ['obsolete']
+
   constructor(opts) {
     super(opts)
     if (opts === null) return
@@ -29,22 +36,6 @@ export default class NXT extends RR {
     return 'Next Secure'
   }
 
-  getTags() {
-    return ['deprecated']
-  }
-
-  getRdataFields(arg) {
-    return ['next domain', 'type bit map']
-  }
-
-  getRFCs() {
-    return [2065]
-  }
-
-  getTypeId() {
-    return 30
-  }
-
   getCanonical() {
     return {
       owner: 'big.example.com.',
@@ -62,7 +53,7 @@ export default class NXT extends RR {
     const [owner, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (parseInt(n, 10) !== this.getTypeId()) this.throwHelp('NXT fromTinydns, invalid n')
 
-    const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const binaryRdata = Uint8Array.from(TINYDNS.octalToChar(rdata), (c) => c.charCodeAt(0))
     const [nextDomain, _escapedLen, binaryLen] = TINYDNS.unpackDomainName(rdata)
 
     return new NXT({
@@ -70,7 +61,7 @@ export default class NXT extends RR {
       ttl: parseInt(ttl, 10),
       type: 'NXT',
       'next domain': nextDomain,
-      'type bit map': binaryRdata.slice(binaryLen).toString(),
+      'type bit map': new TextDecoder().decode(binaryRdata.subarray(binaryLen)),
       timestamp: ts,
       location: loc?.trim() ?? '',
     })
@@ -89,6 +80,19 @@ export default class NXT extends RR {
     })
   }
 
+  fromWire({ owner, cls, ttl, rdata }) {
+    const { fqdn: nextDomain, end } = this.wireUnpackDomain(rdata, 0)
+    const typeBitMap = nxtBitmapToTypes(rdata.subarray(end))
+    return new NXT({
+      owner,
+      ttl,
+      class: cls,
+      type: 'NXT',
+      'next domain': nextDomain,
+      'type bit map': typeBitMap,
+    })
+  }
+
   /******  EXPORTERS   *******/
 
   toTinydns() {
@@ -98,6 +102,41 @@ export default class NXT extends RR {
       TINYDNS.packDomainName(this.get('next domain')) + TINYDNS.escapeOctal(dataRe, this.get('type bit map')),
     )
   }
+
+  getWireRdata() {
+    const nameBytes = this.wirePackDomain(this.get('next domain'))
+    const bitmapBytes = typesToNxtBitmap(this.get('type bit map'))
+    const result = new Uint8Array(nameBytes.length + bitmapBytes.length)
+    result.set(nameBytes)
+    result.set(bitmapBytes, nameBytes.length)
+    return result
+  }
 }
 
 const removeParens = (a) => !['(', ')'].includes(a)
+
+function nxtBitmapToTypes(bitmap) {
+  const DNS_TYPE_NAMES = Object.fromEntries(Object.entries(DNS_TYPE_IDS).map(([k, v]) => [v, k]))
+  const types = []
+  for (let i = 0; i < bitmap.length; i++) {
+    const byte = bitmap[i]
+    for (let bit = 0; bit < 8; bit++) {
+      if (byte & (0x80 >> bit)) {
+        const typeId = i * 8 + bit
+        types.push(DNS_TYPE_NAMES[typeId] ?? `TYPE${typeId}`)
+      }
+    }
+  }
+  return types.join(' ')
+}
+
+function typesToNxtBitmap(typeNamesStr) {
+  const bitmap = new Uint8Array(16)
+  for (const name of typeNamesStr.trim().split(/\s+/)) {
+    const id = /^TYPE\d+$/i.test(name) ? parseInt(name.slice(4), 10) : DNS_TYPE_IDS[name.toUpperCase()]
+    if (id !== undefined && id < 128) bitmap[Math.floor(id / 8)] |= 0x80 >> (id % 8)
+  }
+  let len = bitmap.length
+  while (len > 0 && bitmap[len - 1] === 0) len--
+  return bitmap.slice(0, len)
+}

package/rr/openpgpkey.js

@@ -1,13 +1,21 @@
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
+import * as BINARY from '../lib/binary.js'
 
 export default class OPENPGPKEY extends RR {
+  static typeName = 'OPENPGPKEY'
+  static typeId = 61
+  static RFCs = [4880, 7929]
+  static rdataFields = [['public key', 'base64']]
+  static tags = ['security']
+
   constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
   setPublicKey(val) {
+    this.isBase64('OPENPGPKEY', 'public key', val)
     this.set('public key', val)
   }
 
@@ -15,29 +23,14 @@ export default class OPENPGPKEY extends RR {
     return 'OpenPGP Public Key'
   }
 
-  getTags() {
-    return ['security']
-  }
-
-  getRdataFields() {
-    return ['public key']
-  }
-
-  getRFCs() {
-    return [4880, 7929]
-  }
-
-  getTypeId() {
-    return 61
-  }
-
   getCanonical() {
     return {
       owner: 'matt.example.com.',
       ttl: 3600,
       class: 'IN',
       type: 'OPENPGPKEY',
-      'public key': 'mQINBFY...',
+      'public key':
+        'AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwIXAqcOTiW7iHnQt5hwVAAAAA==',
     }
   }
 
@@ -50,35 +43,36 @@ export default class OPENPGPKEY extends RR {
     if (!match) this.throwHelp(`unable to parse OPENPGPKEY: ${bindline}`)
 
     const { owner, ttl, class: c, type, publickey } = match.groups
+    const keyStr = publickey.trim().replace(/\s+/g, '')
 
     return new OPENPGPKEY({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
-      'public key': publickey.trim(),
+      'public key': keyStr,
     })
   }
 
   fromTinydns({ tinyline }) {
-    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
+    const { owner, typeId, rdata, ttl, timestamp, location } = this.parseTinydnsLine(tinyline)
+    if (typeId != this.getTypeId()) this.throwHelp('OPENPGPKEY fromTinydns, invalid n')
     return new OPENPGPKEY({
-      owner: this.fullyQualify(owner),
-      ttl: parseInt(ttl, 10),
+      owner,
+      ttl,
       type: 'OPENPGPKEY',
-      'public key': Buffer.from(TINYDNS.unescapeOctal(rd), 'base64').toString('utf-8'),
-      timestamp: ts,
-      location: loc?.trim() ?? '',
+      'public key': TINYDNS.octalToBase64(rdata),
+      timestamp,
+      location,
     })
   }
 
   /******  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)
+    return this.getTinydnsGeneric(TINYDNS.base64toOctal(this.get('public key')))
+  }
+
+  getWireRdata() {
+    return BINARY.base64ToBytes(this.get('public key'))
   }
 }