Bye buffer

buffer.js

@@ -0,0 +1,204 @@
+'use strict'
+
+// Allocate a new Uint8Array buffer
+function allocBuffer (size) {
+  return new Uint8Array(size)
+}
+
+// Allocate an uninitialized Uint8Array (same as allocBuffer for Uint8Array)
+function allocUnsafeBuffer (size) {
+  return new Uint8Array(size)
+}
+
+// Check if an object is a Uint8Array
+function isBuffer (obj) {
+  return obj instanceof Uint8Array
+}
+
+// Create Uint8Array from data with optional encoding
+function fromBuffer (data, encoding) {
+  if (data instanceof Uint8Array) {
+    return new Uint8Array(data)
+  }
+  if (Array.isArray(data)) {
+    return new Uint8Array(data)
+  }
+  if (typeof data === 'string') {
+    if (encoding === 'base64') {
+      return base64ToBuffer(data)
+    } else if (encoding === 'hex') {
+      return hexToBuffer(data)
+    } else {
+      return stringToBuffer(data)
+    }
+  }
+  return new Uint8Array(data)
+}
+
+// Convert string to Uint8Array (UTF-8 encoding)
+function stringToBuffer (str) {
+  const encoder = new TextEncoder()
+  return encoder.encode(str)
+}
+
+// Convert Base64 string to Uint8Array
+function base64ToBuffer (base64Str) {
+  if (typeof window !== 'undefined' && window.atob) {
+    // Browser environment
+    const binaryString = window.atob(base64Str)
+    const bytes = new Uint8Array(binaryString.length)
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i)
+    }
+    return bytes
+  } else {
+    // Node.js environment
+    return new Uint8Array(Buffer.from(base64Str, 'base64'))
+  }
+}
+
+// Convert hex string to Uint8Array
+function hexToBuffer (hexStr) {
+  const bytes = new Uint8Array(hexStr.length / 2)
+  for (let i = 0; i < hexStr.length; i += 2) {
+    bytes[i / 2] = parseInt(hexStr.substr(i, 2), 16)
+  }
+  return bytes
+}
+
+// Convert Uint8Array to hex string
+function bufferToHex (buf) {
+  let hex = ''
+  for (let i = 0; i < buf.length; i++) {
+    const byte = buf[i]
+    hex += (byte < 16 ? '0' : '') + byte.toString(16)
+  }
+  return hex.toUpperCase()
+}
+
+// Convert Uint8Array to string
+function bufferToString (buf, encoding, start, end) {
+  encoding = encoding || 'utf-8'
+  start = start || 0
+  end = end || buf.length
+
+  if (encoding !== 'utf-8' && encoding !== 'utf8') {
+    throw new Error('Unsupported encoding: ' + encoding)
+  }
+
+  const slice = buf.slice(start, end)
+  const decoder = new TextDecoder('utf-8')
+  return decoder.decode(slice)
+}
+
+// Write string to buffer, return number of bytes written
+function writeString (buf, str, offset) {
+  offset = offset || 0
+  const encoded = stringToBuffer(str)
+  for (let i = 0; i < encoded.length && offset + i < buf.length; i++) {
+    buf[offset + i] = encoded[i]
+  }
+  return encoded.length
+}
+
+// Get byte length of a string
+function byteLength (str) {
+  const encoder = new TextEncoder()
+  return encoder.encode(str).length
+}
+
+// Read big-endian 16-bit unsigned integer
+function readUInt16BE (buf, offset) {
+  offset = offset || 0
+  return (buf[offset] << 8) | buf[offset + 1]
+}
+
+// Write big-endian 16-bit unsigned integer
+function writeUInt16BE (buf, value, offset) {
+  offset = offset || 0
+  buf[offset] = (value >> 8) & 0xff
+  buf[offset + 1] = value & 0xff
+}
+
+// Read big-endian 32-bit unsigned integer
+function readUInt32BE (buf, offset) {
+  offset = offset || 0
+  return ((buf[offset] << 24) | (buf[offset + 1] << 16) | (buf[offset + 2] << 8) | buf[offset + 3]) >>> 0
+}
+
+// Write big-endian 32-bit unsigned integer
+function writeUInt32BE (buf, value, offset) {
+  offset = offset || 0
+  buf[offset] = (value >> 24) & 0xff
+  buf[offset + 1] = (value >> 16) & 0xff
+  buf[offset + 2] = (value >> 8) & 0xff
+  buf[offset + 3] = value & 0xff
+}
+
+// Read 8-bit unsigned integer
+function readUInt8 (buf, offset) {
+  offset = offset || 0
+  return buf[offset]
+}
+
+// Write 8-bit unsigned integer
+function writeUInt8 (buf, value, offset) {
+  offset = offset || 0
+  buf[offset] = value & 0xff
+}
+
+// Copy buffer contents
+function bufferCopy (source, target, targetStart, sourceStart, sourceEnd) {
+  targetStart = targetStart || 0
+  sourceStart = sourceStart || 0
+  sourceEnd = sourceEnd !== undefined ? sourceEnd : source.length
+
+  for (let i = sourceStart; i < sourceEnd; i++) {
+    target[targetStart + (i - sourceStart)] = source[i]
+  }
+}
+
+// Concatenate multiple buffers
+function bufferConcat (buffers, totalLength) {
+  if (!Array.isArray(buffers)) {
+    throw new Error('buffers must be an Array')
+  }
+
+  if (buffers.length === 0) {
+    return new Uint8Array(0)
+  }
+
+  totalLength = totalLength || buffers.reduce((sum, buf) => sum + buf.length, 0)
+  const result = new Uint8Array(totalLength)
+
+  let offset = 0
+  for (let i = 0; i < buffers.length; i++) {
+    const buf = buffers[i]
+    result.set(buf, offset)
+    offset += buf.length
+  }
+
+  return result
+}
+
+module.exports = {
+  allocBuffer,
+  allocUnsafeBuffer,
+  isBuffer,
+  fromBuffer,
+  stringToBuffer,
+  base64ToBuffer,
+  hexToBuffer,
+  bufferToHex,
+  bufferToString,
+  writeString,
+  byteLength,
+  readUInt8,
+  writeUInt8,
+  readUInt16BE,
+  writeUInt16BE,
+  readUInt32BE,
+  writeUInt32BE,
+  bufferCopy,
+  bufferConcat
+}

