@basmilius/apple-common 0.0.81 → 0.0.83

package/dist/crypto/chacha20.d.ts

@@ -1,6 +1,6 @@
 export declare const CHACHA20_AUTH_TAG_LENGTH = 16;
 export declare const CHACHA20_NONCE_LENGTH = 12;
-export declare function decrypt(key: Buffer, nonce: Buffer, add: Buffer | null, ciphertext: Buffer, authTag: Buffer): Buffer;
+export declare function decrypt(key: Buffer, nonce: Buffer, aad: Buffer | null, ciphertext: Buffer, authTag: Buffer): Buffer;
 export declare function encrypt(key: Buffer, nonce: Buffer, aad: Buffer | null, plaintext: Buffer): EncryptedData;
 export declare function padNonce(nonce: Buffer): Buffer;
 export type EncryptedData = {

package/dist/index.js

@@ -23,25 +23,752 @@ __export(exports_chacha20, {
   CHACHA20_NONCE_LENGTH: () => CHACHA20_NONCE_LENGTH,
   CHACHA20_AUTH_TAG_LENGTH: () => CHACHA20_AUTH_TAG_LENGTH
 });
-import { createCipher, createDecipher } from "chacha";
+
+// ../../node_modules/@stablelib/int/lib/int.js
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+// ../../node_modules/@stablelib/binary/lib/binary.js
+function writeUint32LE(value, out = new Uint8Array(4), offset = 0) {
+  out[offset + 0] = value >>> 0;
+  out[offset + 1] = value >>> 8;
+  out[offset + 2] = value >>> 16;
+  out[offset + 3] = value >>> 24;
+  return out;
+}
+function writeUint64LE(value, out = new Uint8Array(8), offset = 0) {
+  writeUint32LE(value >>> 0, out, offset);
+  writeUint32LE(value / 4294967296 >>> 0, out, offset + 4);
+  return out;
+}
+
+// ../../node_modules/@stablelib/wipe/lib/wipe.js
+function wipe(array) {
+  for (let i = 0;i < array.length; i++) {
+    array[i] = 0;
+  }
+  return array;
+}
+
+// ../../node_modules/@stablelib/chacha/lib/chacha.js
+var ROUNDS = 20;
+function core(out, input, key) {
+  let j0 = 1634760805;
+  let j1 = 857760878;
+  let j2 = 2036477234;
+  let j3 = 1797285236;
+  let j4 = key[3] << 24 | key[2] << 16 | key[1] << 8 | key[0];
+  let j5 = key[7] << 24 | key[6] << 16 | key[5] << 8 | key[4];
+  let j6 = key[11] << 24 | key[10] << 16 | key[9] << 8 | key[8];
+  let j7 = key[15] << 24 | key[14] << 16 | key[13] << 8 | key[12];
+  let j8 = key[19] << 24 | key[18] << 16 | key[17] << 8 | key[16];
+  let j9 = key[23] << 24 | key[22] << 16 | key[21] << 8 | key[20];
+  let j10 = key[27] << 24 | key[26] << 16 | key[25] << 8 | key[24];
+  let j11 = key[31] << 24 | key[30] << 16 | key[29] << 8 | key[28];
+  let j12 = input[3] << 24 | input[2] << 16 | input[1] << 8 | input[0];
+  let j13 = input[7] << 24 | input[6] << 16 | input[5] << 8 | input[4];
+  let j14 = input[11] << 24 | input[10] << 16 | input[9] << 8 | input[8];
+  let j15 = input[15] << 24 | input[14] << 16 | input[13] << 8 | input[12];
+  let x0 = j0;
+  let x1 = j1;
+  let x2 = j2;
+  let x3 = j3;
+  let x4 = j4;
+  let x5 = j5;
+  let x6 = j6;
+  let x7 = j7;
+  let x8 = j8;
+  let x9 = j9;
+  let x10 = j10;
+  let x11 = j11;
+  let x12 = j12;
+  let x13 = j13;
+  let x14 = j14;
+  let x15 = j15;
+  for (let i = 0;i < ROUNDS; i += 2) {
+    x0 = x0 + x4 | 0;
+    x12 ^= x0;
+    x12 = x12 >>> 32 - 16 | x12 << 16;
+    x8 = x8 + x12 | 0;
+    x4 ^= x8;
+    x4 = x4 >>> 32 - 12 | x4 << 12;
+    x1 = x1 + x5 | 0;
+    x13 ^= x1;
+    x13 = x13 >>> 32 - 16 | x13 << 16;
+    x9 = x9 + x13 | 0;
+    x5 ^= x9;
+    x5 = x5 >>> 32 - 12 | x5 << 12;
+    x2 = x2 + x6 | 0;
+    x14 ^= x2;
+    x14 = x14 >>> 32 - 16 | x14 << 16;
+    x10 = x10 + x14 | 0;
+    x6 ^= x10;
+    x6 = x6 >>> 32 - 12 | x6 << 12;
+    x3 = x3 + x7 | 0;
+    x15 ^= x3;
+    x15 = x15 >>> 32 - 16 | x15 << 16;
+    x11 = x11 + x15 | 0;
+    x7 ^= x11;
+    x7 = x7 >>> 32 - 12 | x7 << 12;
+    x2 = x2 + x6 | 0;
+    x14 ^= x2;
+    x14 = x14 >>> 32 - 8 | x14 << 8;
+    x10 = x10 + x14 | 0;
+    x6 ^= x10;
+    x6 = x6 >>> 32 - 7 | x6 << 7;
+    x3 = x3 + x7 | 0;
+    x15 ^= x3;
+    x15 = x15 >>> 32 - 8 | x15 << 8;
+    x11 = x11 + x15 | 0;
+    x7 ^= x11;
+    x7 = x7 >>> 32 - 7 | x7 << 7;
+    x1 = x1 + x5 | 0;
+    x13 ^= x1;
+    x13 = x13 >>> 32 - 8 | x13 << 8;
+    x9 = x9 + x13 | 0;
+    x5 ^= x9;
+    x5 = x5 >>> 32 - 7 | x5 << 7;
+    x0 = x0 + x4 | 0;
+    x12 ^= x0;
+    x12 = x12 >>> 32 - 8 | x12 << 8;
+    x8 = x8 + x12 | 0;
+    x4 ^= x8;
+    x4 = x4 >>> 32 - 7 | x4 << 7;
+    x0 = x0 + x5 | 0;
+    x15 ^= x0;
+    x15 = x15 >>> 32 - 16 | x15 << 16;
+    x10 = x10 + x15 | 0;
+    x5 ^= x10;
+    x5 = x5 >>> 32 - 12 | x5 << 12;
+    x1 = x1 + x6 | 0;
+    x12 ^= x1;
+    x12 = x12 >>> 32 - 16 | x12 << 16;
+    x11 = x11 + x12 | 0;
+    x6 ^= x11;
+    x6 = x6 >>> 32 - 12 | x6 << 12;
+    x2 = x2 + x7 | 0;
+    x13 ^= x2;
+    x13 = x13 >>> 32 - 16 | x13 << 16;
+    x8 = x8 + x13 | 0;
+    x7 ^= x8;
+    x7 = x7 >>> 32 - 12 | x7 << 12;
+    x3 = x3 + x4 | 0;
+    x14 ^= x3;
+    x14 = x14 >>> 32 - 16 | x14 << 16;
+    x9 = x9 + x14 | 0;
+    x4 ^= x9;
+    x4 = x4 >>> 32 - 12 | x4 << 12;
+    x2 = x2 + x7 | 0;
+    x13 ^= x2;
+    x13 = x13 >>> 32 - 8 | x13 << 8;
+    x8 = x8 + x13 | 0;
+    x7 ^= x8;
+    x7 = x7 >>> 32 - 7 | x7 << 7;
+    x3 = x3 + x4 | 0;
+    x14 ^= x3;
+    x14 = x14 >>> 32 - 8 | x14 << 8;
+    x9 = x9 + x14 | 0;
+    x4 ^= x9;
+    x4 = x4 >>> 32 - 7 | x4 << 7;
+    x1 = x1 + x6 | 0;
+    x12 ^= x1;
+    x12 = x12 >>> 32 - 8 | x12 << 8;
+    x11 = x11 + x12 | 0;
+    x6 ^= x11;
+    x6 = x6 >>> 32 - 7 | x6 << 7;
+    x0 = x0 + x5 | 0;
+    x15 ^= x0;
+    x15 = x15 >>> 32 - 8 | x15 << 8;
+    x10 = x10 + x15 | 0;
+    x5 ^= x10;
+    x5 = x5 >>> 32 - 7 | x5 << 7;
+  }
+  writeUint32LE(x0 + j0 | 0, out, 0);
+  writeUint32LE(x1 + j1 | 0, out, 4);
+  writeUint32LE(x2 + j2 | 0, out, 8);
+  writeUint32LE(x3 + j3 | 0, out, 12);
+  writeUint32LE(x4 + j4 | 0, out, 16);
+  writeUint32LE(x5 + j5 | 0, out, 20);
+  writeUint32LE(x6 + j6 | 0, out, 24);
+  writeUint32LE(x7 + j7 | 0, out, 28);
+  writeUint32LE(x8 + j8 | 0, out, 32);
+  writeUint32LE(x9 + j9 | 0, out, 36);
+  writeUint32LE(x10 + j10 | 0, out, 40);
+  writeUint32LE(x11 + j11 | 0, out, 44);
+  writeUint32LE(x12 + j12 | 0, out, 48);
+  writeUint32LE(x13 + j13 | 0, out, 52);
+  writeUint32LE(x14 + j14 | 0, out, 56);
+  writeUint32LE(x15 + j15 | 0, out, 60);
+}
+function streamXOR(key, nonce, src, dst, nonceInplaceCounterLength = 0) {
+  if (key.length !== 32) {
+    throw new Error("ChaCha: key size must be 32 bytes");
+  }
+  if (dst.length < src.length) {
+    throw new Error("ChaCha: destination is shorter than source");
+  }
+  let nc;
+  let counterLength;
+  if (nonceInplaceCounterLength === 0) {
+    if (nonce.length !== 8 && nonce.length !== 12) {
+      throw new Error("ChaCha nonce must be 8 or 12 bytes");
+    }
+    nc = new Uint8Array(16);
+    counterLength = nc.length - nonce.length;
+    nc.set(nonce, counterLength);
+  } else {
+    if (nonce.length !== 16) {
+      throw new Error("ChaCha nonce with counter must be 16 bytes");
+    }
+    nc = nonce;
+    counterLength = nonceInplaceCounterLength;
+  }
+  const block = new Uint8Array(64);
+  for (let i = 0;i < src.length; i += 64) {
+    core(block, nc, key);
+    for (let j = i;j < i + 64 && j < src.length; j++) {
+      dst[j] = src[j] ^ block[j - i];
+    }
+    incrementCounter(nc, 0, counterLength);
+  }
+  wipe(block);
+  if (nonceInplaceCounterLength === 0) {
+    wipe(nc);
+  }
+  return dst;
+}
+function stream(key, nonce, dst, nonceInplaceCounterLength = 0) {
+  wipe(dst);
+  return streamXOR(key, nonce, dst, dst, nonceInplaceCounterLength);
+}
+function incrementCounter(counter, pos, len) {
+  let carry = 1;
+  while (len--) {
+    carry = carry + (counter[pos] & 255) | 0;
+    counter[pos] = carry & 255;
+    carry >>>= 8;
+    pos++;
+  }
+  if (carry > 0) {
+    throw new Error("ChaCha: counter overflow");
+  }
+}
+
+// ../../node_modules/@stablelib/constant-time/lib/constant-time.js
+function compare(a, b) {
+  if (a.length !== b.length) {
+    return 0;
+  }
+  let result = 0;
+  for (let i = 0;i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return 1 & result - 1 >>> 8;
+}
+function equal(a, b) {
+  if (a.length === 0 || b.length === 0) {
+    return false;
+  }
+  return compare(a, b) !== 0;
+}
+
+// ../../node_modules/@stablelib/poly1305/lib/poly1305.js
+var DIGEST_LENGTH = 16;
+
+class Poly1305 {
+  digestLength = DIGEST_LENGTH;
+  _buffer = new Uint8Array(16);
+  _r = new Uint16Array(10);
+  _h = new Uint16Array(10);
+  _pad = new Uint16Array(8);
+  _leftover = 0;
+  _fin = 0;
+  _finished = false;
+  constructor(key) {
+    let t0 = key[0] | key[1] << 8;
+    this._r[0] = t0 & 8191;
+    let t1 = key[2] | key[3] << 8;
+    this._r[1] = (t0 >>> 13 | t1 << 3) & 8191;
+    let t2 = key[4] | key[5] << 8;
+    this._r[2] = (t1 >>> 10 | t2 << 6) & 7939;
+    let t3 = key[6] | key[7] << 8;
+    this._r[3] = (t2 >>> 7 | t3 << 9) & 8191;
+    let t4 = key[8] | key[9] << 8;
+    this._r[4] = (t3 >>> 4 | t4 << 12) & 255;
+    this._r[5] = t4 >>> 1 & 8190;
+    let t5 = key[10] | key[11] << 8;
+    this._r[6] = (t4 >>> 14 | t5 << 2) & 8191;
+    let t6 = key[12] | key[13] << 8;
+    this._r[7] = (t5 >>> 11 | t6 << 5) & 8065;
+    let t7 = key[14] | key[15] << 8;
+    this._r[8] = (t6 >>> 8 | t7 << 8) & 8191;
+    this._r[9] = t7 >>> 5 & 127;
+    this._pad[0] = key[16] | key[17] << 8;
+    this._pad[1] = key[18] | key[19] << 8;
+    this._pad[2] = key[20] | key[21] << 8;
+    this._pad[3] = key[22] | key[23] << 8;
+    this._pad[4] = key[24] | key[25] << 8;
+    this._pad[5] = key[26] | key[27] << 8;
+    this._pad[6] = key[28] | key[29] << 8;
+    this._pad[7] = key[30] | key[31] << 8;
+  }
+  _blocks(m, mpos, bytes) {
+    let hibit = this._fin ? 0 : 1 << 11;
+    let h0 = this._h[0], h1 = this._h[1], h2 = this._h[2], h3 = this._h[3], h4 = this._h[4], h5 = this._h[5], h6 = this._h[6], h7 = this._h[7], h8 = this._h[8], h9 = this._h[9];
+    let r0 = this._r[0], r1 = this._r[1], r2 = this._r[2], r3 = this._r[3], r4 = this._r[4], r5 = this._r[5], r6 = this._r[6], r7 = this._r[7], r8 = this._r[8], r9 = this._r[9];
+    while (bytes >= 16) {
+      let t0 = m[mpos + 0] | m[mpos + 1] << 8;
+      h0 += t0 & 8191;
+      let t1 = m[mpos + 2] | m[mpos + 3] << 8;
+      h1 += (t0 >>> 13 | t1 << 3) & 8191;
+      let t2 = m[mpos + 4] | m[mpos + 5] << 8;
+      h2 += (t1 >>> 10 | t2 << 6) & 8191;
+      let t3 = m[mpos + 6] | m[mpos + 7] << 8;
+      h3 += (t2 >>> 7 | t3 << 9) & 8191;
+      let t4 = m[mpos + 8] | m[mpos + 9] << 8;
+      h4 += (t3 >>> 4 | t4 << 12) & 8191;
+      h5 += t4 >>> 1 & 8191;
+      let t5 = m[mpos + 10] | m[mpos + 11] << 8;
+      h6 += (t4 >>> 14 | t5 << 2) & 8191;
+      let t6 = m[mpos + 12] | m[mpos + 13] << 8;
+      h7 += (t5 >>> 11 | t6 << 5) & 8191;
+      let t7 = m[mpos + 14] | m[mpos + 15] << 8;
+      h8 += (t6 >>> 8 | t7 << 8) & 8191;
+      h9 += t7 >>> 5 | hibit;
+      let c = 0;
+      let d0 = c;
+      d0 += h0 * r0;
+      d0 += h1 * (5 * r9);
+      d0 += h2 * (5 * r8);
+      d0 += h3 * (5 * r7);
+      d0 += h4 * (5 * r6);
+      c = d0 >>> 13;
+      d0 &= 8191;
+      d0 += h5 * (5 * r5);
+      d0 += h6 * (5 * r4);
+      d0 += h7 * (5 * r3);
+      d0 += h8 * (5 * r2);
+      d0 += h9 * (5 * r1);
+      c += d0 >>> 13;
+      d0 &= 8191;
+      let d1 = c;
+      d1 += h0 * r1;
+      d1 += h1 * r0;
+      d1 += h2 * (5 * r9);
+      d1 += h3 * (5 * r8);
+      d1 += h4 * (5 * r7);
+      c = d1 >>> 13;
+      d1 &= 8191;
+      d1 += h5 * (5 * r6);
+      d1 += h6 * (5 * r5);
+      d1 += h7 * (5 * r4);
+      d1 += h8 * (5 * r3);
+      d1 += h9 * (5 * r2);
+      c += d1 >>> 13;
+      d1 &= 8191;
+      let d2 = c;
+      d2 += h0 * r2;
+      d2 += h1 * r1;
+      d2 += h2 * r0;
+      d2 += h3 * (5 * r9);
+      d2 += h4 * (5 * r8);
+      c = d2 >>> 13;
+      d2 &= 8191;
+      d2 += h5 * (5 * r7);
+      d2 += h6 * (5 * r6);
+      d2 += h7 * (5 * r5);
+      d2 += h8 * (5 * r4);
+      d2 += h9 * (5 * r3);
+      c += d2 >>> 13;
+      d2 &= 8191;
+      let d3 = c;
+      d3 += h0 * r3;
+      d3 += h1 * r2;
+      d3 += h2 * r1;
+      d3 += h3 * r0;
+      d3 += h4 * (5 * r9);
+      c = d3 >>> 13;
+      d3 &= 8191;
+      d3 += h5 * (5 * r8);
+      d3 += h6 * (5 * r7);
+      d3 += h7 * (5 * r6);
+      d3 += h8 * (5 * r5);
+      d3 += h9 * (5 * r4);
+      c += d3 >>> 13;
+      d3 &= 8191;
+      let d4 = c;
+      d4 += h0 * r4;
+      d4 += h1 * r3;
+      d4 += h2 * r2;
+      d4 += h3 * r1;
+      d4 += h4 * r0;
+      c = d4 >>> 13;
+      d4 &= 8191;
+      d4 += h5 * (5 * r9);
+      d4 += h6 * (5 * r8);
+      d4 += h7 * (5 * r7);
+      d4 += h8 * (5 * r6);
+      d4 += h9 * (5 * r5);
+      c += d4 >>> 13;
+      d4 &= 8191;
+      let d5 = c;
+      d5 += h0 * r5;
+      d5 += h1 * r4;
+      d5 += h2 * r3;
+      d5 += h3 * r2;
+      d5 += h4 * r1;
+      c = d5 >>> 13;
+      d5 &= 8191;
+      d5 += h5 * r0;
+      d5 += h6 * (5 * r9);
+      d5 += h7 * (5 * r8);
+      d5 += h8 * (5 * r7);
+      d5 += h9 * (5 * r6);
+      c += d5 >>> 13;
+      d5 &= 8191;
+      let d6 = c;
+      d6 += h0 * r6;
+      d6 += h1 * r5;
+      d6 += h2 * r4;
+      d6 += h3 * r3;
+      d6 += h4 * r2;
+      c = d6 >>> 13;
+      d6 &= 8191;
+      d6 += h5 * r1;
+      d6 += h6 * r0;
+      d6 += h7 * (5 * r9);
+      d6 += h8 * (5 * r8);
+      d6 += h9 * (5 * r7);
+      c += d6 >>> 13;
+      d6 &= 8191;
+      let d7 = c;
+      d7 += h0 * r7;
+      d7 += h1 * r6;
+      d7 += h2 * r5;
+      d7 += h3 * r4;
+      d7 += h4 * r3;
+      c = d7 >>> 13;
+      d7 &= 8191;
+      d7 += h5 * r2;
+      d7 += h6 * r1;
+      d7 += h7 * r0;
+      d7 += h8 * (5 * r9);
+      d7 += h9 * (5 * r8);
+      c += d7 >>> 13;
+      d7 &= 8191;
+      let d8 = c;
+      d8 += h0 * r8;
+      d8 += h1 * r7;
+      d8 += h2 * r6;
+      d8 += h3 * r5;
+      d8 += h4 * r4;
+      c = d8 >>> 13;
+      d8 &= 8191;
+      d8 += h5 * r3;
+      d8 += h6 * r2;
+      d8 += h7 * r1;
+      d8 += h8 * r0;
+      d8 += h9 * (5 * r9);
+      c += d8 >>> 13;
+      d8 &= 8191;
+      let d9 = c;
+      d9 += h0 * r9;
+      d9 += h1 * r8;
+      d9 += h2 * r7;
+      d9 += h3 * r6;
+      d9 += h4 * r5;
+      c = d9 >>> 13;
+      d9 &= 8191;
+      d9 += h5 * r4;
+      d9 += h6 * r3;
+      d9 += h7 * r2;
+      d9 += h8 * r1;
+      d9 += h9 * r0;
+      c += d9 >>> 13;
+      d9 &= 8191;
+      c = (c << 2) + c | 0;
+      c = c + d0 | 0;
+      d0 = c & 8191;
+      c = c >>> 13;
+      d1 += c;
+      h0 = d0;
+      h1 = d1;
+      h2 = d2;
+      h3 = d3;
+      h4 = d4;
+      h5 = d5;
+      h6 = d6;
+      h7 = d7;
+      h8 = d8;
+      h9 = d9;
+      mpos += 16;
+      bytes -= 16;
+    }
+    this._h[0] = h0;
+    this._h[1] = h1;
+    this._h[2] = h2;
+    this._h[3] = h3;
+    this._h[4] = h4;
+    this._h[5] = h5;
+    this._h[6] = h6;
+    this._h[7] = h7;
+    this._h[8] = h8;
+    this._h[9] = h9;
+  }
+  finish(mac, macpos = 0) {
+    const g = new Uint16Array(10);
+    let c;
+    let mask;
+    let f;
+    let i;
+    if (this._leftover) {
+      i = this._leftover;
+      this._buffer[i++] = 1;
+      for (;i < 16; i++) {
+        this._buffer[i] = 0;
+      }
+      this._fin = 1;
+      this._blocks(this._buffer, 0, 16);
+    }
+    c = this._h[1] >>> 13;
+    this._h[1] &= 8191;
+    for (i = 2;i < 10; i++) {
+      this._h[i] += c;
+      c = this._h[i] >>> 13;
+      this._h[i] &= 8191;
+    }
+    this._h[0] += c * 5;
+    c = this._h[0] >>> 13;
+    this._h[0] &= 8191;
+    this._h[1] += c;
+    c = this._h[1] >>> 13;
+    this._h[1] &= 8191;
+    this._h[2] += c;
+    g[0] = this._h[0] + 5;
+    c = g[0] >>> 13;
+    g[0] &= 8191;
+    for (i = 1;i < 10; i++) {
+      g[i] = this._h[i] + c;
+      c = g[i] >>> 13;
+      g[i] &= 8191;
+    }
+    g[9] -= 1 << 13;
+    mask = (c ^ 1) - 1;
+    for (i = 0;i < 10; i++) {
+      g[i] &= mask;
+    }
+    mask = ~mask;
+    for (i = 0;i < 10; i++) {
+      this._h[i] = this._h[i] & mask | g[i];
+    }
+    this._h[0] = (this._h[0] | this._h[1] << 13) & 65535;
+    this._h[1] = (this._h[1] >>> 3 | this._h[2] << 10) & 65535;
+    this._h[2] = (this._h[2] >>> 6 | this._h[3] << 7) & 65535;
+    this._h[3] = (this._h[3] >>> 9 | this._h[4] << 4) & 65535;
+    this._h[4] = (this._h[4] >>> 12 | this._h[5] << 1 | this._h[6] << 14) & 65535;
+    this._h[5] = (this._h[6] >>> 2 | this._h[7] << 11) & 65535;
+    this._h[6] = (this._h[7] >>> 5 | this._h[8] << 8) & 65535;
+    this._h[7] = (this._h[8] >>> 8 | this._h[9] << 5) & 65535;
+    f = this._h[0] + this._pad[0];
+    this._h[0] = f & 65535;
+    for (i = 1;i < 8; i++) {
+      f = (this._h[i] + this._pad[i] | 0) + (f >>> 16) | 0;
+      this._h[i] = f & 65535;
+    }
+    mac[macpos + 0] = this._h[0] >>> 0;
+    mac[macpos + 1] = this._h[0] >>> 8;
+    mac[macpos + 2] = this._h[1] >>> 0;
+    mac[macpos + 3] = this._h[1] >>> 8;
+    mac[macpos + 4] = this._h[2] >>> 0;
+    mac[macpos + 5] = this._h[2] >>> 8;
+    mac[macpos + 6] = this._h[3] >>> 0;
+    mac[macpos + 7] = this._h[3] >>> 8;
+    mac[macpos + 8] = this._h[4] >>> 0;
+    mac[macpos + 9] = this._h[4] >>> 8;
+    mac[macpos + 10] = this._h[5] >>> 0;
+    mac[macpos + 11] = this._h[5] >>> 8;
+    mac[macpos + 12] = this._h[6] >>> 0;
+    mac[macpos + 13] = this._h[6] >>> 8;
+    mac[macpos + 14] = this._h[7] >>> 0;
+    mac[macpos + 15] = this._h[7] >>> 8;
+    this._finished = true;
+    return this;
+  }
+  update(m) {
+    let mpos = 0;
+    let bytes = m.length;
+    let want;
+    if (this._leftover) {
+      want = 16 - this._leftover;
+      if (want > bytes) {
+        want = bytes;
+      }
+      for (let i = 0;i < want; i++) {
+        this._buffer[this._leftover + i] = m[mpos + i];
+      }
+      bytes -= want;
+      mpos += want;
+      this._leftover += want;
+      if (this._leftover < 16) {
+        return this;
+      }
+      this._blocks(this._buffer, 0, 16);
+      this._leftover = 0;
+    }
+    if (bytes >= 16) {
+      want = bytes - bytes % 16;
+      this._blocks(m, mpos, want);
+      mpos += want;
+      bytes -= want;
+    }
+    if (bytes) {
+      for (let i = 0;i < bytes; i++) {
+        this._buffer[this._leftover + i] = m[mpos + i];
+      }
+      this._leftover += bytes;
+    }
+    return this;
+  }
+  digest() {
+    if (this._finished) {
+      throw new Error("Poly1305 was finished");
+    }
+    let mac = new Uint8Array(16);
+    this.finish(mac);
+    return mac;
+  }
+  clean() {
+    wipe(this._buffer);
+    wipe(this._r);
+    wipe(this._h);
+    wipe(this._pad);
+    this._leftover = 0;
+    this._fin = 0;
+    this._finished = true;
+    return this;
+  }
+}
+
+// ../../node_modules/@stablelib/chacha20poly1305/lib/chacha20poly1305.js
+var KEY_LENGTH = 32;
+var NONCE_LENGTH = 12;
+var TAG_LENGTH = 16;
+var ZEROS = new Uint8Array(16);
+
+class ChaCha20Poly1305 {
+  nonceLength = NONCE_LENGTH;
+  tagLength = TAG_LENGTH;
+  _key;
+  constructor(key) {
+    if (key.length !== KEY_LENGTH) {
+      throw new Error("ChaCha20Poly1305 needs 32-byte key");
+    }
+    this._key = new Uint8Array(key);
+  }
+  seal(nonce, plaintext, associatedData, dst) {
+    if (nonce.length > 16) {
+      throw new Error("ChaCha20Poly1305: incorrect nonce length");
+    }
+    const counter = new Uint8Array(16);
+    counter.set(nonce, counter.length - nonce.length);
+    const authKey = new Uint8Array(32);
+    stream(this._key, counter, authKey, 4);
+    const resultLength = plaintext.length + this.tagLength;
+    let result;
+    if (dst) {
+      if (dst.length !== resultLength) {
+        throw new Error("ChaCha20Poly1305: incorrect destination length");
+      }
+      result = dst;
+    } else {
+      result = new Uint8Array(resultLength);
+    }
+    streamXOR(this._key, counter, plaintext, result, 4);
+    this._authenticate(result.subarray(result.length - this.tagLength, result.length), authKey, result.subarray(0, result.length - this.tagLength), associatedData);
+    wipe(counter);
+    return result;
+  }
+  open(nonce, sealed, associatedData, dst) {
+    if (nonce.length > 16) {
+      throw new Error("ChaCha20Poly1305: incorrect nonce length");
+    }
+    if (sealed.length < this.tagLength) {
+      return null;
+    }
+    const counter = new Uint8Array(16);
+    counter.set(nonce, counter.length - nonce.length);
+    const authKey = new Uint8Array(32);
+    stream(this._key, counter, authKey, 4);
+    const calculatedTag = new Uint8Array(this.tagLength);
+    this._authenticate(calculatedTag, authKey, sealed.subarray(0, sealed.length - this.tagLength), associatedData);
+    if (!equal(calculatedTag, sealed.subarray(sealed.length - this.tagLength, sealed.length))) {
+      return null;
+    }
+    const resultLength = sealed.length - this.tagLength;
+    let result;
+    if (dst) {
+      if (dst.length !== resultLength) {
+        throw new Error("ChaCha20Poly1305: incorrect destination length");
+      }
+      result = dst;
+    } else {
+      result = new Uint8Array(resultLength);
+    }
+    streamXOR(this._key, counter, sealed.subarray(0, sealed.length - this.tagLength), result, 4);
+    wipe(counter);
+    return result;
+  }
+  clean() {
+    wipe(this._key);
+    return this;
+  }
+  _authenticate(tagOut, authKey, ciphertext, associatedData) {
+    const h = new Poly1305(authKey);
+    if (associatedData) {
+      h.update(associatedData);
+      if (associatedData.length % 16 > 0) {
+        h.update(ZEROS.subarray(associatedData.length % 16));
+      }
+    }
+    h.update(ciphertext);
+    if (ciphertext.length % 16 > 0) {
+      h.update(ZEROS.subarray(ciphertext.length % 16));
+    }
+    const length = new Uint8Array(8);
+    if (associatedData) {
+      writeUint64LE(associatedData.length, length);
+    }
+    h.update(length);
+    writeUint64LE(ciphertext.length, length);
+    h.update(length);
+    const tag = h.digest();
+    for (let i = 0;i < tag.length; i++) {
+      tagOut[i] = tag[i];
+    }
+    h.clean();
+    wipe(tag);
+    wipe(length);
+  }
+}
+
+// src/crypto/chacha20.ts
 var CHACHA20_AUTH_TAG_LENGTH = 16;
 var CHACHA20_NONCE_LENGTH = 12;
-function decrypt(key, nonce, add, ciphertext, authTag) {
+function decrypt(key, nonce, aad, ciphertext, authTag) {
   nonce = padNonce(nonce);
-  const decipher = createDecipher(key, nonce);
-  add && decipher.setAAD(add);
-  decipher.setAuthTag(authTag);
-  const plaintext = decipher._update(ciphertext);
-  decipher._final();
-  return plaintext;
+  const chacha = new ChaCha20Poly1305(key);
+  const sealed = Buffer.concat([ciphertext, authTag]);
+  const plaintext = chacha.open(nonce, sealed, aad ?? undefined);
+  if (!plaintext) {
+    throw new Error("Decryption failed: authentication tag mismatch");
+  }
+  return Buffer.from(plaintext);
 }
 function encrypt(key, nonce, aad, plaintext) {
   nonce = padNonce(nonce);
-  const cipher = createCipher(key, nonce);
-  aad && cipher.setAAD(aad);
-  const ciphertext = cipher._update(plaintext);
-  cipher._final();
-  const authTag = cipher.getAuthTag();
+  const chacha = new ChaCha20Poly1305(key);
+  const sealed = chacha.seal(nonce, plaintext, aad ?? undefined);
+  const ciphertext = Buffer.from(sealed.subarray(0, sealed.length - CHACHA20_AUTH_TAG_LENGTH));
+  const authTag = Buffer.from(sealed.subarray(sealed.length - CHACHA20_AUTH_TAG_LENGTH));
   return {
     ciphertext,
     authTag
@@ -417,6 +1144,7 @@ class Connection extends EventEmitter {
     const wasConnected = this.#state === "connected";
     if (this.#state !== "closing") {
       this.#state = "disconnected";
+      reporter.net(`Connection closed (${hadError ? "with error" : "normally"}).`);
     }
     this.emit("close", hadError);
     if (wasConnected && this.#retryEnabled && hadError) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-common",
     "description": "Common features shared across various apple protocol packages.",
-    "version": "0.0.81",
+    "version": "0.0.83",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -38,8 +38,8 @@
         }
     },
     "dependencies": {
-        "@basmilius/apple-encoding": "0.0.81",
-        "chacha": "^2.1.0",
+        "@basmilius/apple-encoding": "0.0.83",
+        "@stablelib/chacha20poly1305": "^2.0.1",
         "fast-srp-hap": "^2.0.4",
         "node-dns-sd": "^1.0.1",
         "tweetnacl": "^1.0.3",