@jscrypto/classic 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /*!
- * @jscrypto/classic v0.1.0
+ * @jscrypto/classic v0.2.0
  * Copyright 2026 Chen, Yi-Cyuan
  * Released under the MIT license
  */
@@ -135,7 +135,7 @@ var aes = {
   }
 };
 function createAesCipher(key) {
-  if (![16, 24, 32].includes(key.length)) {
+  if (key.length !== 16 && key.length !== 24 && key.length !== 32) {
     throw new Error("AES key must be 128, 192, or 256 bits.");
   }
   return createCryptoJsBlockCipher({
@@ -212,10 +212,10 @@ function createRc4Transform(key, drop = 0) {
       assertNotFinalized(finalized);
       return processInput(input);
     },
-    finalize(input = new Uint8Array()) {
+    finalize(input = new Uint8Array(0)) {
       assertNotFinalized(finalized);
       finalized = true;
-      return input.length === 0 ? new Uint8Array() : processInput(input);
+      return input.length === 0 ? new Uint8Array(0) : processInput(input);
     }
   };
 }
@@ -280,7 +280,7 @@ var tripleDes = {
   }
 };
 function createTripleDesCipher(key) {
-  if (![16, 24].includes(key.length)) {
+  if (key.length !== 16 && key.length !== 24) {
     throw new Error("Triple DES key must be 128 or 192 bits.");
   }
   return createCryptoJsBlockCipher({
@@ -342,13 +342,14 @@ var evpKdf = {
   }
 };
 function deriveEvpKdf(params) {
+  var _a;
   assertPositiveInteger(params.length, "EvpKDF length");
   if (params.iterations !== void 0) {
     assertPositiveInteger(params.iterations, "EvpKDF iterations");
   }
   const options = {
     keySize: params.length / 4,
-    iterations: params.iterations ?? 1
+    iterations: (_a = params.iterations) != null ? _a : 1
   };
   const hasher = getHasher(params.hash);
   if (hasher) {
@@ -371,7 +372,7 @@ function getHasher(hash) {
   return hasher;
 }
 function normalizeHashName(hash) {
-  return hash.replaceAll("-", "").toUpperCase();
+  return hash.replace(/-/g, "").toUpperCase();
 }
 function assertPositiveInteger(value, label) {
   if (!Number.isInteger(value) || value <= 0) {
@@ -415,7 +416,7 @@ function getHasher2(hash) {
   return hasher;
 }
 function normalizeHashName2(hash) {
-  return hash.replaceAll("-", "").toUpperCase();
+  return hash.replace(/-/g, "").toUpperCase();
 }
 function assertPositiveInteger2(value, label) {
   if (!Number.isInteger(value) || value <= 0) {
@@ -452,8 +453,8 @@ function createCbcEncryptor(cipher, iv) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
@@ -471,8 +472,8 @@ function createCbcDecryptor(cipher, iv) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
@@ -526,8 +527,8 @@ function createCfbTransform(cipher, iv, encrypting) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
@@ -565,8 +566,8 @@ function createCtrTransform(cipher, iv) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
@@ -602,8 +603,8 @@ function createEcbEncryptor(cipher) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
@@ -617,8 +618,8 @@ function createEcbDecryptor(cipher) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
@@ -627,32 +628,311 @@ function assertBlockMultiple2(blockSize, input) {
 }
 
 // packages/classic/src/modes/gcm.ts
+var import_core6 = require("@jscrypto/core");
 var gcm = {
   kind: "mode",
   name: "GCM",
   aead: true,
   requiredBlockSize: 16,
   requiresPadding: false,
-  createEncryptor() {
-    throw new Error("GCM mode is not implemented yet.");
+  createEncryptor({ cipher, iv, options }) {
+    return createGcmEncryptor(cipher, getNonce(iv, options), getAad(options), getTagLength(options));
   },
-  createDecryptor() {
-    throw new Error("GCM mode is not implemented yet.");
+  createDecryptor({ cipher, iv, options }) {
+    return createGcmDecryptor(cipher, getNonce(iv, options), getAad(options), getTagLength(options), getTag(options));
   }
 };
+var BLOCK_SIZE = 16;
+var DEFAULT_TAG_LENGTH = 16;
+var R_WORD = 3774873600;
+function createGcmEncryptor(cipher, nonce, aad, tagLength) {
+  assertGcmCipher(cipher);
+  const auth = createGhash(cipher.encryptBlock(new Uint8Array(BLOCK_SIZE)));
+  auth.update(aad);
+  auth.pad();
+  const j0 = createInitialCounter(auth.h, nonce);
+  const tagMask = cipher.encryptBlock(j0);
+  const counter = j0.slice();
+  incrementCounter2(counter);
+  const xor = createCounterXor(cipher, counter);
+  let ciphertextLength = 0;
+  return {
+    process(input) {
+      const ciphertext = xor(input);
+      auth.update(ciphertext);
+      ciphertextLength += ciphertext.length;
+      return ciphertext;
+    },
+    finalize(input = new Uint8Array(0)) {
+      const ciphertext = input.length === 0 ? new Uint8Array(0) : this.process(input);
+      const tag = createTag(auth, tagMask, aad.length, ciphertextLength, tagLength);
+      return (0, import_core6.concatBytes)(ciphertext, tag);
+    }
+  };
+}
+function createGcmDecryptor(cipher, nonce, aad, tagLength, detachedTag) {
+  assertGcmCipher(cipher);
+  const h = cipher.encryptBlock(new Uint8Array(BLOCK_SIZE));
+  const j0 = createInitialCounter(h, nonce);
+  const tagMask = cipher.encryptBlock(j0);
+  let pending = new Uint8Array(0);
+  return {
+    process(input) {
+      pending = (0, import_core6.concatBytes)(pending, input);
+      return new Uint8Array(0);
+    },
+    finalize(input = new Uint8Array(0)) {
+      if (input.length !== 0) {
+        this.process(input);
+      }
+      let ciphertext = pending;
+      let tag = detachedTag;
+      if (!tag) {
+        if (pending.length < tagLength) {
+          throw new Error("GCM ciphertext must include an authentication tag.");
+        }
+        ciphertext = new Uint8Array(pending.subarray(0, pending.length - tagLength));
+        tag = new Uint8Array(pending.subarray(pending.length - tagLength));
+      }
+      const auth = createGhash(h);
+      auth.update(aad);
+      auth.pad();
+      auth.update(ciphertext);
+      const expectedTag = createTag(auth, tagMask, aad.length, ciphertext.length, tagLength);
+      if (!(0, import_core6.equalBytes)(expectedTag, tag)) {
+        throw new Error("GCM authentication failed.");
+      }
+      const counter = j0.slice();
+      incrementCounter2(counter);
+      const plaintext = createCounterXor(cipher, counter)(ciphertext);
+      pending = new Uint8Array(0);
+      return plaintext;
+    }
+  };
+}
+function createGhash(h) {
+  const hValue = blockToWords(h);
+  let state = createZeroWords();
+  let pending = new Uint8Array(0);
+  function updateBlock(block) {
+    state = multiplyGf128(xorWords(state, blockToWords(padBlock(block))), hValue);
+  }
+  return {
+    h,
+    update(input) {
+      const data = (0, import_core6.concatBytes)(pending, input);
+      const processLength = data.length - data.length % BLOCK_SIZE;
+      for (let offset = 0; offset < processLength; offset += BLOCK_SIZE) {
+        updateBlock(data.subarray(offset, offset + BLOCK_SIZE));
+      }
+      pending = data.slice(processLength);
+    },
+    pad() {
+      if (pending.length !== 0) {
+        updateBlock(pending);
+        pending = new Uint8Array(0);
+      }
+    },
+    digest(aadLength, ciphertextLength) {
+      this.pad();
+      updateBlock(createLengthBlock(aadLength, ciphertextLength));
+      return wordsToBlock(state);
+    }
+  };
+}
+function createInitialCounter(h, nonce) {
+  if (nonce.length === 0) {
+    throw new Error("GCM mode requires a nonce.");
+  }
+  if (nonce.length === 12) {
+    const j0 = new Uint8Array(BLOCK_SIZE);
+    j0.set(nonce);
+    j0[15] = 1;
+    return j0;
+  }
+  const auth = createGhash(h);
+  auth.update(nonce);
+  return auth.digest(0, nonce.length);
+}
+function createCounterXor(cipher, counter) {
+  let keystream = new Uint8Array(0);
+  let position = BLOCK_SIZE;
+  return (input) => {
+    const output = new Uint8Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      if (position === BLOCK_SIZE) {
+        keystream = cipher.encryptBlock(counter);
+        incrementCounter2(counter);
+        position = 0;
+      }
+      output[i] = input[i] ^ keystream[position];
+      position++;
+    }
+    return output;
+  };
+}
+function createTag(auth, tagMask, aadLength, ciphertextLength, tagLength) {
+  const tag = auth.digest(aadLength, ciphertextLength);
+  for (let i = 0; i < tag.length; i++) {
+    tag[i] ^= tagMask[i];
+  }
+  return tag.subarray(0, tagLength);
+}
+function createZeroWords() {
+  return [0, 0, 0, 0];
+}
+function multiplyGf128(x, y) {
+  const z = createZeroWords();
+  const v = [y[0], y[1], y[2], y[3]];
+  for (let i = 0; i < 128; i++) {
+    if ((x[i >>> 5] & 2147483648 >>> (i & 31)) !== 0) {
+      xorWordsInPlace(z, v);
+    }
+    shiftRightAndReduce(v);
+  }
+  return z;
+}
+function shiftRightAndReduce(words) {
+  const lsb = words[3] & 1;
+  words[3] = (words[3] >>> 1 | (words[2] & 1) << 31) >>> 0;
+  words[2] = (words[2] >>> 1 | (words[1] & 1) << 31) >>> 0;
+  words[1] = (words[1] >>> 1 | (words[0] & 1) << 31) >>> 0;
+  words[0] >>>= 1;
+  if (lsb) {
+    words[0] = (words[0] ^ R_WORD) >>> 0;
+  }
+}
+function xorWords(left, right) {
+  return [
+    (left[0] ^ right[0]) >>> 0,
+    (left[1] ^ right[1]) >>> 0,
+    (left[2] ^ right[2]) >>> 0,
+    (left[3] ^ right[3]) >>> 0
+  ];
+}
+function xorWordsInPlace(left, right) {
+  left[0] = (left[0] ^ right[0]) >>> 0;
+  left[1] = (left[1] ^ right[1]) >>> 0;
+  left[2] = (left[2] ^ right[2]) >>> 0;
+  left[3] = (left[3] ^ right[3]) >>> 0;
+}
+function incrementCounter2(counter) {
+  const value = (counter[12] << 24 >>> 0 | counter[13] << 16 | counter[14] << 8 | counter[15]) + 1 >>> 0;
+  counter[12] = value >>> 24;
+  counter[13] = value >>> 16;
+  counter[14] = value >>> 8;
+  counter[15] = value;
+}
+function padBlock(input) {
+  if (input.length === BLOCK_SIZE) {
+    return input;
+  }
+  const output = new Uint8Array(BLOCK_SIZE);
+  output.set(input);
+  return output;
+}
+function createLengthBlock(aadLength, ciphertextLength) {
+  const output = new Uint8Array(BLOCK_SIZE);
+  writeBitLength64BE(aadLength, output, 0);
+  writeBitLength64BE(ciphertextLength, output, 8);
+  return output;
+}
+function writeBitLength64BE(byteLength, output, offset) {
+  const high = Math.floor(byteLength / 536870912);
+  const low = byteLength % 536870912 * 8;
+  writeUint32BE(high, output, offset);
+  writeUint32BE(low, output, offset + 4);
+}
+function blockToWords(input) {
+  return [
+    readUint32BE(input, 0),
+    readUint32BE(input, 4),
+    readUint32BE(input, 8),
+    readUint32BE(input, 12)
+  ];
+}
+function wordsToBlock(words) {
+  const output = new Uint8Array(BLOCK_SIZE);
+  writeUint32BE(words[0], output, 0);
+  writeUint32BE(words[1], output, 4);
+  writeUint32BE(words[2], output, 8);
+  writeUint32BE(words[3], output, 12);
+  return output;
+}
+function readUint32BE(input, offset) {
+  return (input[offset] << 24 >>> 0 | input[offset + 1] << 16 | input[offset + 2] << 8 | input[offset + 3]) >>> 0;
+}
+function writeUint32BE(value, output, offset) {
+  output[offset] = value >>> 24;
+  output[offset + 1] = value >>> 16;
+  output[offset + 2] = value >>> 8;
+  output[offset + 3] = value;
+}
+function getNonce(iv, options) {
+  const nonce = getOptions(options).nonce;
+  if (nonce !== void 0) {
+    (0, import_core6.assertBytes)(nonce, "GCM nonce");
+    if (iv !== void 0) {
+      throw new Error("GCM mode accepts either iv or nonce, not both.");
+    }
+    return nonce;
+  }
+  if (!iv) {
+    throw new Error("GCM mode requires an IV/nonce.");
+  }
+  return iv;
+}
+function getAad(options) {
+  const aad = getOptions(options).aad;
+  if (aad === void 0) {
+    return new Uint8Array(0);
+  }
+  (0, import_core6.assertBytes)(aad, "GCM aad");
+  return aad;
+}
+function getTag(options) {
+  const tag = getOptions(options).tag;
+  if (tag === void 0) {
+    return void 0;
+  }
+  (0, import_core6.assertBytes)(tag, "GCM tag");
+  return tag;
+}
+function getTagLength(options) {
+  const tag = getTag(options);
+  if (tag) {
+    return tag.length;
+  }
+  const tagLength = getOptions(options).tagLength;
+  if (tagLength === void 0) {
+    return DEFAULT_TAG_LENGTH;
+  }
+  if (typeof tagLength !== "number" || !Number.isInteger(tagLength) || tagLength < 4 || tagLength > BLOCK_SIZE) {
+    throw new RangeError("GCM tagLength must be an integer between 4 and 16 bytes.");
+  }
+  return tagLength;
+}
+function getOptions(options) {
+  return typeof options === "object" && options !== null ? options : {};
+}
+function assertGcmCipher(cipher) {
+  if (cipher.blockSize !== BLOCK_SIZE) {
+    throw new Error("GCM mode requires a 128-bit block cipher.");
+  }
+}
 
 // packages/classic/src/modes/ofb.ts
-var import_core6 = require("@jscrypto/core");
+var import_core7 = require("@jscrypto/core");
 var ofb = {
   kind: "mode",
   name: "OFB",
   requiresPadding: false,
   createEncryptor({ cipher, iv }) {
-    (0, import_core6.assertIv)(cipher.blockSize, iv, "OFB");
+    (0, import_core7.assertIv)(cipher.blockSize, iv, "OFB");
     return createOfbTransform(cipher, iv);
   },
   createDecryptor({ cipher, iv }) {
-    (0, import_core6.assertIv)(cipher.blockSize, iv, "OFB");
+    (0, import_core7.assertIv)(cipher.blockSize, iv, "OFB");
     return createOfbTransform(cipher, iv);
   }
 };
@@ -674,14 +954,14 @@ function createOfbTransform(cipher, iv) {
       }
       return output;
     },
-    finalize(input = new Uint8Array()) {
-      return input.length === 0 ? new Uint8Array() : this.process(input);
+    finalize(input = new Uint8Array(0)) {
+      return input.length === 0 ? new Uint8Array(0) : this.process(input);
     }
   };
 }
 
 // packages/classic/src/paddings/ansi-x923.ts
-var import_core7 = require("@jscrypto/core");
+var import_core8 = require("@jscrypto/core");
 var ansiX923 = {
   kind: "padding",
   name: "AnsiX923",
@@ -708,17 +988,17 @@ var ansiX923 = {
   }
 };
 function assertBlockSize(blockSize) {
-  (0, import_core7.assertBlockSize)(blockSize, { max: 255 });
+  (0, import_core8.assertBlockSize)(blockSize, { max: 255 });
 }
 function assertPaddedInput(input, blockSize) {
-  (0, import_core7.assertPaddedInput)(input, blockSize, "ANSI X9.23", { max: 255 });
+  (0, import_core8.assertPaddedInput)(input, blockSize, "ANSI X9.23", { max: 255 });
 }
 function getPaddingLength(inputLength, blockSize) {
-  return (0, import_core7.getBlockPaddingLength)(inputLength, blockSize);
+  return (0, import_core8.getBlockPaddingLength)(inputLength, blockSize);
 }
 
 // packages/classic/src/paddings/iso10126.ts
-var import_core8 = require("@jscrypto/core");
+var import_core9 = require("@jscrypto/core");
 var iso10126 = {
   kind: "padding",
   name: "Iso10126",
@@ -741,20 +1021,21 @@ var iso10126 = {
   }
 };
 function assertBlockSize2(blockSize) {
-  (0, import_core8.assertBlockSize)(blockSize, { max: 255 });
+  (0, import_core9.assertBlockSize)(blockSize, { max: 255 });
 }
 function assertPaddedInput2(input, blockSize) {
-  (0, import_core8.assertPaddedInput)(input, blockSize, "ISO 10126", { max: 255 });
+  (0, import_core9.assertPaddedInput)(input, blockSize, "ISO 10126", { max: 255 });
 }
 function getPaddingLength2(inputLength, blockSize) {
-  return (0, import_core8.getBlockPaddingLength)(inputLength, blockSize);
+  return (0, import_core9.getBlockPaddingLength)(inputLength, blockSize);
 }
 function fillRandom(bytes) {
+  var _a;
   if (bytes.length === 0) {
     return;
   }
   const crypto = globalThis;
-  crypto.crypto?.getRandomValues(bytes);
+  (_a = crypto.crypto) == null ? void 0 : _a.getRandomValues(bytes);
   if (bytes.some((byte) => byte !== 0)) {
     return;
   }
@@ -764,7 +1045,7 @@ function fillRandom(bytes) {
 }
 
 // packages/classic/src/paddings/iso97971.ts
-var import_core9 = require("@jscrypto/core");
+var import_core10 = require("@jscrypto/core");
 var iso97971 = {
   kind: "padding",
   name: "Iso97971",
@@ -789,10 +1070,10 @@ var iso97971 = {
   }
 };
 function assertBlockSize3(blockSize) {
-  (0, import_core9.assertBlockSize)(blockSize);
+  (0, import_core10.assertBlockSize)(blockSize);
 }
 function assertPaddedInput3(input, blockSize) {
-  (0, import_core9.assertPaddedInput)(input, blockSize, "ISO/IEC 9797-1");
+  (0, import_core10.assertPaddedInput)(input, blockSize, "ISO/IEC 9797-1");
 }
 function getPaddingLength3(inputLength, blockSize) {
   const remainder = (inputLength + 1) % blockSize;
@@ -800,7 +1081,7 @@ function getPaddingLength3(inputLength, blockSize) {
 }
 
 // packages/classic/src/paddings/none.ts
-var import_core10 = require("@jscrypto/core");
+var import_core11 = require("@jscrypto/core");
 var noPadding = {
   kind: "padding",
   name: "NoPadding",
@@ -814,24 +1095,24 @@ var noPadding = {
   }
 };
 function assertMultiple(input, blockSize) {
-  (0, import_core10.assertBlockMultiple)(input, blockSize, "NoPadding");
+  (0, import_core11.assertBlockMultiple)(input, blockSize, "NoPadding");
 }
 
 // packages/classic/src/paddings/pkcs7.ts
-var import_core11 = require("@jscrypto/core");
+var import_core12 = require("@jscrypto/core");
 var pkcs7 = {
   kind: "padding",
   name: "Pkcs7",
   pad(input, blockSize) {
-    (0, import_core11.assertBlockSize)(blockSize, { max: 255 });
-    const paddingLength = (0, import_core11.getBlockPaddingLength)(input.length, blockSize);
+    (0, import_core12.assertBlockSize)(blockSize, { max: 255 });
+    const paddingLength = (0, import_core12.getBlockPaddingLength)(input.length, blockSize);
     const output = new Uint8Array(input.length + paddingLength);
     output.set(input);
     output.fill(paddingLength, input.length);
     return output;
   },
   unpad(input, blockSize) {
-    (0, import_core11.assertPaddedInput)(input, blockSize, "PKCS#7", { max: 255 });
+    (0, import_core12.assertPaddedInput)(input, blockSize, "PKCS#7", { max: 255 });
     const paddingLength = input[input.length - 1];
     if (paddingLength === 0 || paddingLength > blockSize || paddingLength > input.length) {
       throw new Error("Invalid PKCS#7 padding.");
@@ -871,7 +1152,7 @@ var zeroPadding = {
 };
 
 // packages/classic/src/preset.ts
-var import_core12 = require("@jscrypto/core");
+var import_core13 = require("@jscrypto/core");
 function classicPreset() {
   return {
     kind: "preset",
@@ -903,7 +1184,7 @@ function classicPreset() {
   };
 }
 function createClassicRegistry() {
-  return (0, import_core12.createRegistry)().use(classicPreset());
+  return (0, import_core13.createRegistry)().use(classicPreset());
 }
 var registry = createClassicRegistry();
 // Annotate the CommonJS export names for ESM import in node: