@nictool/dns-resource-record 1.3.1 → 1.5.0

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,
@@ -93,41 +93,53 @@ 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('	'),
     })
   }
 
-  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')
 
+    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 } = 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 : '',
+      location: loc?.trim() ?? '',
     })
   }
 
   /******  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() {
@@ -143,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,
+  }
+}

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) {
@@ -10,7 +11,7 @@ export default class NSEC3PARAM extends RR {
   setHashAlgorithm(val) {
     // Hash Algorithm is a single octet.
     // The Hash Algorithm field is represented as an unsigned decimal integer.
-    if (!val) this.throwHelp(`NSEC3PARAM: 'hash algorithm' is required`)
+    if (val === undefined || val === null) this.throwHelp(`NSEC3PARAM: 'hash algorithm' is required`)
 
     this.is8bitInt('NSEC3PARAM', 'hash algorithm', val)
 
@@ -19,7 +20,7 @@ export default class NSEC3PARAM extends RR {
 
   setFlags(val) {
     // The Flags field is represented as an unsigned decimal integer.
-    if (!val) this.throwHelp(`NSEC3PARAM: 'flags' is required`)
+    if (val === undefined || val === null) this.throwHelp(`NSEC3PARAM: 'flags' is required`)
 
     this.is8bitInt('NSEC3PARAM', 'flags', val)
 
@@ -28,7 +29,7 @@ export default class NSEC3PARAM extends RR {
 
   setIterations(val) {
     // The Iterations field is represented as an unsigned decimal integer. 0-65535
-    if (!val) this.throwHelp(`NSEC3PARAM: 'iterations' is required`)
+    if (val === undefined || val === null) this.throwHelp(`NSEC3PARAM: 'iterations' is required`)
 
     this.is16bitInt('NSEC3PARAM', 'iterations', val)
 
@@ -40,6 +41,15 @@ export default class NSEC3PARAM extends RR {
     // hexadecimal digits.  Whitespace is not allowed within the
     // sequence.  The Salt field is represented as "-" (without the
     // quotes) when the Salt Length field has a value of 0
+    if (val === '-') {
+      this.set('salt', val)
+      return
+    }
+
+    if (val !== undefined && val !== null && !/^[0-9A-Fa-f]*$/.test(val)) {
+      this.throwHelp(`NSEC3PARAM: 'salt' must be hex or '-'`)
+    }
+
     this.set('salt', val)
   }
 
@@ -61,22 +71,62 @@ export default class NSEC3PARAM extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(str) {
-    // test.example.com  3600  IN  NSEC3PARAM
-    const [owner, ttl, c, type] = str.split(/\s+/)
+  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': '',
-      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({ 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}`)
+    }
+
+    // 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')
+
+    return new NSEC3PARAM({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      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() ?? '',
     })
   }
 
   /******  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')
+
+    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')),
+    )
+  }
 }

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,20 +43,46 @@ export default class NXT extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    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 [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?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  NXT NextDomain TypeBitMap
-    const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, next] = bindline.split(/\s+/)
     return new NXT({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
       'next domain': next,
-      'type bit map': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
+      'type bit map': bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
     })
   }
 
   /******  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) {
@@ -27,11 +28,14 @@ export default class OPENPGPKEY extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(obj) {
+  fromBind({ bindline: bindline }) {
     // test.example.com  3600  IN  OPENPGPKEY  <base64 public key>
-    const regex = /^([\S]+)\s+(\d{1,10})\s+(IN)\s+(OPENPGPKEY)\s+([\W\w]*)$/
-    // eslint-disable-next-line no-unused-vars
-    const [ignore, owner, ttl, c, type, publickey] = obj.bindline.trim().match(regex)
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<class>IN)\s+(?<type>OPENPGPKEY)\s+(?<publickey>\S[\s\S]*)$/i
+    const match = bindline.trim().match(regex)
+    if (!match) this.throwHelp(`unable to parse OPENPGPKEY: ${bindline}`)
+
+    const { owner, ttl, class: c, type, publickey } = match.groups
 
     return new OPENPGPKEY({
       owner,
@@ -42,5 +46,25 @@ export default class OPENPGPKEY extends RR {
     })
   }
 
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
+    return new OPENPGPKEY({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'OPENPGPKEY',
+      'public key': Buffer.from(TINYDNS.unescapeOctal(rd), 'base64').toString('utf-8'),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
   /******  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/ptr.js

@@ -31,9 +31,9 @@ export default class PTR extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // ^fqdn:p:ttl:timestamp:lo
-    const [fqdn, p, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, p, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new PTR({
       owner: this.fullyQualify(fqdn),
@@ -41,13 +41,13 @@ export default class PTR extends RR {
       type: 'PTR',
       dname: this.fullyQualify(p),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  PTR  dname
-    const [owner, ttl, c, type, dname] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, dname] = bindline.split(/\s+/)
     return new PTR({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/rp.js

@@ -52,9 +52,9 @@ export default class RP extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  RP  mbox txt
-    const [owner, ttl, c, type, mbox, txt] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, mbox, txt] = bindline.split(/\s+/)
     return new RP({
       owner,
       ttl: parseInt(ttl, 10),
@@ -65,6 +65,23 @@ export default class RP extends RR {
     })
   }
 
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+
+    const [mbox, consumed] = TINYDNS.unpackDomainName(rdata)
+    const txt = TINYDNS.unpackDomainName(rdata.slice(consumed))[0]
+
+    return new RP({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'RP',
+      mbox,
+      txt,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
   /******  EXPORTERS   *******/
   toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.getFQDN('mbox', zone_opts)}\t${this.getFQDN('txt', zone_opts)}\n`

package/rr/rrsig.js

@@ -1,4 +1,5 @@
 import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
 
 export default class RRSIG extends RR {
   constructor(opts) {
@@ -101,16 +102,89 @@ export default class RRSIG extends RR {
 
   /******  IMPORTERS   *******/
 
-  // fromBind (str) {
-  //   // test.example.com  3600  IN  RRSIG ...
-  //   const [ owner, ttl, c, type ] = str.split(/\s+/)
-  //   return new RRSIG({
-  //     owner,
-  //     ttl          : parseInt(ttl, 10),
-  //     class        : c,
-  //     type         : type,
-  //   })
-  // }
+  fromBind({ bindline }) {
+    // example.com. 3600 IN RRSIG typecovered algorithm labels origttl sigexp siginc keytag signersname ( signature )
+    const parts = bindline.trim().split(/\s+/)
+    return new RRSIG({
+      owner: parts[0],
+      ttl: parseInt(parts[1], 10),
+      class: parts[2],
+      type: 'RRSIG',
+      'type covered': parseInt(parts[4], 10),
+      algorithm: parseInt(parts[5], 10),
+      labels: parseInt(parts[6], 10),
+      'original ttl': parseInt(parts[7], 10),
+      'signature expiration': parseInt(parts[8], 10),
+      'signature inception': parseInt(parts[9], 10),
+      'key tag': parseInt(parts[10], 10),
+      'signers name': parts[11],
+      signature: parts
+        .slice(12)
+        .filter((a) => a !== '(' && a !== ')')
+        .join(' ')
+        .trim(),
+    })
+  }
+
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (parseInt(n, 10) !== this.getTypeId()) this.throwHelp('RRSIG fromTinydns, invalid n')
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const typeCovered = bytes.readUInt16BE(0)
+    const algorithm = bytes.readUInt8(2)
+    const labels = bytes.readUInt8(3)
+    const originalTtl = bytes.readUInt32BE(4)
+    const signatureExpiration = bytes.readUInt32BE(8)
+    const signatureInception = bytes.readUInt32BE(12)
+    const keyTag = bytes.readUInt16BE(16)
+
+    let pos = 18
+    const labelArr = []
+    while (pos < bytes.length) {
+      const len = bytes.readUInt8(pos++)
+      if (len === 0) break
+      labelArr.push(bytes.slice(pos, pos + len).toString())
+      pos += len
+    }
+    const signersName = `${labelArr.join('.')}.`
+    const signature = bytes.slice(pos).toString()
+
+    return new RRSIG({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'RRSIG',
+      'type covered': typeCovered,
+      algorithm,
+      labels,
+      'original ttl': originalTtl,
+      'signature expiration': signatureExpiration,
+      'signature inception': signatureInception,
+      'key tag': keyTag,
+      'signers name': signersName,
+      signature,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
 
   /******  EXPORTERS   *******/
+  toBind(zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t${this.get('type covered')}\t${this.get('algorithm')}\t${this.get('labels')}\t${this.get('original ttl')}\t${this.get('signature expiration')}\t${this.get('signature inception')}\t${this.get('key tag')}\t${this.getFQDN('signers name', zone_opts)}\t${this.get('signature')}\n`
+  }
+
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:]/, 'g')
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('type covered')) +
+        TINYDNS.UInt8toOctal(this.get('algorithm')) +
+        TINYDNS.UInt8toOctal(this.get('labels')) +
+        TINYDNS.UInt32toOctal(this.get('original ttl')) +
+        TINYDNS.UInt32toOctal(this.get('signature expiration')) +
+        TINYDNS.UInt32toOctal(this.get('signature inception')) +
+        TINYDNS.UInt16toOctal(this.get('key tag')) +
+        TINYDNS.packDomainName(this.get('signers name')) +
+        TINYDNS.escapeOctal(dataRe, this.get('signature')),
+    )
+  }
 }

