@nictool/dns-resource-record 1.6.1 → 1.7.0

package/index.js

@@ -1,5 +1,3 @@
-const typeMap = {}
-
 import RR from './rr.js'
 import A from './rr/a.js'
 import AAAA from './rr/aaaa.js'
@@ -42,9 +40,8 @@ import TXT from './rr/txt.js'
 import URI from './rr/uri.js'
 import WKS from './rr/wks.js'
 
-export default RR
-
-export {
+const typeMap = {}
+const classes = [
   A,
   AAAA,
   APL,
@@ -85,10 +82,15 @@ export {
   TXT,
   URI,
   WKS,
-  typeMap,
+]
+
+for (const c of classes) {
+  const id = c.getTypeId()
+  typeMap[id] = c.typeName
+  typeMap[c.typeName] = id
 }
 
-for (const c of [
+export {
   A,
   AAAA,
   APL,
@@ -129,8 +131,7 @@ for (const c of [
   TXT,
   URI,
   WKS,
-]) {
-  const id = new c(null).getTypeId()
-  typeMap[id] = c.name
-  typeMap[c.name] = id
+  typeMap,
 }
+
+export default RR

package/lib/binary.js

@@ -0,0 +1,108 @@
+export function hexToBytes(hex) {
+  return Uint8Array.from({ length: hex.length / 2 }, (_, i) => parseInt(hex.slice(i * 2, i * 2 + 2), 16))
+}
+
+export function bytesToHex(bytes) {
+  return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+export function bytesToBase64(bytes) {
+  return btoa([...bytes].map((b) => String.fromCharCode(b)).join(''))
+}
+
+export function base64ToBytes(b64) {
+  return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0))
+}
+
+// DNS type name → numeric type ID mapping (subset covering known RR types)
+export const DNS_TYPE_IDS = {
+  A: 1,
+  NS: 2,
+  MD: 3,
+  MF: 4,
+  CNAME: 5,
+  SOA: 6,
+  MB: 7,
+  MG: 8,
+  MR: 9,
+  NULL: 10,
+  WKS: 11,
+  PTR: 12,
+  HINFO: 13,
+  MINFO: 14,
+  MX: 15,
+  TXT: 16,
+  RP: 17,
+  AFSDB: 18,
+  X25: 19,
+  ISDN: 20,
+  RT: 21,
+  NSAP: 22,
+  NSAP_PTR: 23,
+  SIG: 24,
+  KEY: 25,
+  PX: 26,
+  GPOS: 27,
+  AAAA: 28,
+  LOC: 29,
+  NXT: 30,
+  EID: 31,
+  NIMLOC: 32,
+  SRV: 33,
+  ATMA: 34,
+  NAPTR: 35,
+  KX: 36,
+  CERT: 37,
+  A6: 38,
+  DNAME: 39,
+  SINK: 40,
+  OPT: 41,
+  APL: 42,
+  DS: 43,
+  SSHFP: 44,
+  IPSECKEY: 45,
+  RRSIG: 46,
+  NSEC: 47,
+  DNSKEY: 48,
+  DHCID: 49,
+  NSEC3: 50,
+  NSEC3PARAM: 51,
+  TLSA: 52,
+  SMIMEA: 53,
+  HIP: 55,
+  NINFO: 56,
+  RKEY: 57,
+  TALINK: 58,
+  CDS: 59,
+  CDNSKEY: 60,
+  OPENPGPKEY: 61,
+  CSYNC: 62,
+  ZONEMD: 63,
+  SVCB: 64,
+  HTTPS: 65,
+  SPF: 99,
+  UINFO: 100,
+  UID: 101,
+  GID: 102,
+  UNSPEC: 103,
+  NID: 104,
+  L32: 105,
+  L64: 106,
+  LP: 107,
+  EUI48: 108,
+  EUI64: 109,
+  TKEY: 249,
+  TSIG: 250,
+  IXFR: 251,
+  AXFR: 252,
+  MAILB: 253,
+  MAILA: 254,
+  ANY: 255,
+  URI: 256,
+  CAA: 257,
+  AVC: 258,
+  DOA: 259,
+  AMTRELAY: 260,
+  TA: 32768,
+  DLV: 32769,
+}

package/lib/bind.js

@@ -0,0 +1,94 @@
+export function parseBindLine(line, RRClasses) {
+  const res = {
+    class: 'IN',
+    type: '',
+    rdata: [],
+  }
+
+  // 1. Strip comments (not inside quotes)
+  let cleanLine = ''
+  let inQuote = false
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i]
+    if (c === '"') inQuote = !inQuote
+    if (c === ';' && !inQuote) break
+    cleanLine += c
+  }
+  cleanLine = cleanLine.trim()
+  if (!cleanLine) return null
+
+  // 2. Tokenize, respecting quoted strings
+  const tokens = cleanLine.match(/(".*?"|\S+)/g) || []
+  if (tokens.length < 1) return null
+
+  // 3. Owner handling
+  if (!/^\s/.test(line)) {
+    res.owner = tokens.shift()
+  }
+
+  // 4. Extract TTL, Class, and Type
+  while (tokens.length > 0) {
+    const token = tokens[0].toUpperCase()
+
+    if (RRClasses[token]) {
+      res.class = tokens.shift().toUpperCase()
+      continue
+    }
+
+    if (/^\d+$/.test(token)) {
+      res.ttl = parseInt(tokens.shift(), 10)
+      continue
+    }
+
+    // If it's not a Class or TTL, it must be the RR Type (A, MX, etc.)
+    res.type = tokens.shift().toUpperCase()
+    break
+  }
+
+  // 5. Remaining tokens are RDATA
+  res.rdata = tokens
+
+  return res
+}
+
+export function fromBind(rrInstance, opts) {
+  const { owner, ttl, cls, rdata } = opts
+  const result = {
+    owner,
+    ttl,
+    class: cls,
+    type: rrInstance.constructor.typeName,
+  }
+
+  const fields = rrInstance.getFields('rdata')
+  for (let i = 0; i < fields.length; i++) {
+    const isLastField = i === fields.length - 1
+    if (isLastField && rrInstance.isQuotedField(fields[i])) {
+      // Collect all remaining tokens for TXT/etc
+      const val = rdata
+        .slice(i)
+        .map((s) => s.replace(/^"|"$/g, ''))
+        .join('')
+      result[fields[i]] = val
+      break
+    }
+
+    let val = rdata[i]
+    if (rrInstance.isQuotedField(fields[i])) {
+      val = val?.replace(/^"|"$/g, '')
+    } else if (/^\d+$/.test(val)) {
+      val = parseInt(val, 10)
+    }
+    result[fields[i]] = val
+  }
+
+  return new rrInstance.constructor(result)
+}
+
+export function toBind(rrInstance, zone_opts) {
+  const fields = rrInstance.getFields('rdata')
+  const rdata = fields
+    .map((f) => (rrInstance.isFqdnField(f) ? rrInstance.getFQDN(f, zone_opts) : rrInstance.getQuoted(f)))
+    .join('\t')
+  return `${rrInstance.getPrefix(zone_opts)}\t${rdata}\n`
+}

package/lib/dns-query.js

@@ -0,0 +1,67 @@
+import { createSocket } from 'node:dgram'
+import { createConnection } from 'node:net'
+
+export function dnsQueryUDP(host, port, queryBuf, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const socket = createSocket('udp4')
+    const timer = setTimeout(() => {
+      socket.close()
+      reject(new Error(`DNS query timed out (${host}:${port})`))
+    }, timeout)
+    socket.on('message', (msg) => {
+      clearTimeout(timer)
+      socket.close()
+      resolve(msg)
+    })
+    socket.on('error', (err) => {
+      clearTimeout(timer)
+      socket.close()
+      reject(err)
+    })
+    socket.send(queryBuf, port, host, (err) => {
+      if (err) {
+        clearTimeout(timer)
+        socket.close()
+        reject(err)
+      }
+    })
+  })
+}
+
+export function dnsQueryTCP(host, port, queryBuf, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const conn = createConnection({ host, port })
+    const timer = setTimeout(() => {
+      conn.destroy()
+      reject(new Error(`DNS TCP query timed out (${host}:${port})`))
+    }, timeout)
+    let received = Buffer.alloc(0)
+    conn.on('connect', () => {
+      const len = Buffer.alloc(2)
+      len.writeUInt16BE(queryBuf.length)
+      conn.write(Buffer.concat([len, queryBuf]))
+    })
+    conn.on('data', (chunk) => {
+      received = Buffer.concat([received, chunk])
+      if (received.length >= 2) {
+        const msgLen = received.readUInt16BE(0)
+        if (received.length >= 2 + msgLen) {
+          clearTimeout(timer)
+          conn.destroy()
+          resolve(received.slice(2, 2 + msgLen))
+        }
+      }
+    })
+    conn.on('error', (err) => {
+      clearTimeout(timer)
+      reject(err)
+    })
+  })
+}
+
+export async function dnsQuery(host, port, queryBuf, timeout = 5000) {
+  const udpResult = await dnsQueryUDP(host, port, queryBuf, timeout)
+  const tc = (udpResult.readUInt16BE(2) >> 9) & 1
+  if (tc) return dnsQueryTCP(host, port, queryBuf, timeout)
+  return udpResult
+}

