@nictool/dns-resource-record 1.4.0 → 1.5.0

package/rr/hinfo.js

@@ -39,26 +39,29 @@ export default class HINFO extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const regex = /^([\S]+)\s+([0-9]{1,10})\s+(IN)\s+(HINFO)\s+("[^"]+"|[\S]+)\s+("[^"]+"|[\S]+)/i
-    const match = opts.bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse HINFO: ${opts.bindline}`)
-    const [owner, ttl, c, type, cpu, os] = match.slice(1)
+    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,
-      os,
+      cpu: qCPU ?? uCPU,
+      os: qOS ?? uOS,
     })
   }
 
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // HINFO via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, , rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, , rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     const [cpu, os] = [...TINYDNS.unpackString(rdata)]
 
     return new this.constructor({
@@ -68,7 +71,7 @@ export default class HINFO extends RR {
       cpu,
       os,
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/hip.js

@@ -59,9 +59,50 @@ export default class HIP extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // HIP via generic, :fqdn:55:rdata:ttl:timestamp:lo
+    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 hit = bytes
+      .slice(4, 4 + hitLen)
+      .toString('hex')
+      .toUpperCase()
+    const publicKey = bytes.slice(4 + hitLen, 4 + hitLen + pkLen).toString('base64')
+
+    const rvsNames = []
+    let pos = 4 + hitLen + pkLen
+    while (pos < bytes.length) {
+      const [name, newPos] = TINYDNS.unpackDomainName(
+        [...bytes.slice(pos)]
+          .map((b) => (b < 32 || b > 126 ? TINYDNS.UInt8toOctal(b) : String.fromCharCode(b)))
+          .join(''),
+      )
+      pos += newPos
+      if (name !== '.') rvsNames.push(name)
+    }
+
+    return new HIP({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'HIP',
+      'pk algorithm': pkAlgorithm,
+      hit,
+      'public key': publicKey,
+      'rendezvous servers': rvsNames.join(' '),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // owner  ttl  IN  HIP  pk-algorithm HIT public-key [rendezvous-server...]
-    const parts = opts.bindline.split(/\s+/)
+    const parts = bindline.split(/\s+/)
     const [owner, ttl, c, type, pkAlgorithm, hit, publicKey] = parts
     return new HIP({
       owner,

package/rr/https.js

@@ -46,9 +46,9 @@ export default class HTTPS extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  HTTPS Priority TargetName Params
-    const [owner, ttl, c, type, pri, fqdn] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pri, fqdn] = bindline.split(/\s+/)
     return new HTTPS({
       owner,
       ttl: parseInt(ttl, 10),
@@ -56,20 +56,31 @@ export default class HTTPS extends RR {
       type,
       priority: parseInt(pri, 10),
       'target name': fqdn,
-      params: opts.bindline.split(/\s+/).slice(6).join(' ').trim(),
+      params: bindline.split(/\s+/).slice(6).join(' ').trim(),
     })
   }
 
-  fromTinydns({ rd, owner, ttl }) {
+  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 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))
+    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()
 
     return new HTTPS({
       owner: this.fullyQualify(owner),
@@ -78,6 +89,8 @@ export default class HTTPS extends RR {
       priority,
       'target name': targetName,
       params,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/ipseckey.js

@@ -98,9 +98,9 @@ export default class IPSECKEY extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // FQDN TTL CLASS IPSECKEY Precedence GatewayType Algorithm Gateway PublicKey
-    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] = bindline.split(/\s+/)
     return new IPSECKEY({
       owner,
       ttl: parseInt(ttl, 10),
@@ -114,32 +114,32 @@ export default class IPSECKEY extends RR {
     })
   }
 
-  fromTinydns(opts) {
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 45) this.throwHelp('IPSECKEY fromTinydns, invalid n')
 
-    const precedence = TINYDNS.octalToUInt8(rdata.substring(0, 4))
-    const gwType = TINYDNS.octalToUInt8(rdata.substring(4, 8))
-    const algorithm = TINYDNS.octalToUInt8(rdata.substring(8, 12))
+    const precedence = TINYDNS.octalToUInt8(rdata.slice(0, 4))
+    const gwType = TINYDNS.octalToUInt8(rdata.slice(4, 8))
+    const algorithm = TINYDNS.octalToUInt8(rdata.slice(8, 12))
 
     let len, gateway, octalKey
 
     switch (gwType) {
       case 0: // no gateway
-        gateway = rdata.substring(12, 13) // should always be: '.'
-        octalKey = rdata.substring(13)
+        gateway = rdata.slice(12, 13) // should always be: '.'
+        octalKey = rdata.slice(13)
         break
       case 1: // 4-byte IPv4 address
-        gateway = TINYDNS.octalToIPv4(rdata.substring(12, 28))
-        octalKey = rdata.substring(28)
+        gateway = TINYDNS.octalToIPv4(rdata.slice(12, 28))
+        octalKey = rdata.slice(28)
         break
       case 2: // 16-byte IPv6
-        gateway = TINYDNS.octalToHex(rdata.substring(12, 76))
-        octalKey = rdata.substring(76)
+        gateway = TINYDNS.octalToHex(rdata.slice(12, 76))
+        octalKey = rdata.slice(76)
         break
       case 3: // wire encoded domain name
-        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.substring(12))
-        octalKey = rdata.substring(12 + len)
+        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.slice(12))
+        octalKey = rdata.slice(12 + len)
         break
     }
 
@@ -153,7 +153,7 @@ export default class IPSECKEY extends RR {
       gateway,
       publickey: TINYDNS.octalToBase64(octalKey),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/key.js

@@ -65,9 +65,9 @@ export default class KEY extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  KEY Flags Protocol Algorithm PublicKey
-    const [owner, ttl, c, type, flags, protocol, algorithm] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, flags, protocol, algorithm] = bindline.split(/\s+/)
     return new KEY({
       owner,
       ttl: parseInt(ttl, 10),
@@ -76,31 +76,27 @@ export default class KEY extends RR {
       flags: parseInt(flags, 10),
       protocol: parseInt(protocol, 10),
       algorithm: parseInt(algorithm, 10),
-      publickey: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+      publickey: bindline.split(/\s+/).slice(7).join(' ').trim(),
     })
   }
 
-  fromTinydns(opts) {
-    const rd = opts.rd
-
+  fromTinydns({ tinyline }) {
     // RDATA format: Flags (6 octal chars) + Protocol (3 octal chars) + Algorithm (3 octal chars) + Public Key (escaped data)
+    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
     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),
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
       type: 'KEY',
-      flags: flags,
-      protocol: protocol,
-      algorithm: algorithm,
-      publickey: publicKeyData,
+      flags: TINYDNS.octalToUInt16(rd.slice(0, 6)),
+      protocol: TINYDNS.octalToUInt8(rd.slice(6, 9)),
+      algorithm: TINYDNS.octalToUInt8(rd.slice(9, 12)),
+      publickey: TINYDNS.unescapeOctal(rd.slice(12)),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/kx.js

@@ -51,9 +51,25 @@ export default class KX extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // KX via generic, :fqdn:36:rdata:ttl:timestamp:lo
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (n != 36) this.throwHelp('KX fromTinydns, invalid n')
+
+    return new KX({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'KX',
+      preference: TINYDNS.octalToUInt16(rdata.slice(0, 8)),
+      exchanger: TINYDNS.unpackDomainName(rdata.slice(8))[0],
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  KX  preference exchanger
-    const [owner, ttl, c, type, preference, exchanger] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchanger] = bindline.split(/\s+/)
     return new KX({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/loc.js

@@ -85,22 +85,22 @@ export default class LOC extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // LOC via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 29) this.throwHelp('LOC fromTinydns, invalid n')
 
     // divide by 100 is to convert cm to meters
     const l = {
-      version: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
+      version: TINYDNS.octalToUInt8(rdata.slice(0, 4)),
+      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(4, 8))),
       precision: {
-        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(8, 12))),
-        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(12, 16))),
+        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(8, 12))),
+        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(12, 16))),
       },
-      latitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(16, 32)), 'lat'),
-      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(32, 48)), 'lon'),
-      altitude: TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
+      latitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.slice(16, 32)), 'lat'),
+      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.slice(32, 48)), 'lon'),
+      altitude: TINYDNS.octalToUInt32(rdata.slice(48, 64)) - REF.ALTITUDE,
     }
 
     return new LOC({
@@ -109,24 +109,24 @@ export default class LOC extends RR {
       address: this.toHuman(l),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
-    const [owner, ttl, c, type] = opts.bindline.split(/\s+/)
+  fromBind({ bindline }) {
+    const [owner, ttl, c, type] = bindline.split(/\s+/)
 
     return new LOC({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
-      address: opts.bindline.split(/\s+/).slice(4).join(' ').trim(),
+      address: bindline.split(/\s+/).slice(4).join(' ').trim(),
     })
   }
 
   dmsToArcSec(obj) {
-    let retval = obj.degrees * CONV.deg + (obj.minutes || 0) * CONV.min + (obj.seconds || 0) * CONV.sec
+    let retval = obj.degrees * CONV.deg + (obj.minutes ?? 0) * CONV.min + (obj.seconds ?? 0) * CONV.sec
     switch (obj.hemisphere.toUpperCase()) {
       case 'W':
       case 'S':

package/rr/mx.js

@@ -53,10 +53,10 @@ export default class MX extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // @fqdn:ip:x:dist:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [owner, ip, x, preference, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [owner, ip, x, preference, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new MX({
       type: 'MX',
@@ -65,13 +65,13 @@ export default class MX extends RR {
       preference: parseInt(preference, 10) || 0,
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  MX  preference exchange
-    const [owner, ttl, c, type, preference, exchange] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchange] = bindline.split(/\s+/)
 
     return new MX({
       owner,

package/rr/naptr.js

@@ -62,9 +62,9 @@ export default class NAPTR extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // NAPTR via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 35) this.throwHelp('NAPTR fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -74,7 +74,7 @@ export default class NAPTR extends RR {
       owner: this.fullyQualify(fqdn),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
       order: binRdata.readUInt16BE(0, 2),
       preference: binRdata.readUInt16BE(2, 4),
     }
@@ -102,26 +102,30 @@ export default class NAPTR extends RR {
     return new NAPTR(rec)
   }
 
-  fromBind(opts) {
-    const str = opts.bindline
-    // test.example.com  3600  IN  NAPTR order, preference, "flags", "service", "regexp", replacement
-    const [owner, ttl, c, type, order, preference] = str.split(/\s+/)
-    const [flags, service, regexp] = str.match(/(?:").*?(?:"\s)/g)
-    const replacement = str.trim().split(/\s+/).pop()
+  fromBind({ bindline }) {
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d+)\s+(?<class>\S+)\s+(?<type>NAPTR)\s+(?<order>\d+)\s+(?<preference>\d+)\s+["'](?<flags>[^"']*)["']\s+["'](?<service>[^"']*)["']\s+["'](?<regexp>[^"']*)["']\s+(?<replacement>\S+)$/
 
-    const bits = {
-      owner: owner,
+    const match = bindline.trim().match(regex)
+
+    if (!match) {
+      throw new Error(`Invalid NAPTR BIND line: ${bindline}`)
+    }
+
+    const { owner, ttl, type, order, preference, flags, service, regexp, replacement } = match.groups
+
+    return new NAPTR({
+      owner: this.fullyQualify(owner),
       ttl: parseInt(ttl, 10),
-      class: c,
-      type: type,
+      class: match.groups.class,
+      type,
       order: parseInt(order, 10),
       preference: parseInt(preference, 10),
-      flags: flags.trim().replace(/^['"]|['"]$/g, ''),
-      service: service.trim().replace(/^['"]|['"]$/g, ''),
-      regexp: regexp.trim().replace(/^['"]|['"]/g, ''),
-      replacement: replacement,
-    }
-    return new NAPTR(bits)
+      flags,
+      service,
+      regexp,
+      replacement,
+    })
   }
 
   /******  EXPORTERS   *******/

package/rr/ns.js

@@ -34,10 +34,10 @@ export default class NS extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // &fqdn:ip:x:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [fqdn, ip, dname, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, ip, dname, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new NS({
       type: 'NS',
@@ -45,13 +45,13 @@ export default class NS extends RR {
       dname: this.fullyQualify(/\./.test(dname) ? dname : `${dname}.ns.${fqdn}`),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  NS dname
-    const [owner, ttl, c, type, dname] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, dname] = bindline.split(/\s+/)
 
     return new NS({
       owner,

package/rr/nsec.js

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

package/rr/nsec3.js

@@ -78,10 +78,10 @@ export default class NSEC3 extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com. 3600 IN NSEC3 1 1 12 aabbccdd (2vptu5timamqttgl4luu9kg21e0aor3s A RRSIG)
-    const [owner, ttl, c, type, ha, flags, iterations, salt] = opts.bindline.split(/\s+/)
-    const rdata = opts.bindline.split(/\(|\)/)[1]
+    const [owner, ttl, c, type, ha, flags, iterations, salt] = bindline.split(/\s+/)
+    const rdata = bindline.split(/\(|\)/)[1]
 
     return new NSEC3({
       owner,
@@ -97,8 +97,8 @@ export default class NSEC3 extends RR {
     })
   }
 
-  fromTinydns(opts) {
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    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')
@@ -112,7 +112,7 @@ export default class NSEC3 extends RR {
     // 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)
+    const { salt, nextHashedOwnerName, typeBitMaps } = parseNSEC3Buffer(bytes)
 
     return new NSEC3({
       owner: this.fullyQualify(fqdn),
@@ -125,7 +125,7 @@ export default class NSEC3 extends RR {
       'next hashed owner name': nextHashedOwnerName,
       'type bit maps': typeBitMaps,
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
@@ -155,3 +155,48 @@ export default class NSEC3 extends RR {
     )
   }
 }
+
+function parseNSEC3Buffer(bytes) {
+  // bytes is a Buffer 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')
+
+  // determine expected next hashed owner name length from hash algorithm
+  const hashAlgorithm = bytes.readUInt8(0)
+  // common mapping: algorithm 1 => SHA-1 => 20 bytes => base32 length 32
+  const expectedLen = hashAlgorithm === 1 ? 32 : hashAlgorithm === 2 ? 52 : 32
+
+  // salt length is ambiguous in this representation; try to find a split where
+  // the following segment matches expected base32 length
+  let salt = ''
+  let nextHashedOwnerName = ''
+  let typeBitMaps = ''
+
+  const maxSl = Math.min(64, rest.length)
+  for (let sl = maxSl; sl >= 1; sl--) {
+    const candNext = rest.slice(sl, sl + expectedLen)
+    if (candNext.length !== expectedLen) continue
+    if (!/^[0-9a-z]+$/.test(candNext)) continue
+    // candidate looks like a base32 name; accept and treat remainder as type bit maps
+    const saltCandidate = rest.slice(0, sl)
+    if (!/^[0-9A-Fa-f]+$/.test(saltCandidate)) continue
+    salt = saltCandidate
+    nextHashedOwnerName = candNext
+    typeBitMaps = rest.slice(sl + expectedLen)
+    break
+  }
+
+  // fallback: if we couldn't find a split, treat everything up to first non-hex as salt
+  if (!nextHashedOwnerName) {
+    const saltMatch = rest.match(/^([0-9A-Fa-f]*)/)
+    salt = saltMatch ? saltMatch[1] : ''
+    nextHashedOwnerName = rest.slice(salt.length)
+    typeBitMaps = ''
+  }
+
+  return {
+    salt,
+    nextHashedOwnerName,
+    typeBitMaps,
+  }
+}