@jscrypto/classic 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * @jscrypto/classic v0.1.0
+ * @jscrypto/classic v0.2.0
  * Copyright 2026 Chen, Yi-Cyuan
  * Released under the MIT license
  */
@@ -65,7 +65,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({
@@ -142,10 +142,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);
     }
   };
 }
@@ -210,7 +210,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({
@@ -272,13 +272,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) {
@@ -301,7 +302,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) {
@@ -345,7 +346,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) {
@@ -386,8 +387,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);
     }
   };
 }
@@ -405,8 +406,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);
     }
   };
 }
@@ -460,8 +461,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);
     }
   };
 }
@@ -499,8 +500,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);
     }
   };
 }
@@ -536,8 +537,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);
     }
   };
 }
@@ -551,8 +552,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);
     }
   };
 }
@@ -561,19 +562,302 @@ function assertBlockMultiple2(blockSize, input) {
 }
 
 // packages/classic/src/modes/gcm.ts
+import {
+  assertBytes,
+  concatBytes as concatBytes2,
+  equalBytes as equalBytes2
+} from "@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 concatBytes2(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 = concatBytes2(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 (!equalBytes2(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 = concatBytes2(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) {
+    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);
+  }
+  assertBytes(aad, "GCM aad");
+  return aad;
+}
+function getTag(options) {
+  const tag = getOptions(options).tag;
+  if (tag === void 0) {
+    return void 0;
+  }
+  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
 import { assertIv as assertIv4 } from "@jscrypto/core";
@@ -608,8 +892,8 @@ 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);
     }
   };
 }
@@ -692,11 +976,12 @@ function getPaddingLength2(inputLength, blockSize) {
   return getBlockPaddingLength2(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;
   }