package/rr/sig.js

@@ -1,5 +1,7 @@
 import RR from '../rr.js'
 
+import * as TINYDNS from '../lib/tinydns.js'
+
 export default class SIG extends RR {
   constructor(opts) {
     super(opts)
@@ -15,8 +17,7 @@ export default class SIG extends RR {
 
   setAlgorithm(val) {
     // a 1 octet Algorithm field
-
-    this.is8bitInt('SIG', 'labels', val)
+    this.is8bitInt('SIG', 'algorithm', val)
 
     this.set('algorithm', val)
   }
@@ -90,16 +91,101 @@ export default class SIG extends RR {
   }
 
   /******  IMPORTERS   *******/
-  // fromBind (str) {
-  //   // test.example.com  3600  IN  SIG ...
-  //   const [ owner, ttl, c, type ] = str.split(/\s+/)
-  //   return new SIG({
-  //     owner,
-  //     ttl          : parseInt(ttl, 10),
-  //     class        : c,
-  //     type         : type,
-  //   })
-  // }
+
+  fromBind({ bindline }) {
+    // example.com. 3600 IN SIG TypeCovered Algorithm Labels OrigTTL SigExpiration SigInception KeyTag SignersName ( Signature )
+    const parts = bindline.trim().split(/\s+/)
+
+    return new SIG({
+      owner: parts[0],
+      ttl: parseInt(parts[1], 10),
+      class: parts[2],
+      type: 'SIG',
+      'type covered': parseInt(parts[4], 10),
+      algorithm: parseInt(parts[5], 10),
+      labels: parseInt(parts[6], 10),
+      'original ttl': parseInt(parts[7], 10),
+      'signature expiration': parseInt(parts[8], 10),
+      'signature inception': parseInt(parts[9], 10),
+      'key tag': parseInt(parts[10], 10),
+      'signers name': parts[11],
+      signature: parts
+        .slice(12)
+        .filter((a) => a !== '(' && a !== ')')
+        .join(' ')
+        .trim(),
+    })
+  }
 
   /******  EXPORTERS   *******/
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('type covered')) +
+        TINYDNS.UInt8toOctal(this.get('algorithm')) +
+        TINYDNS.UInt8toOctal(this.get('labels')) +
+        TINYDNS.UInt32toOctal(this.get('original ttl')) +
+        TINYDNS.UInt32toOctal(this.get('signature expiration')) +
+        TINYDNS.UInt32toOctal(this.get('signature inception')) +
+        TINYDNS.UInt16toOctal(this.get('key tag')) +
+        TINYDNS.packDomainName(this.get('signers name')) +
+        TINYDNS.escapeOctal(dataRe, this.get('signature')),
+    )
+  }
+
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.substring(1).split(':')
+    if (parseInt(n, 10) !== this.getTypeId()) this.throwHelp('SIG fromTinydns, invalid n')
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+
+    const typeCovered = bytes.readUInt16BE(0)
+    const algorithm = bytes.readUInt8(2)
+    const labels = bytes.readUInt8(3)
+    const originalTtl = bytes.readUInt32BE(4)
+    const signatureExpiration = bytes.readUInt32BE(8)
+    const signatureInception = bytes.readUInt32BE(12)
+    const keyTag = bytes.readUInt16BE(16)
+
+    // parse signers name from binary buffer starting at offset 18
+    let pos = 18
+    const labelsArr = []
+    while (pos < bytes.length) {
+      const len = bytes.readUInt8(pos++)
+      if (len === 0) break
+      labelsArr.push(bytes.slice(pos, pos + len).toString())
+      pos += len
+    }
+    const signersName = `${labelsArr.join('.')}.`
+
+    const signature = bytes.slice(pos).toString()
+
+    return new SIG({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'SIG',
+      'type covered': typeCovered,
+      algorithm,
+      labels,
+      'original ttl': originalTtl,
+      'signature expiration': signatureExpiration,
+      'signature inception': signatureInception,
+      'key tag': keyTag,
+      'signers name': signersName,
+      signature,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  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')} )`
+  }
 }