hexdump.js

@@ -1,7 +1,16 @@
 'use strict'
 
 const wout = (s) => {
-  process.stdout.write(s)
+  if (typeof process !== 'undefined' && process.stdout) {
+    process.stdout.write(s)
+  } else if (typeof console !== 'undefined') {
+    if (s === '\n') {
+      console.log('')
+    } else {
+      process.stdout = process.stdout || ''
+      process.stdout += s
+    }
+  }
 }
 
 const padStr = (s, len, ch) => {
@@ -55,7 +64,7 @@ const hexdump = (buf, len) => {
 }
 
 /*
-let buf = Buffer.alloc(500)
+let buf = new Uint8Array(500)
 for (let i = 0; i < buf.length; i++) {
   buf[i] = i & 0xff
 }

test.js

@@ -11,7 +11,7 @@ const ip = require('@leichtgewicht/ip-codec')
 const hexdump = require('./hexdump')
 
 tape('unknown', function (t) {
-  testEncoder(t, packet.unknown, Buffer.from('hello world'))
+  testEncoder(t, packet.unknown, new Uint8Array('hello world'))
   t.end()
 })
 
@@ -19,9 +19,9 @@ tape('txt', function (t) {
   testEncoder(t, packet.txt, [])
   testEncoder(t, packet.txt, ['hello world'])
   testEncoder(t, packet.txt, ['hello', 'world'])
-  testEncoder(t, packet.txt, [Buffer.from([0, 1, 2, 3, 4, 5])])
+  testEncoder(t, packet.txt, [new Uint8Array([0, 1, 2, 3, 4, 5])])
-  testEncoder(t, packet.txt, ['a', 'b', Buffer.from([0, 1, 2, 3, 4, 5])])
+  testEncoder(t, packet.txt, ['a', 'b', new Uint8Array([0, 1, 2, 3, 4, 5])])
-  testEncoder(t, packet.txt, ['', Buffer.allocUnsafe(0)])
+  testEncoder(t, packet.txt, ['', new Uint8Array(0)])
   t.end()
 })
 
@@ -29,16 +29,17 @@ tape('txt-scalar-string', function (t) {
   const buf = packet.txt.encode('hi')
   const val = packet.txt.decode(buf)
   t.ok(val.length === 1, 'array length')
-  t.ok(val[0].toString() === 'hi', 'data')
+  const decoded = val[0] instanceof Uint8Array ? new TextDecoder().decode(val[0]) : val[0].toString()
+  t.ok(decoded === 'hi', 'data')
   t.end()
 })
 
 tape('txt-scalar-buffer', function (t) {
-  const data = Buffer.from([0, 1, 2, 3, 4, 5])
+  const data = new Uint8Array([0, 1, 2, 3, 4, 5])
   const buf = packet.txt.encode(data)
   const val = packet.txt.decode(buf)
   t.ok(val.length === 1, 'array length')
-  t.ok(val[0].equals(data), 'data')
+  t.ok(compare(t, val[0], data), 'data')
   t.end()
 })
 
@@ -50,7 +51,7 @@ tape('txt-invalid-data', function (t) {
 })
 
 tape('null', function (t) {
-  testEncoder(t, packet.null, Buffer.from([0, 1, 2, 3, 4, 5]))
+  testEncoder(t, packet.null, new Uint8Array([0, 1, 2, 3, 4, 5]))
   t.end()
 })
 
@@ -259,7 +260,7 @@ tape('response', function (t) {
     answers: [{
       type: 'NULL',
       name: 'hello.null.com',
-      data: Buffer.from([1, 2, 3, 4, 5])
+      data: new Uint8Array([1, 2, 3, 4, 5])
     }]
   })
 
@@ -315,7 +316,7 @@ tape('rcode', function (t) {
 
 tape('name_encoding', function (t) {
   let data = 'foo.example.com'
-  const buf = Buffer.allocUnsafe(255)
+  const buf = new Uint8Array(255)
   let offset = 0
   packet.name.encode(data, buf, offset)
   t.ok(packet.name.encode.bytes === 17, 'name encoding length matches')
@@ -384,42 +385,57 @@ tape('name_encoding', function (t) {
 
 tape('name_decoding', function (t) {
   // The two most significant bits of a valid label header must be either both zero or both one
-  t.throws(function () { packet.name.decode(Buffer.from([0x80])) }, /Cannot decode name \(bad label\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0x80])) }, /Cannot decode name \(bad label\)$/)
-  t.throws(function () { packet.name.decode(Buffer.from([0xb0])) }, /Cannot decode name \(bad label\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0xb0])) }, /Cannot decode name \(bad label\)$/)
 
   // Ensure there's enough buffer to read
-  t.throws(function () { packet.name.decode(Buffer.from([])) }, /Cannot decode name \(buffer overflow\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([])) }, /Cannot decode name \(buffer overflow\)$/)
-  t.throws(function () { packet.name.decode(Buffer.from([0x01, 0x00])) }, /Cannot decode name \(buffer overflow\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0x01, 0x00])) }, /Cannot decode name \(buffer overflow\)$/)
-  t.throws(function () { packet.name.decode(Buffer.from([0x01])) }, /Cannot decode name \(buffer overflow\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0x01])) }, /Cannot decode name \(buffer overflow\)$/)
-  t.throws(function () { packet.name.decode(Buffer.from([0xc0])) }, /Cannot decode name \(buffer overflow\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0xc0])) }, /Cannot decode name \(buffer overflow\)$/)
 
   // Allow only pointers backwards
-  t.throws(function () { packet.name.decode(Buffer.from([0xc0, 0x00])) }, /Cannot decode name \(bad pointer\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0xc0, 0x00])) }, /Cannot decode name \(bad pointer\)$/)
-  t.throws(function () { packet.name.decode(Buffer.from([0xc0, 0x01])) }, /Cannot decode name \(bad pointer\)$/)
+  t.throws(function () { packet.name.decode(new Uint8Array([0xc0, 0x01])) }, /Cannot decode name \(bad pointer\)$/)
 
   // A name can be only 253 characters (when connected with dots)
-  const maxLength = Buffer.alloc(255)
+  const maxLength = new Uint8Array(255)
-  maxLength.fill(Buffer.from([0x01, 0x61]), 0, 254)
+  for (let i = 0; i < 127; i++) {
+    maxLength[i * 2] = 0x01
+    maxLength[i * 2 + 1] = 0x61
+  }
+  maxLength[254] = 0x00
   t.ok(packet.name.decode(maxLength) === new Array(127).fill('a').join('.'))
 
-  const tooLong = Buffer.alloc(256)
+  const tooLong = new Uint8Array(256)
-  tooLong.fill(Buffer.from([0x01, 0x61]))
+  for (let i = 0; i < 128; i++) {
+    tooLong[i * 2] = 0x01
+    tooLong[i * 2 + 1] = 0x61
+  }
   t.throws(function () { packet.name.decode(tooLong) }, /Cannot decode name \(name too long\)$/)
 
   // Ensure jumps don't reset the total length counter
-  const tooLongWithJump = Buffer.alloc(403)
+  const tooLongWithJump = new Uint8Array(403)
-  tooLongWithJump.fill(Buffer.from([0x01, 0x61]), 0, 200)
+  for (let i = 0; i < 100; i++) {
-  tooLongWithJump.fill(Buffer.from([0x01, 0x61]), 201, 401)
+    tooLongWithJump[i * 2] = 0x01
+    tooLongWithJump[i * 2 + 1] = 0x61
+  }
+  for (let i = 0; i < 100; i++) {
+    tooLongWithJump[201 + i * 2] = 0x01
+    tooLongWithJump[201 + i * 2 + 1] = 0x61
+  }
   tooLongWithJump.set([0xc0, 0x00], 401)
   t.throws(function () { packet.name.decode(tooLongWithJump, 201) }, /Cannot decode name \(name too long\)$/)
 
   // Ensure a jump to a null byte doesn't add extra dots
-  t.ok(packet.name.decode(Buffer.from([0x00, 0x01, 0x61, 0xc0, 0x00]), 1) === 'a')
+  t.ok(packet.name.decode(new Uint8Array([0x00, 0x01, 0x61, 0xc0, 0x00]), 1) === 'a')
 
   // Ensure deeply nested pointers don't cause "Maximum call stack size exceeded" errors
-  const buf = Buffer.alloc(16386)
+  const buf = new Uint8Array(16386)
   for (let i = 0; i < 16384; i += 2) {
-    buf.writeUInt16BE(0xc000 | i, i + 2)
+    const value = 0xc000 | i
+    buf[i + 2] = (value >> 8) & 0xff
+    buf[i + 3] = value & 0xff
   }
   t.ok(packet.name.decode(buf, 16384) === '.')
 
@@ -519,7 +535,7 @@ tape('dnskey', function (t) {
   testEncoder(t, packet.dnskey, {
     flags: packet.dnskey.SECURE_ENTRYPOINT | packet.dnskey.ZONE_KEY,
     algorithm: 1,
-    key: Buffer.from([0, 1, 2, 3, 4, 5])
+    key: new Uint8Array([0, 1, 2, 3, 4, 5])
   })
   t.end()
 })
@@ -534,12 +550,12 @@ tape('rrsig', function (t) {
     inception: 1233,
     keyTag: 2345,
     signersName: 'foo.com',
-    signature: Buffer.from([0, 1, 2, 3, 4, 5])
+    signature: new Uint8Array([0, 1, 2, 3, 4, 5])
   }
   testEncoder(t, packet.rrsig, testRRSIG)
 
   // Check the signature length is correct with extra junk at the end
-  const buf = Buffer.allocUnsafe(packet.rrsig.encodingLength(testRRSIG) + 4)
+  const buf = new Uint8Array(packet.rrsig.encodingLength(testRRSIG) + 4)
   packet.rrsig.encode(testRRSIG, buf)
   const val2 = packet.rrsig.decode(buf)
   t.ok(compare(t, testRRSIG, val2))
@@ -589,9 +605,9 @@ tape('nsec', function (t) {
   })
 
   // Test with the sample NSEC from https://tools.ietf.org/html/rfc4034#section-4.3
-  var sampleNSEC = Buffer.from('003704686f7374076578616d706c6503636f6d00' +
+  var sampleNSEC = unhexlify('003704686f7374076578616d706c6503636f6d00' +
       '0006400100000003041b000000000000000000000000000000000000000000000' +
-      '000000020', 'hex')
+      '000000020')
   var decoded = packet.nsec.decode(sampleNSEC)
   t.ok(compare(t, decoded, {
     nextDomain: 'host.example.com',
@@ -608,8 +624,8 @@ tape('nsec3', function (t) {
     algorithm: 1,
     flags: 0,
     iterations: 257,
-    salt: Buffer.from([42, 42, 42]),
+    salt: new Uint8Array([42, 42, 42]),
-    nextDomain: Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]),
+    nextDomain: new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]),
     rrtypes: ['A', 'DNSKEY', 'CAA', 'DLV']
   })
   t.end()
@@ -620,7 +636,7 @@ tape('ds', function (t) {
     keyTag: 1234,
     algorithm: 1,
     digestType: 1,
-    digest: Buffer.from([0, 1, 2, 3, 4, 5])
+    digest: new Uint8Array([0, 1, 2, 3, 4, 5])
   })
   t.end()
 })
@@ -642,13 +658,13 @@ tape('tlsa', function (t) {
     usage: 3,
     selector: 1,
     matchingType: 1,
-    certificate: Buffer.from([0, 1, 2, 3, 4, 5])
+    certificate: new Uint8Array([0, 1, 2, 3, 4, 5])
   })
   t.end()
 })
 
 const unhexlify = (hex) => {
-  return Buffer.from(hex.match(/[\da-f]{2}/gi).map(function (h) { return parseInt(h, 16) }))
+  return new Uint8Array(hex.match(/[\da-f]{2}/gi).map(function (h) { return parseInt(h, 16) }))
 }
 
 // <HTTPS SVCB test cases>
@@ -834,7 +850,7 @@ tape('https svcb', function (t) {
       priority: 1,
       name: 'foo.example.com',
       values: {
-        key667: unhexlify('68 65 6c 6c 6f d2 71 6f 6f').toString('utf-8')
+        key667: new TextDecoder('utf-8').decode(unhexlify('68 65 6c 6c 6f d2 71 6f 6f'))
       }
     },
     true // skipEncode, we cannot encode an unknown key
@@ -977,6 +993,7 @@ tape('cloudflare real world svcb/https', (t) => {
       {
         name: 'community.cloudflare.com',
         type: 'HTTPS',
+        qu_bit: false,
         class: 'IN'
       }
     ],
@@ -1079,6 +1096,7 @@ tape('google resolver SVCB real world', function (t) {
       {
         name: '_dns.resolver.arpa',
         type: 'SVCB',
+        qu_bit: false,
         class: 'IN'
       }
     ],
@@ -1176,7 +1194,7 @@ tape('google resolver SVCB real world', function (t) {
 // </HTTPS SVCB test cases>
 
 tape('unpack', function (t) {
-  const buf = Buffer.from([
+  const buf = new Uint8Array([
     0x00, 0x79,
     0xde, 0xad, 0x85, 0x00, 0x00, 0x01, 0x00, 0x01,
     0x00, 0x02, 0x00, 0x02, 0x02, 0x6f, 0x6a, 0x05,
@@ -1256,7 +1274,7 @@ function testEncoder (t, rpacket, val) {
   t.ok(compare(t, val, val3), 'decoded object match on re-encode')
   t.ok(compare(t, val2, val3), 're-encoded decoded object match on re-encode')
 
-  const bigger = Buffer.allocUnsafe(buf2.length + 10)
+  const bigger = new Uint8Array(buf2.length + 10)
 
   const buf3 = rpacket.encode(val, bigger, 10)
   const val4 = rpacket.decode(buf3, 10)
@@ -1267,7 +1285,13 @@ function testEncoder (t, rpacket, val) {
 }
 
 function compare (t, a, b) {
-  if (Buffer.isBuffer(a)) return a.toString('hex') === b.toString('hex')
+  if (a instanceof Uint8Array && b instanceof Uint8Array) {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false
+    }
+    return true
+  }
   if (typeof a === 'object' && a && b) {
     const keys = Object.keys(a)
     for (let i = 0; i < keys.length; i++) {