package/lib/tinydns.js

@@ -18,6 +18,84 @@ export const SPECIAL_CHARS = {
 }
 
 const octalRe = new RegExp(/\\(?:[1-7][0-7]{0,2}|[0-7]{2,3})/, 'g')
+const textDecoder = new TextDecoder()
+
+export function parseFields(tinyline, rdataCount) {
+  const parts = tinyline.slice(1).split(':')
+  const owner = parts[0]
+  const rdata = parts.slice(1, 1 + rdataCount)
+  const [ttl, timestamp, location] = parts.slice(1 + rdataCount)
+  return { owner, rdata, ttl, timestamp, location: location?.trim() ?? '' }
+}
+
+export function parseGenericLine(tinyline) {
+  // Generic form: :owner:typeId:rdata:ttl:timestamp:location
+  const [owner, typeId, rdata, ttl, timestamp, location] = tinyline.slice(1).split(':')
+  return { owner, typeId, rdata, ttl: parseInt(ttl, 10), timestamp, location: location?.trim() ?? '' }
+}
+
+export function octalRdataToBytes(rdata) {
+  return Uint8Array.from(octalToChar(rdata), (c) => c.charCodeAt(0))
+}
+
+export function parseSvcbLikeRdata(rdata, recordType) {
+  if (rdata.length < 6) {
+    throw new Error(`${recordType}: RDATA too short: ${rdata}`)
+  }
+
+  const binary = octalRdataToBytes(rdata)
+  const priority = (binary[0] << 8) | binary[1]
+
+  let pos = 2
+  const labels = []
+  while (true) {
+    const len = binary[pos]
+    pos += 1
+    if (len === 0) break
+    labels.push(textDecoder.decode(binary.subarray(pos, pos + len)))
+    pos += len
+  }
+
+  return {
+    priority,
+    targetName: `${labels.join('.')}.`,
+    params: textDecoder.decode(binary.subarray(pos)),
+  }
+}
+
+export function to(rrInstance) {
+  if (rrInstance.constructor.tinydnsType) {
+    const fields = rrInstance.getFields('rdata')
+    const rdata = fields
+      .map((f) => {
+        if (rrInstance.isFqdnField(f)) return rrInstance.getTinyFQDN(f)
+        return rrInstance.get(f)
+      })
+      .join(':')
+    return `${rrInstance.constructor.tinydnsType}${rrInstance.getTinyFQDN('owner')}:${rdata}:${rrInstance.getTinydnsPostamble()}\n`
+  }
+  return rrInstance.getTinydnsGeneric(bytesToOctalString(rrInstance.getWireRdata()))
+}
+
+export function fromGeneric(rrInstance, { tinyline }) {
+  const fields = rrInstance.getFields('rdata')
+  const { owner, rdata, ttl, timestamp, location } = parseFields(tinyline, fields.length)
+
+  const result = {
+    owner: rrInstance.fullyQualify(owner),
+    type: rrInstance.constructor.typeName,
+    ttl: parseInt(ttl, 10),
+    timestamp: timestamp,
+    location: location,
+  }
+
+  for (let i = 0; i < fields.length; i++) {
+    const val = rdata[i]
+    result[fields[i]] = rrInstance.isFqdnField(fields[i]) ? rrInstance.fullyQualify(val) : val
+  }
+
+  return new rrInstance.constructor(result)
+}
 
 export function escapeOctal(re, str) {
   let escaped = ''
@@ -28,7 +106,7 @@ export function escapeOctal(re, str) {
 }
 
 export function unescapeOctal(str) {
-  return this.octalToChar(str)
+  return octalToChar(str)
 }
 
 export function octalToChar(str) {
@@ -46,47 +124,38 @@ export function octalToHex(str) {
 }
 
 export function octalToUInt8(str) {
-  const b = Buffer.alloc(1)
-  b.writeUInt8(parseInt(str.slice(1, 4), 8), 0)
-  return b.readUInt8()
+  return parseInt(str.slice(1, 4), 8) & 0xff
 }
 
 export function octalToUInt16(str) {
-  const b = Buffer.alloc(2)
-  b.writeUInt8(parseInt(str.slice(1, 4), 8), 0)
-  b.writeUInt8(parseInt(str.slice(5, 8), 8), 1)
-  return b.readUInt16BE()
+  return (parseInt(str.slice(1, 4), 8) << 8) | parseInt(str.slice(5, 8), 8)
 }
 
 export function octalToUInt32(str) {
-  const b = Buffer.alloc(4)
-  b.writeUInt8(parseInt(str.slice(1, 4), 8), 0)
-  b.writeUInt8(parseInt(str.slice(5, 8), 8), 1)
-  b.writeUInt8(parseInt(str.slice(9, 12), 8), 2)
-  b.writeUInt8(parseInt(str.slice(13, 16), 8), 3)
-  return b.readUInt32BE()
+  const b0 = parseInt(str.slice(1, 4), 8)
+  const b1 = parseInt(str.slice(5, 8), 8)
+  const b2 = parseInt(str.slice(9, 12), 8)
+  const b3 = parseInt(str.slice(13, 16), 8)
+  return ((b0 << 24) | (b1 << 16) | (b2 << 8) | b3) >>> 0
 }
 
 export function packString(str) {
   return str
     .match(/(.{1,255})/g)
-    .map((s) => {
-      const len = Buffer.alloc(1)
-      len.writeUInt8(s.length)
-      return `${UInt8toOctal(len.readUInt8(0))}${s}`
-    })
+    .map((s) => `${UInt8toOctal(s.length)}${s}`)
     .join('')
 }
 
 export function unpackString(str) {
-  const asBuf = Buffer.from(octalToChar(str.toString()))
+  const asBuf = Uint8Array.from(octalToChar(str.toString()), (c) => c.charCodeAt(0))
+  const dec = new TextDecoder()
   const res = []
   let pos = 0
   let len
-  while ((len = asBuf.readUInt8(pos))) {
+  while ((len = asBuf[pos])) {
     // encoded length byte
     pos++
-    res.push(asBuf.slice(pos, pos + len).toString())
+    res.push(dec.decode(asBuf.subarray(pos, pos + len)))
     pos = +(pos + len)
     if (pos >= asBuf.length) break
   }
@@ -102,9 +171,7 @@ export function packDomainName(fqdn) {
   fqdn.split('.').forEach((label) => {
     if (label === undefined || !label.length) return
 
-    const len = Buffer.alloc(1)
-    len.writeUInt8(label.length)
-    packed += UInt8toOctal(len.readUInt8(0))
+    packed += UInt8toOctal(label.length)
 
     packed += escapeOctal(labelRegEx, label)
   })
@@ -163,28 +230,26 @@ export function charToOctal(c) {
 }
 
 export function UInt8toOctal(n) {
-  if (n > 255) throw new Error('UInt8toOctal does not work on numbers > 255')
+  if (n > 255) {
+    throw new Error(
+      `UInt8toOctal: value ${n} exceeds 255 — tinydns encoders require Latin-1/byte input (code points <= 0xFF)`,
+    )
+  }
 
   return `\\${parseInt(n, 10).toString(8).padStart(3, 0)}`
 }
 
 export function UInt16toOctal(n) {
-  let r = ''
-  const pri = Buffer.alloc(2)
-  pri.writeUInt16BE(n)
-  r += UInt8toOctal(pri.readUInt8(0))
-  r += UInt8toOctal(pri.readUInt8(1))
-  return r
+  return UInt8toOctal((n >>> 8) & 0xff) + UInt8toOctal(n & 0xff)
 }
 
 export function UInt32toOctal(n) {
-  let r = ''
-  const pri = Buffer.alloc(4)
-  pri.writeUInt32BE(n)
-  for (let i = 0; i < 4; i++) {
-    r += UInt8toOctal(pri.readUInt8(i))
-  }
-  return r
+  return (
+    UInt8toOctal((n >>> 24) & 0xff) +
+    UInt8toOctal((n >>> 16) & 0xff) +
+    UInt8toOctal((n >>> 8) & 0xff) +
+    UInt8toOctal(n & 0xff)
+  )
 }
 
 export function ipv4toOctal(ip) {
@@ -196,8 +261,20 @@ export function octalToIPv4(str) {
   return [24, 16, 8, 0].map((n) => (asInt >> n) & 0xff).join('.')
 }
 
+export function expandIPv6(val, delimiter = ':') {
+  const colons = val.match(/:/g)
+  if (colons?.length < 7) {
+    val = val.replace(/::/, ':'.repeat(9 - colons.length))
+  }
+  return val
+    .split(':')
+    .map((s) => s.padStart(4, '0'))
+    .join(delimiter)
+    .toLowerCase()
+}
+
 export function ipv6toOctal(ip) {
-  return packHex(ip.replace(/:/g, ''))
+  return packHex(expandIPv6(ip, ''))
 }
 
 export function octalToIPv6(str) {
@@ -207,14 +284,21 @@ export function octalToIPv6(str) {
 }
 
 export function base64toOctal(str) {
-  const bytes = Buffer.from(str, 'base64')
+  const binary = atob(str)
   let escaped = ''
-  for (const b of bytes) {
-    escaped += /[A-Za-z0-9\-.]/.test(String.fromCharCode(b)) ? String.fromCharCode(b) : UInt8toOctal(b)
+  for (let i = 0; i < binary.length; i++) {
+    const b = binary.charCodeAt(i)
+    escaped += /[A-Za-z0-9\-.]/.test(binary[i]) ? binary[i] : UInt8toOctal(b)
   }
   return escaped
 }
 
 export function octalToBase64(str) {
-  return Buffer.from(octalToChar(str), 'binary').toString('base64')
+  return btoa(octalToChar(str))
+}
+
+export function bytesToOctalString(bytes) {
+  let result = ''
+  for (const b of bytes) result += UInt8toOctal(b)
+  return result
 }