@nictool/dns-resource-record 1.1.3

package/rr/nsec3param.js

@@ -0,0 +1,84 @@
+
+import RR from '../rr.js'
+
+export default class NSEC3PARAM extends RR {
+  constructor (opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+  setHashAlgoritm (val) {
+    // Hash Algorithm is a single octet.
+    // The Hash Algorithm field is represented as an unsigned decimal integer.
+    if (!val) throw new Error(`NSEC3PARAM: 'hash algorithm' is required, ${this.citeRFC()}`)
+
+    this.is8bitInt('NSEC3PARAM', 'hash algorithm', val)
+
+    this.set('hash algorithm', val)
+  }
+
+  setFlags (val) {
+    // The Flags field is represented as an unsigned decimal integer.
+    if (!val) throw new Error(`NSEC3PARAM: 'flags' is required, ${this.citeRFC()}`)
+
+    this.is8bitInt('NSEC3PARAM', 'flags', val)
+
+    this.set('flags', val)
+  }
+
+  setIterations (val) {
+    // The Iterations field is represented as an unsigned decimal integer. 0-65535
+    if (!val) throw new Error(`NSEC3PARAM: 'iterations' is required, ${this.citeRFC()}`)
+
+    this.is16bitInt('NSEC3PARAM', 'iterations', val)
+
+    this.set('iterations', val)
+  }
+
+  setSalt (val) {
+    // The Salt field is represented as a sequence of case-insensitive
+    // 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
+    this.set('salt', val)
+  }
+
+  getDescription () {
+    return 'Next Secure Parameters'
+  }
+
+  getRdataFields (arg) {
+    return [ 'hash algorithm', 'flags', 'iterations', 'salt' ]
+  }
+
+  getRFCs () {
+    return [ 5155 ]
+  }
+
+  getTypeId () {
+    return 51
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (str) {
+    // test.example.com  3600  IN  NSEC3PARAM
+    const [ owner, ttl, c, type ] = str.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'         : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+
+}

package/rr/openpgpkey.js

@@ -0,0 +1,44 @@
+
+import RR from '../rr.js'
+
+export default class OPENPGPKEY extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPublicKey (val) {
+    this.set('public key', val)
+  }
+
+  getDescription () {
+    return 'OpenPGP Public Key'
+  }
+
+  getRdataFields () {
+    return [ 'public key' ]
+  }
+
+  getRFCs () {
+    return [ 4880, 7929 ]
+  }
+
+  getTypeId () {
+    return 61
+  }
+
+  /******  IMPORTERS   *******/
+  fromBind (str) {
+    // test.example.com  3600  IN  OPENPGPKEY  <base64 public key>
+    const [ owner, ttl, c, type, privatekey ] = str.split(/\s+/)
+    return new OPENPGPKEY({
+      owner,
+      ttl          : parseInt(ttl, 10),
+      class        : c,
+      type         : type,
+      'private key': privatekey,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}

package/rr/ptr.js

@@ -0,0 +1,65 @@
+
+import RR from '../rr.js'
+
+export default class PTR extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setDname (val) {
+    this.isFullyQualified('PTR', 'dname', val)
+    this.isValidHostname('PTR', 'dname', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('dname', val.toLowerCase())
+  }
+
+  getDescription () {
+    return 'Pointer'
+  }
+
+  getRdataFields (arg) {
+    return [ 'dname' ]
+  }
+
+  getRFCs () {
+    return [ 1035 ]
+  }
+
+  getTypeId () {
+    return 12
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // ^fqdn:p:ttl:timestamp:lo
+    const [ fqdn, p, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+
+    return new PTR({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'PTR',
+      dname    : this.fullyQualify(p),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  PTR  dname
+    const [ owner, ttl, c, type, dname ] = opts.bindline.split(/\s+/)
+    return new PTR({
+      owner,
+      ttl  : parseInt(ttl, 10),
+      class: c,
+      type : type,
+      dname: dname,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+    return `^${this.getTinyFQDN('owner')}:${this.getTinyFQDN('dname')}:${this.getTinydnsPostamble()}\n`
+  }
+}

package/rr/rrsig.js

@@ -0,0 +1,101 @@
+
+import RR from '../rr.js'
+
+export default class RRSIG extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setTypeCovered (val) {
+    // a 2 octet Type Covered field
+    if (!val) throw new Error(`RRSIG: 'type covered' is required`)
+    if (val.length > 2) throw new Error(`RRSIG: 'type covered' is too long, ${this.citeRFC()}`)
+
+    this.set('type covered', val)
+  }
+
+  setAlgorithm (val) {
+    // a 1 octet Algorithm field
+    // 1=RSA/MD5, 2=DH, 3=RRSIGA/SHA-1, 4=EC, 5=RSA/SHA-1
+    if (![ 1,2,3,4,5,253,254 ].includes(val))
+      throw new Error(`RRSIG: algorithm invalid, ${this.citeRFC()}`)
+
+    this.set('algorithm', val)
+  }
+
+  setLabels (val) {
+    // a 1 octet Labels field
+    this.is8bitInt('RRSIG', 'labels', val)
+
+    this.set('labels', val)
+  }
+
+  setOriginalTtl (val) {
+    // a 4 octet Original TTL field
+    this.is32bitInt('RRSIG', 'original ttl', val)
+
+    this.set('original ttl', val)
+  }
+
+  setSignatureExpiration (val) {
+    // a 4 octet Signature Expiration field
+    this.set('signature expiration', val)
+  }
+
+  setSignatureInception (val) {
+    // a 4 octet Signature Inception field
+    this.set('signature inception', val)
+  }
+
+  setKeyTag (val) {
+    // a 2 octet Key tag
+    this.set('key tag', val)
+  }
+
+  setSignersName (val) {
+    // the Signer's Name field
+    this.set('signers name', val)
+  }
+
+  setSignature (val) {
+    // the Signature field.
+
+    this.set('signature', val)
+  }
+
+  getDescription () {
+    return 'Resource Record Signature'
+  }
+
+  getRdataFields (arg) {
+    return [
+      'type covered', 'algorithm', 'labels', 'original ttl', 'signature expiration',
+      'signature inception', 'key tag', 'signers name', 'signature',
+    ]
+  }
+
+  getRFCs () {
+    return [ 4034 ]
+  }
+
+  getTypeId () {
+    return 46
+  }
+
+  /******  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,
+  //   })
+  // }
+
+  /******  EXPORTERS   *******/
+
+}

package/rr/sig.js

@@ -0,0 +1,100 @@
+
+import RR from '../rr.js'
+
+export default class SIG extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setTypeCovered (val) {
+    // a 2 octet Type Covered field
+    if (!val) throw new Error(`SIG: 'type covered' is required`)
+
+    this.set('type covered', val)
+  }
+
+  setAlgorithm (val) {
+    // a 1 octet Algorithm field
+
+    this.is8bitInt('SIG', 'labels', val)
+
+    this.set('algorithm', val)
+  }
+
+  setLabels (val) {
+    // a 1 octet Labels field
+    this.is8bitInt('SIG', 'labels', val)
+
+    this.set('labels', val)
+  }
+
+  setOriginalTtl (val) {
+    // a 4 octet Original TTL field
+    this.is32bitInt('SIG', 'original ttl', val)
+
+    this.set('original ttl', val)
+  }
+
+  setSignatureExpiration (val) {
+    // a 4 octet Signature Expiration field
+    this.set('signature expiration', val)
+  }
+
+  setSignatureInception (val) {
+    // a 4 octet Signature Inception field
+    this.set('signature inception', val)
+  }
+
+  setKeyTag (val) {
+    // a 2 octet Key tag
+    this.set('key tag', val)
+  }
+
+  setSignersName (val) {
+    // the domain name of the signer generating the SIG RR
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('signers name', val.toLowerCase())
+  }
+
+  setSignature (val) {
+    // the Signature field.
+
+    this.set('signature', val)
+  }
+
+  getDescription () {
+    return 'Signature'
+  }
+
+  getRdataFields (arg) {
+    return [
+      'type covered', 'algorithm', 'labels', 'original ttl', 'signature expiration',
+      'signature inception', 'key tag', 'signers name', 'signature',
+    ]
+  }
+
+  getRFCs () {
+    return [ 2535 ]
+  }
+
+  getTypeId () {
+    return 24
+  }
+
+  /******  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,
+  //   })
+  // }
+
+  /******  EXPORTERS   *******/
+
+}

package/rr/smimea.js

@@ -0,0 +1,73 @@
+
+import RR from '../rr.js'
+
+export default class SMIMEA extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setCertificateUsage (val) {
+    if (![ 0,1,2,3 ].includes(val))
+      throw new Error(`SMIMEA: certificate usage invalid, ${this.citeRFC()}`)
+
+    this.set('certificate usage', val)
+  }
+
+  setSelector (val) {
+    if (![ 0,1 ].includes(val))
+      throw new Error(`SMIMEA: selector invalid, ${this.citeRFC()}`)
+
+    this.set('selector', val)
+  }
+
+  setMatchingType (val) {
+    if (![ 0,1,2 ].includes(val))
+      throw new Error(`SMIMEA: matching type, ${this.citeRFC()}`)
+
+    this.set('matching type', val)
+  }
+
+  setCertificateAssociationData (val) {
+    this.set('certificate association data', val)
+  }
+
+
+  getDescription () {
+    return 'S/MIME cert association'
+  }
+
+  getRdataFields (arg) {
+    return [ 'certificate usage', 'selector', 'matching type', 'certificate association data' ]
+  }
+
+  getRFCs () {
+    return [ 8162 ]
+  }
+
+  getTypeId () {
+    return 53
+  }
+
+  getQuotedFields () {
+    return [  ]
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind (opts) {
+    // test.example.com  3600  IN  SMIMEA, usage, selector, match, data
+    const [ owner, ttl, c, type, usage, selector, match ] = opts.bindline.split(/\s+/)
+    return new SMIMEA({
+      owner,
+      ttl                           : parseInt(ttl, 10),
+      class                         : c,
+      type                          : type,
+      'certificate usage'           : parseInt(usage,    10),
+      selector                      : parseInt(selector, 10),
+      'matching type'               : parseInt(match   , 10),
+      'certificate association data': opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+    })
+  }
+
+}

package/rr/soa.js

@@ -0,0 +1,140 @@
+
+import RR from '../rr.js'
+
+export default class SOA extends RR {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setMinimum (val) {
+    // minimum (used for negative caching, since RFC 2308)
+    // RFC 1912 sugggests 1-5 days
+    // RIPE recommends 3600 (1 hour)
+    this.is32bitInt('SOA', 'minimum', val)
+
+    this.set('minimum', val)
+  }
+
+  setMname (val) {
+    // MNAME (primary NS)
+    this.isValidHostname('SOA', 'MNAME', val)
+    this.isFullyQualified('SOA', 'MNAME', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('mname', val.toLowerCase())
+  }
+
+  setRname (val) {
+    // RNAME (email of admin)  (escape . with \)
+    this.isValidHostname('SOA', 'RNAME', val)
+    this.isFullyQualified('SOA', 'RNAME', val)
+    if (/@/.test(val)) throw new Error(`SOA rname replaces @ with a . (dot), ${this.citeRFC()}`)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('rname', val.toLowerCase())
+  }
+
+  setSerial (val) {
+    this.is32bitInt('SOA', 'serial', val)
+
+    this.set('serial', val)
+  }
+
+  setRefresh (val) {
+    // refresh (seconds after which to check with master for update)
+    // RFC 1912 suggests 20 min to 12 hours
+    // RIPE recommends 86400 (24 hours)
+    this.is32bitInt('SOA', 'refresh', val)
+
+    this.set('refresh', val)
+  }
+
+  setRetry (val) {
+    // seconds after which to retry serial # update
+    // RIPE recommends 7200 seconds (2 hours)
+
+    this.is32bitInt('SOA', 'retry', val)
+
+    this.set('retry', val)
+  }
+
+  setExpire (val) {
+    // seconds after which secondary should drop zone if no master response
+    // RFC 1912 suggests 2-4 weeks
+    // RIPE suggests 3600000 (1,000 hours, 6 weeks)
+    this.is32bitInt('SOA', 'expire', val)
+
+    this.set('expire', val)
+  }
+
+  getDescription () {
+    return 'Start Of Authority'
+  }
+
+  getRdataFields (arg) {
+    return [ 'mname', 'rname', 'serial', 'refresh', 'retry', 'expire', 'minimum' ]
+  }
+
+  getRFCs () {
+    return [ 1035, 2308 ]
+  }
+
+  getTypeId () {
+    return 6
+  }
+
+  /******  IMPORTERS   *******/
+  fromBind (opts) {
+    // example.com TTL IN  SOA mname rname serial refresh retry expire minimum
+    const [ owner, ttl, c, type, mname, rname, serial, refresh, retry, expire, minimum ] = opts.bindline.split(/[\s+]/)
+
+    return new SOA({
+      owner,
+      ttl    : parseInt(ttl) || parseInt(minimum),
+      class  : c,
+      type,
+      mname,
+      rname,
+      serial : parseInt(serial , 10),
+      refresh: parseInt(refresh, 10),
+      retry  : parseInt(retry  , 10),
+      expire : parseInt(expire , 10),
+      minimum: parseInt(minimum, 10),
+    })
+  }
+
+  fromTinydns (opts) {
+    // Zfqdn:mname:rname:ser:ref:ret:exp:min:ttl:time:lo
+    const [ fqdn, mname, rname, ser, ref, ret, exp, min, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+
+    return new SOA({
+      owner    : this.fullyQualify(fqdn),
+      ttl      : parseInt(ttl, 10),
+      type     : 'SOA',
+      mname    : this.fullyQualify(mname),
+      rname    : this.fullyQualify(rname),
+      serial   : parseInt(ser || opts.default?.serial, 10),
+      refresh  : parseInt(ref, 10) || 16384,
+      retry    : parseInt(ret, 10) || 2048,
+      expire   : parseInt(exp, 10) || 1048576,
+      minimum  : parseInt(min, 10) || 2560,
+      timestamp: parseInt(ts) || '',
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toBind (zone_opts) {
+    const numFields = [ 'serial', 'refresh', 'retry', 'expire', 'minimum' ]
+    return `${this.getFQDN('owner', zone_opts)}\t${this.get('ttl')}\t${this.get('class')}\tSOA\t${this.getFQDN('mname', zone_opts)}\t${this.getFQDN('rname', zone_opts)}${numFields.map(f => '\t' + this.get(f) ).join('')}\n`
+  }
+
+  toMaraDNS () {
+    return `${this.get('owner')}\t SOA\t${this.getRdataFields().map(f => this.getQuoted(f)).join('\t')} ~\n`
+  }
+
+  toTinydns () {
+    return `Z${this.getTinyFQDN('owner')}:${this.getTinyFQDN('mname')}:${this.getTinyFQDN('rname')}:${this.getEmpty('serial')}:${this.getEmpty('refresh')}:${this.getEmpty('retry')}:${this.getEmpty('expire')}:${this.getEmpty('minimum')}:${this.getTinydnsPostamble()}\n`
+  }
+}

package/rr/spf.js

@@ -0,0 +1,54 @@
+// obsoleted by RFC 7208
+
+import TXT from './txt.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class SPF extends TXT {
+  constructor (opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setData (val) {
+    this.set('data', val)
+  }
+
+  getDescription () {
+    return 'Sender Policy Framework'
+  }
+
+  getRdataFields (arg) {
+    return [ 'data' ]
+  }
+
+  getRFCs () {
+    return [ 4408, 7208 ]
+  }
+
+  getTypeId () {
+    return 99
+  }
+
+  /******  IMPORTERS   *******/
+  fromTinydns (opts) {
+    // SPF via generic, :fqdn:n:rdata:ttl:timestamp:lo
+    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    if (n != 99) throw new Error('SPF fromTinydns, invalid n')
+
+    return new SPF({
+      type     : 'SPF',
+      owner    : this.fullyQualify(fqdn),
+      data     : TINYDNS.octalToChar(rdata),
+      ttl      : parseInt(ttl, 10),
+      timestamp: ts,
+      location : loc !== '' && loc !== '\n' ? loc : '',
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toTinydns () {
+    const rdata = TINYDNS.escapeOctal(new RegExp(/[\r\n\t:\\/]/, 'g'), this.get('data'))
+    return this.getTinydnsGeneric(rdata)
+  }
+}