@bitgo/sdk-api 2.3.1 → 2.4.0

package/dist/src/decryptV1.d.ts

@@ -0,0 +1,60 @@
+import { createDecipheriv, pbkdf2 } from 'crypto';
+import * as t from 'io-ts';
+/**
+ * Minimal shape the decrypt path needs from a crypto module. Both `node:crypto`
+ * and `crypto-browserify` satisfy this. Passing this in from tests lets the
+ * browser-shim test suite exercise the real decrypt code instead of a copy.
+ */
+export interface CryptoModule {
+    pbkdf2: typeof pbkdf2;
+    createDecipheriv: typeof createDecipheriv;
+}
+/**
+ * Upper bound on PBKDF2 iterations accepted from a v1 envelope. BitGo-produced
+ * v1 envelopes use 10,000; this cap is 10x that. Envelope validation enforces
+ * it up front before any KDF work runs.
+ */
+export declare const V1_MAX_ITER = 100000;
+/**
+ * io-ts codec for a v1 (SJCL) envelope.
+ *
+ * Enforces the shape and the `iter` cap up front, before any KDF work runs.
+ */
+declare const V1EnvelopeCodec: t.IntersectionC<[t.TypeC<{
+    v: t.LiteralC<1>;
+    iter: t.Type<number, number, unknown>;
+    ks: t.UnionC<[t.LiteralC<128>, t.LiteralC<256>]>;
+    ts: t.UnionC<[t.LiteralC<64>, t.LiteralC<96>, t.LiteralC<128>]>;
+    mode: t.LiteralC<"ccm">;
+    cipher: t.LiteralC<"aes">;
+    salt: t.Type<string, string, unknown>;
+    iv: t.Type<string, string, unknown>;
+    ct: t.Type<string, string, unknown>;
+}>, t.PartialC<{
+    adata: t.StringC;
+}>]>;
+export type V1Envelope = t.TypeOf<typeof V1EnvelopeCodec>;
+export declare function parseV1Envelope(ciphertext: string): V1Envelope;
+/**
+ * Decrypt a parsed v1 envelope given a crypto module.
+ *
+ * v1 = PBKDF2-SHA256(password, salt, iter, keyLen) then AES-CCM(key, nonce, ct||tag).
+ * Byte-for-byte compatible with `sjcl.decrypt` output for the same envelope.
+ *
+ * Exported so tests can inject `crypto-browserify` and exercise the exact
+ * runtime path the webpack browser bundle produces, without duplicating the
+ * decrypt logic.
+ */
+export declare function decryptV1WithCrypto(password: string, ciphertext: string, crypto: CryptoModule): Promise<string>;
+/**
+ * Decrypt a v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope.
+ *
+ * Runs the same `node:crypto` code on server and browser. The BitGoJS webpack
+ * config already maps `crypto` -> `crypto-browserify`, whose `aes-256-ccm` and
+ * `pbkdf2` implementations are byte-compatible with Node's native ones and
+ * with SJCL's envelope format. Parity is guarded by tests in
+ * `test/unit/decryptV1.browser.ts`.
+ */
+export declare function decryptV1(password: string, ciphertext: string): Promise<string>;
+export {};
+//# sourceMappingURL=decryptV1.d.ts.map

package/dist/src/decryptV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decryptV1.d.ts","sourceRoot":"","sources":["../../src/decryptV1.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAG3B;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;CAC3C;AAID;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAU,CAAC;AAEnC;;;;GAIG;AACH,QAAA,MAAM,eAAe;;;;;;;;;;;;IAenB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAQ9D;AAeD;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBrH;AAED;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAErF"}

package/dist/src/decryptV1.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V1_MAX_ITER = void 0;
+exports.parseV1Envelope = parseV1Envelope;
+exports.decryptV1WithCrypto = decryptV1WithCrypto;
+exports.decryptV1 = decryptV1;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const crypto_1 = require("crypto");
+const t = __importStar(require("io-ts"));
+const util_1 = require("util");
+const defaultCrypto = { pbkdf2: crypto_1.pbkdf2, createDecipheriv: crypto_1.createDecipheriv };
+/**
+ * Upper bound on PBKDF2 iterations accepted from a v1 envelope. BitGo-produced
+ * v1 envelopes use 10,000; this cap is 10x that. Envelope validation enforces
+ * it up front before any KDF work runs.
+ */
+exports.V1_MAX_ITER = 100000;
+/**
+ * io-ts codec for a v1 (SJCL) envelope.
+ *
+ * Enforces the shape and the `iter` cap up front, before any KDF work runs.
+ */
+const V1EnvelopeCodec = t.intersection([
+    t.type({
+        v: t.literal(1),
+        iter: (0, sdk_core_1.boundedInt)(1, exports.V1_MAX_ITER, 'iter'),
+        ks: t.union([t.literal(128), t.literal(256)]),
+        ts: t.union([t.literal(64), t.literal(96), t.literal(128)]),
+        mode: t.literal('ccm'),
+        cipher: t.literal('aes'),
+        salt: sdk_core_1.base64String,
+        iv: sdk_core_1.base64String,
+        ct: sdk_core_1.base64String,
+    }),
+    t.partial({
+        adata: t.string,
+    }),
+]);
+function parseV1Envelope(ciphertext) {
+    let parsed;
+    try {
+        parsed = JSON.parse(ciphertext);
+    }
+    catch {
+        throw new Error('v1 decrypt: invalid JSON envelope');
+    }
+    return (0, sdk_core_1.decodeWithCodec)(V1EnvelopeCodec, parsed, 'v1 decrypt: invalid envelope');
+}
+/**
+ * CCM length field size L, in bytes, chosen to encode the plaintext length.
+ *
+ * SJCL picks the smallest L in [2, 4) that can represent the plaintext length,
+ * then derives the nonce length as (15 - L). We mirror that so Node's CCM
+ * uses the same nonce framing as the SJCL encoder produced.
+ */
+function ccmNonceLength(plaintextLen) {
+    let L = 2;
+    while (L < 4 && plaintextLen >= Math.pow(2, 8 * L))
+        L++;
+    return 15 - L;
+}
+/**
+ * Decrypt a parsed v1 envelope given a crypto module.
+ *
+ * v1 = PBKDF2-SHA256(password, salt, iter, keyLen) then AES-CCM(key, nonce, ct||tag).
+ * Byte-for-byte compatible with `sjcl.decrypt` output for the same envelope.
+ *
+ * Exported so tests can inject `crypto-browserify` and exercise the exact
+ * runtime path the webpack browser bundle produces, without duplicating the
+ * decrypt logic.
+ */
+async function decryptV1WithCrypto(password, ciphertext, crypto) {
+    const env = parseV1Envelope(ciphertext);
+    const salt = Buffer.from(env.salt, 'base64');
+    const ivFull = Buffer.from(env.iv, 'base64');
+    const full = Buffer.from(env.ct, 'base64');
+    const tagBytes = env.ts / 8;
+    if (full.length < tagBytes)
+        throw new Error('v1 decrypt: ciphertext shorter than tag');
+    const cipher = full.subarray(0, full.length - tagBytes);
+    const authTag = full.subarray(full.length - tagBytes);
+    const nonceLen = ccmNonceLength(cipher.length);
+    if (ivFull.length < nonceLen)
+        throw new Error('v1 decrypt: iv shorter than nonce');
+    const iv = ivFull.subarray(0, nonceLen);
+    const keyBytes = env.ks / 8;
+    const key = await (0, util_1.promisify)(crypto.pbkdf2)(password, salt, env.iter, keyBytes, 'sha256');
+    const decipher = crypto.createDecipheriv(`aes-${env.ks}-ccm`, key, iv, { authTagLength: tagBytes });
+    decipher.setAuthTag(authTag);
+    const aad = env.adata ? Buffer.from(env.adata, 'utf8') : Buffer.alloc(0);
+    decipher.setAAD(aad, { plaintextLength: cipher.length });
+    const pt = Buffer.concat([decipher.update(cipher), decipher.final()]);
+    return pt.toString('utf8');
+}
+/**
+ * Decrypt a v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope.
+ *
+ * Runs the same `node:crypto` code on server and browser. The BitGoJS webpack
+ * config already maps `crypto` -> `crypto-browserify`, whose `aes-256-ccm` and
+ * `pbkdf2` implementations are byte-compatible with Node's native ones and
+ * with SJCL's envelope format. Parity is guarded by tests in
+ * `test/unit/decryptV1.browser.ts`.
+ */
+async function decryptV1(password, ciphertext) {
+    return decryptV1WithCrypto(password, ciphertext, defaultCrypto);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decryptV1.js","sourceRoot":"","sources":["../../src/decryptV1.ts"],"names":[],"mappings":"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","sourcesContent":["import { base64String, boundedInt, decodeWithCodec } from '@bitgo/sdk-core';\nimport { createDecipheriv, pbkdf2 } from 'crypto';\nimport * as t from 'io-ts';\nimport { promisify } from 'util';\n\n/**\n * Minimal shape the decrypt path needs from a crypto module. Both `node:crypto`\n * and `crypto-browserify` satisfy this. Passing this in from tests lets the\n * browser-shim test suite exercise the real decrypt code instead of a copy.\n */\nexport interface CryptoModule {\n  pbkdf2: typeof pbkdf2;\n  createDecipheriv: typeof createDecipheriv;\n}\n\nconst defaultCrypto: CryptoModule = { pbkdf2, createDecipheriv };\n\n/**\n * Upper bound on PBKDF2 iterations accepted from a v1 envelope. BitGo-produced\n * v1 envelopes use 10,000; this cap is 10x that. Envelope validation enforces\n * it up front before any KDF work runs.\n */\nexport const V1_MAX_ITER = 100_000;\n\n/**\n * io-ts codec for a v1 (SJCL) envelope.\n *\n * Enforces the shape and the `iter` cap up front, before any KDF work runs.\n */\nconst V1EnvelopeCodec = t.intersection([\n  t.type({\n    v: t.literal(1),\n    iter: boundedInt(1, V1_MAX_ITER, 'iter'),\n    ks: t.union([t.literal(128), t.literal(256)]),\n    ts: t.union([t.literal(64), t.literal(96), t.literal(128)]),\n    mode: t.literal('ccm'),\n    cipher: t.literal('aes'),\n    salt: base64String,\n    iv: base64String,\n    ct: base64String,\n  }),\n  t.partial({\n    adata: t.string,\n  }),\n]);\n\nexport type V1Envelope = t.TypeOf<typeof V1EnvelopeCodec>;\n\nexport function parseV1Envelope(ciphertext: string): V1Envelope {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(ciphertext);\n  } catch {\n    throw new Error('v1 decrypt: invalid JSON envelope');\n  }\n  return decodeWithCodec(V1EnvelopeCodec, parsed, 'v1 decrypt: invalid envelope');\n}\n\n/**\n * CCM length field size L, in bytes, chosen to encode the plaintext length.\n *\n * SJCL picks the smallest L in [2, 4) that can represent the plaintext length,\n * then derives the nonce length as (15 - L). We mirror that so Node's CCM\n * uses the same nonce framing as the SJCL encoder produced.\n */\nfunction ccmNonceLength(plaintextLen: number): number {\n  let L = 2;\n  while (L < 4 && plaintextLen >= Math.pow(2, 8 * L)) L++;\n  return 15 - L;\n}\n\n/**\n * Decrypt a parsed v1 envelope given a crypto module.\n *\n * v1 = PBKDF2-SHA256(password, salt, iter, keyLen) then AES-CCM(key, nonce, ct||tag).\n * Byte-for-byte compatible with `sjcl.decrypt` output for the same envelope.\n *\n * Exported so tests can inject `crypto-browserify` and exercise the exact\n * runtime path the webpack browser bundle produces, without duplicating the\n * decrypt logic.\n */\nexport async function decryptV1WithCrypto(password: string, ciphertext: string, crypto: CryptoModule): Promise<string> {\n  const env = parseV1Envelope(ciphertext);\n  const salt = Buffer.from(env.salt, 'base64');\n  const ivFull = Buffer.from(env.iv, 'base64');\n  const full = Buffer.from(env.ct, 'base64');\n  const tagBytes = env.ts / 8;\n  if (full.length < tagBytes) throw new Error('v1 decrypt: ciphertext shorter than tag');\n\n  const cipher = full.subarray(0, full.length - tagBytes);\n  const authTag = full.subarray(full.length - tagBytes);\n  const nonceLen = ccmNonceLength(cipher.length);\n  if (ivFull.length < nonceLen) throw new Error('v1 decrypt: iv shorter than nonce');\n  const iv = ivFull.subarray(0, nonceLen);\n\n  const keyBytes = env.ks / 8;\n  const key: Buffer = await promisify(crypto.pbkdf2)(password, salt, env.iter, keyBytes, 'sha256');\n\n  const decipher = crypto.createDecipheriv(`aes-${env.ks}-ccm`, key, iv, { authTagLength: tagBytes });\n  decipher.setAuthTag(authTag);\n  const aad = env.adata ? Buffer.from(env.adata, 'utf8') : Buffer.alloc(0);\n  decipher.setAAD(aad, { plaintextLength: cipher.length });\n\n  const pt = Buffer.concat([decipher.update(cipher), decipher.final()]);\n  return pt.toString('utf8');\n}\n\n/**\n * Decrypt a v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope.\n *\n * Runs the same `node:crypto` code on server and browser. The BitGoJS webpack\n * config already maps `crypto` -> `crypto-browserify`, whose `aes-256-ccm` and\n * `pbkdf2` implementations are byte-compatible with Node's native ones and\n * with SJCL's envelope format. Parity is guarded by tests in\n * `test/unit/decryptV1.browser.ts`.\n */\nexport async function decryptV1(password: string, ciphertext: string): Promise<string> {\n  return decryptV1WithCrypto(password, ciphertext, defaultCrypto);\n}\n"]}

package/dist/src/encrypt.d.ts

@@ -18,7 +18,26 @@ export declare function encrypt(password: string, plaintext: string, options?: {
     encryptionVersion?: 1 | 2;
 }): Promise<string>;
 /**
- * Auto-detect v1 (SJCL) or v2 (Argon2id + AES-256-GCM) from the envelope `v` field and decrypt.
+ * v1 decrypt with an SJCL safety net.
+ *
+ * Design intent during rollout: zero false negatives. Any native failure
+ * (envelope shape our stricter codec rejects, framing bug, unsupported
+ * algorithm, auth-tag mismatch, etc.) falls through to `sjcl.decrypt` so the
+ * caller is never blocked. The only exception is an iter-cap violation,
+ * which is rethrown to preserve DoS protection.
+ *
+ * The console.warn only fires when native fails AND SJCL succeeds -- i.e.
+ * when the two engines disagree, which is the only signal worth
+ * investigating. Wrong password fails both engines silently and surfaces
+ * SJCL's auth error (mapped upstream to "incorrect password").
+ *
+ * `native` defaults to the module's `decryptV1` but is exposed as a parameter
+ * so tests can inject a throwing version to exercise the fallback path.
+ */
+export declare function decryptV1WithFallback(password: string, ciphertext: string, native?: (pw: string, ct: string) => Promise<string>): Promise<string>;
+/**
+ * Auto-detect v1 (PBKDF2-SHA256 + AES-CCM) or v2 (Argon2id + AES-256-GCM)
+ * from the envelope `v` field and decrypt.
  */
 export declare function decrypt(password: string, ciphertext: string): Promise<string>;
 //# sourceMappingURL=encrypt.d.ts.map

package/dist/src/encrypt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../src/encrypt.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,MAAM,CAKjE;AAiCD;;;;;GAKG;AACH,wBAAsB,OAAO,CAC3B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;CAAE,GAClF,OAAO,CAAC,MAAM,CAAC,CAKjB;AAUD;;GAEG;AACH,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBnF"}
+{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../src/encrypt.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,MAAM,CAKjE;AAiCD;;;;;GAKG;AACH,wBAAsB,OAAO,CAC3B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;CAAE,GAClF,OAAO,CAAC,MAAM,CAAC,CAKjB;AAaD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAa,GAC9D,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBnF"}

package/dist/src/encrypt.js

@@ -35,9 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bytesToWord = bytesToWord;
 exports.encrypt = encrypt;
+exports.decryptV1WithFallback = decryptV1WithFallback;
 exports.decrypt = decrypt;
 const sjcl = __importStar(require("@bitgo/sjcl"));
 const crypto_1 = require("crypto");
+const decryptV1_1 = require("./decryptV1");
 const encryptV2_1 = require("./encryptV2");
 /**
  * convert a 4 element Uint8Array to a 4 byte Number
@@ -92,14 +94,58 @@ async function encrypt(password, plaintext, options) {
     return (0, encryptV2_1.encryptV2)(password, plaintext, { adata: options?.adata });
 }
 /**
- * Internal v1 (SJCL) decrypt helper. Not part of the public surface: callers use
- * the auto-detecting `decrypt` instead.
+ * Iter-cap violations are the only error we refuse to fall back on: SJCL has
+ * no upper bound on `iter`, so falling through to it would let a hostile
+ * envelope burn CPU running an inflated PBKDF2. Everything else -- codec
+ * rejection of a shape SJCL would accept, native crypto bug, auth-tag
+ * mismatch -- is safe to fall through to SJCL.
  */
-function decryptV1(password, ciphertext) {
-    return sjcl.decrypt(password, ciphertext);
+function isIterCapViolation(err) {
+    return err instanceof Error && /iter:\s*expected integer|iter out of range/i.test(err.message);
 }
 /**
- * Auto-detect v1 (SJCL) or v2 (Argon2id + AES-256-GCM) from the envelope `v` field and decrypt.
+ * v1 decrypt with an SJCL safety net.
+ *
+ * Design intent during rollout: zero false negatives. Any native failure
+ * (envelope shape our stricter codec rejects, framing bug, unsupported
+ * algorithm, auth-tag mismatch, etc.) falls through to `sjcl.decrypt` so the
+ * caller is never blocked. The only exception is an iter-cap violation,
+ * which is rethrown to preserve DoS protection.
+ *
+ * The console.warn only fires when native fails AND SJCL succeeds -- i.e.
+ * when the two engines disagree, which is the only signal worth
+ * investigating. Wrong password fails both engines silently and surfaces
+ * SJCL's auth error (mapped upstream to "incorrect password").
+ *
+ * `native` defaults to the module's `decryptV1` but is exposed as a parameter
+ * so tests can inject a throwing version to exercise the fallback path.
+ */
+async function decryptV1WithFallback(password, ciphertext, native = decryptV1_1.decryptV1) {
+    try {
+        return await native(password, ciphertext);
+    }
+    catch (nativeErr) {
+        if (isIterCapViolation(nativeErr))
+            throw nativeErr;
+        let result;
+        try {
+            result = sjcl.decrypt(password, ciphertext);
+        }
+        catch (sjclErr) {
+            // Both engines rejected -- almost certainly a real auth failure.
+            // Rethrow SJCL's error so BitGoAPI.decrypt maps it to "incorrect password".
+            throw sjclErr;
+        }
+        // Native failed but SJCL succeeded -- real signal, log for the operator.
+        const message = nativeErr instanceof Error ? nativeErr.message : String(nativeErr);
+        // eslint-disable-next-line no-console
+        console.warn('[bitgo-sdk] v1 native decrypt failed; SJCL fallback succeeded:', message);
+        return result;
+    }
+}
+/**
+ * Auto-detect v1 (PBKDF2-SHA256 + AES-CCM) or v2 (Argon2id + AES-256-GCM)
+ * from the envelope `v` field and decrypt.
  */
 async function decrypt(password, ciphertext) {
     let envelopeVersion;
@@ -117,6 +163,6 @@ async function decrypt(password, ciphertext) {
     if (envelopeVersion !== undefined && envelopeVersion !== 1) {
         throw new Error(`decrypt: unknown envelope version ${envelopeVersion}`);
     }
-    return decryptV1(password, ciphertext);
+    return decryptV1WithFallback(password, ciphertext);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encrypt.js","sourceRoot":"","sources":["../../src/encrypt.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sjcl from '@bitgo/sjcl';\nimport { randomBytes } from 'crypto';\n\nimport { decryptV1 } from './decryptV1';\nimport { decryptV2, encryptV2 } from './encryptV2';\n\n/**\n * convert a 4 element Uint8Array to a 4 byte Number\n *\n * @param bytes\n * @return 4 byte number\n */\nexport function bytesToWord(bytes?: Uint8Array | number[]): number {\n  if (!(bytes instanceof Uint8Array) || bytes.length !== 4) {\n    throw new Error('bytes must be a Uint8Array with length 4');\n  }\n  return bytes.reduce((num, byte) => num * 0x100 + byte, 0);\n}\n\n/**\n * Internal v1 (SJCL PBKDF2-SHA256 + AES-256-CCM) encrypt helper.\n *\n * Not exported as part of the public encrypt/decrypt surface: callers must not use\n * this directly. v1 output is requested via `encrypt(..., { encryptionVersion: 1 })`.\n */\nfunction encryptV1(\n  password: string,\n  plaintext: string,\n  options?: { salt?: Buffer; iv?: Buffer; adata?: string }\n): string {\n  const salt = options?.salt || randomBytes(8);\n  if (salt.length !== 8) throw new Error('salt must be 8 bytes');\n  const iv = options?.iv || randomBytes(16);\n  if (iv.length !== 16) throw new Error('iv must be 16 bytes');\n\n  const encryptOptions: { iter: number; ks: number; salt: number[]; iv: number[]; adata?: string } = {\n    iter: 10000,\n    ks: 256,\n    salt: [bytesToWord(salt.slice(0, 4)), bytesToWord(salt.slice(4))],\n    iv: [\n      bytesToWord(iv.slice(0, 4)),\n      bytesToWord(iv.slice(4, 8)),\n      bytesToWord(iv.slice(8, 12)),\n      bytesToWord(iv.slice(12, 16)),\n    ],\n  };\n  if (options?.adata) encryptOptions.adata = options.adata;\n  return sjcl.encrypt(password, plaintext, encryptOptions);\n}\n\n/**\n * Encrypt `plaintext` with `password`. Defaults to v2 (Argon2id + AES-256-GCM).\n *\n * Pass `encryptionVersion: 1` to produce a legacy v1 (SJCL) envelope; this is the\n * only supported way to request v1 encryption.\n */\nexport async function encrypt(\n  password: string,\n  plaintext: string,\n  options?: { salt?: Buffer; iv?: Buffer; adata?: string; encryptionVersion?: 1 | 2 }\n): Promise<string> {\n  if (options?.encryptionVersion === 1) {\n    return encryptV1(password, plaintext, options);\n  }\n  return encryptV2(password, plaintext, { adata: options?.adata });\n}\n\n/**\n * Iter-cap violations are the only error we refuse to fall back on: SJCL has\n * no upper bound on `iter`, so falling through to it would let a hostile\n * envelope burn CPU running an inflated PBKDF2. Everything else -- codec\n * rejection of a shape SJCL would accept, native crypto bug, auth-tag\n * mismatch -- is safe to fall through to SJCL.\n */\nfunction isIterCapViolation(err: unknown): boolean {\n  return err instanceof Error && /iter:\\s*expected integer|iter out of range/i.test(err.message);\n}\n\n/**\n * v1 decrypt with an SJCL safety net.\n *\n * Design intent during rollout: zero false negatives. Any native failure\n * (envelope shape our stricter codec rejects, framing bug, unsupported\n * algorithm, auth-tag mismatch, etc.) falls through to `sjcl.decrypt` so the\n * caller is never blocked. The only exception is an iter-cap violation,\n * which is rethrown to preserve DoS protection.\n *\n * The console.warn only fires when native fails AND SJCL succeeds -- i.e.\n * when the two engines disagree, which is the only signal worth\n * investigating. Wrong password fails both engines silently and surfaces\n * SJCL's auth error (mapped upstream to \"incorrect password\").\n *\n * `native` defaults to the module's `decryptV1` but is exposed as a parameter\n * so tests can inject a throwing version to exercise the fallback path.\n */\nexport async function decryptV1WithFallback(\n  password: string,\n  ciphertext: string,\n  native: (pw: string, ct: string) => Promise<string> = decryptV1\n): Promise<string> {\n  try {\n    return await native(password, ciphertext);\n  } catch (nativeErr) {\n    if (isIterCapViolation(nativeErr)) throw nativeErr;\n    let result: string;\n    try {\n      result = sjcl.decrypt(password, ciphertext);\n    } catch (sjclErr) {\n      // Both engines rejected -- almost certainly a real auth failure.\n      // Rethrow SJCL's error so BitGoAPI.decrypt maps it to \"incorrect password\".\n      throw sjclErr;\n    }\n    // Native failed but SJCL succeeded -- real signal, log for the operator.\n    const message = nativeErr instanceof Error ? nativeErr.message : String(nativeErr);\n    // eslint-disable-next-line no-console\n    console.warn('[bitgo-sdk] v1 native decrypt failed; SJCL fallback succeeded:', message);\n    return result;\n  }\n}\n\n/**\n * Auto-detect v1 (PBKDF2-SHA256 + AES-CCM) or v2 (Argon2id + AES-256-GCM)\n * from the envelope `v` field and decrypt.\n */\nexport async function decrypt(password: string, ciphertext: string): Promise<string> {\n  let envelopeVersion: number | undefined;\n  try {\n    const envelope = JSON.parse(ciphertext);\n    envelopeVersion = envelope.v;\n  } catch {\n    throw new Error('decrypt: ciphertext is not valid JSON');\n  }\n  if (envelopeVersion === 2) {\n    // Do not catch: wrong password on v2 must not silently fall through to v1.\n    return decryptV2(password, ciphertext);\n  }\n  if (envelopeVersion !== undefined && envelopeVersion !== 1) {\n    throw new Error(`decrypt: unknown envelope version ${envelopeVersion}`);\n  }\n  return decryptV1WithFallback(password, ciphertext);\n}\n"]}

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api';
 export * from './bitgoAPI';
+export * from './decryptV1';
 export * from './encrypt';
 export * from './encryptionSession';
 export * from './encryptV2';

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/src/index.js

@@ -16,9 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api"), exports);
 __exportStar(require("./bitgoAPI"), exports);
+__exportStar(require("./decryptV1"), exports);
 __exportStar(require("./encrypt"), exports);
 __exportStar(require("./encryptionSession"), exports);
 __exportStar(require("./encryptV2"), exports);
 __exportStar(require("./util"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQjtBQUN0Qiw2Q0FBMkI7QUFDM0IsNENBQTBCO0FBQzFCLHNEQUFvQztBQUNwQyw4Q0FBNEI7QUFDNUIseUNBQXVCO0FBQ3ZCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vYml0Z29BUEknO1xuZXhwb3J0ICogZnJvbSAnLi9lbmNyeXB0JztcbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdGlvblNlc3Npb24nO1xuZXhwb3J0ICogZnJvbSAnLi9lbmNyeXB0VjInO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQjtBQUN0Qiw2Q0FBMkI7QUFDM0IsOENBQTRCO0FBQzVCLDRDQUEwQjtBQUMxQixzREFBb0M7QUFDcEMsOENBQTRCO0FBQzVCLHlDQUF1QjtBQUN2QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FwaSc7XG5leHBvcnQgKiBmcm9tICcuL2JpdGdvQVBJJztcbmV4cG9ydCAqIGZyb20gJy4vZGVjcnlwdFYxJztcbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdCc7XG5leHBvcnQgKiBmcm9tICcuL2VuY3J5cHRpb25TZXNzaW9uJztcbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdFYyJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/test/unit/decryptV1.browser.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decryptV1.browser.d.ts.map

package/dist/test/unit/decryptV1.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decryptV1.browser.d.ts","sourceRoot":"","sources":["../../../test/unit/decryptV1.browser.ts"],"names":[],"mappings":""}

package/dist/test/unit/decryptV1.browser.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sjcl = __importStar(require("@bitgo/sjcl"));
+const assert_1 = __importDefault(require("assert"));
+const src_1 = require("../../src");
+const keycard_1 = require("./fixtures/keycard");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const browserCrypto = require('crypto-browserify');
+/**
+ * sjcl.encrypt's typings require salt/iv, but the runtime picks them from
+ * sjcl.random when omitted. Feed real random words so the call type-checks
+ * without an `as` cast.
+ */
+function sjclEncrypt(password, plaintext, params) {
+    const salt = sjcl.random.randomWords(2);
+    const iv = sjcl.random.randomWords(4);
+    return sjcl.encrypt(password, plaintext, { ...params, salt, iv });
+}
+/**
+ * Exercises the real `decryptV1WithCrypto` code path with `crypto-browserify`
+ * injected as the crypto module. This is exactly what webpack bundles for the
+ * browser (its `crypto` shim), so a green test here proves the browser build
+ * stays byte-compatible with SJCL-produced envelopes and the Node path.
+ */
+function decryptV1Browser(password, ciphertext) {
+    return (0, src_1.decryptV1WithCrypto)(password, ciphertext, browserCrypto);
+}
+describe('decryptV1 browser path (crypto-browserify shim)', () => {
+    const password = 'myPassword';
+    const plaintext = 'Hello, Browser!';
+    it('produces the same plaintext as sjcl.decrypt', async () => {
+        const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });
+        assert_1.default.strictEqual(await decryptV1Browser(password, ciphertext), sjcl.decrypt(password, ciphertext));
+    });
+    it('handles adata (AAD)', async () => {
+        const ciphertext = sjclEncrypt(password, plaintext, {
+            iter: 10000,
+            ks: 256,
+            ts: 64,
+            mode: 'ccm',
+            adata: 'ctx-A',
+        });
+        assert_1.default.strictEqual(await decryptV1Browser(password, ciphertext), plaintext);
+    });
+    it('handles UTF-8 password + plaintext', async () => {
+        const utf8Password = 'pässwörd中文🔐';
+        const utf8Plaintext = 'passphrase: 秘密キー ☃🔑';
+        const ciphertext = sjclEncrypt(utf8Password, utf8Plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });
+        assert_1.default.strictEqual(await decryptV1Browser(utf8Password, ciphertext), utf8Plaintext);
+    });
+    it('handles large plaintext (>64 KiB, forces L=3 nonce framing)', async () => {
+        const large = 'x'.repeat(70000);
+        const ciphertext = sjclEncrypt(password, large, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });
+        assert_1.default.strictEqual(await decryptV1Browser(password, ciphertext), large);
+    });
+    it('handles aes-128 envelopes', async () => {
+        const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 128, ts: 64, mode: 'ccm' });
+        assert_1.default.strictEqual(await decryptV1Browser(password, ciphertext), plaintext);
+    });
+    it('handles 128-bit tag envelopes', async () => {
+        const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 128, mode: 'ccm' });
+        assert_1.default.strictEqual(await decryptV1Browser(password, ciphertext), plaintext);
+    });
+    it('rejects wrong password', async () => {
+        const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });
+        await assert_1.default.rejects(() => decryptV1Browser('wrongPassword', ciphertext));
+    });
+    it('rejects envelope with iter above cap before running PBKDF2', async () => {
+        const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });
+        const envelope = JSON.parse(ciphertext);
+        envelope.iter = src_1.V1_MAX_ITER + 1;
+        const start = Date.now();
+        await assert_1.default.rejects(() => decryptV1Browser(password, JSON.stringify(envelope)), /iter/);
+        assert_1.default.ok(Date.now() - start < 100, 'must reject before any KDF work');
+    });
+    it('parity across 50 randomised inputs', async () => {
+        const { randomBytes } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        for (let i = 0; i < 50; i++) {
+            const pw = randomBytes(16).toString('hex');
+            const pt = randomBytes(1 + Math.floor(Math.random() * 500)).toString('base64');
+            const ciphertext = sjclEncrypt(pw, pt, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });
+            assert_1.default.strictEqual(await decryptV1Browser(pw, ciphertext), pt, `iteration ${i}`);
+        }
+    });
+    it('Box A + Box B: shim decrypt matches SJCL byte-for-byte', async () => {
+        for (const [label, ct] of [
+            ['A', keycard_1.KEYCARD_BOX_A],
+            ['B', keycard_1.KEYCARD_BOX_B],
+        ]) {
+            const sjclResult = sjcl.decrypt(keycard_1.KEYCARD_PASSWORD, ct);
+            const shimResult = await decryptV1Browser(keycard_1.KEYCARD_PASSWORD, ct);
+            assert_1.default.strictEqual(shimResult, sjclResult, `Box ${label} mismatch`);
+            assert_1.default.ok(shimResult.startsWith(keycard_1.KEYCARD_PLAINTEXT_PREFIX));
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decryptV1.browser.js","sourceRoot":"","sources":["../../../test/unit/decryptV1.browser.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sjcl from '@bitgo/sjcl';\nimport assert from 'assert';\n\nimport { decryptV1WithCrypto, V1_MAX_ITER } from '../../src';\nimport { KEYCARD_BOX_A, KEYCARD_BOX_B, KEYCARD_PASSWORD, KEYCARD_PLAINTEXT_PREFIX } from './fixtures/keycard';\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst browserCrypto = require('crypto-browserify');\n\n/**\n * sjcl.encrypt's typings require salt/iv, but the runtime picks them from\n * sjcl.random when omitted. Feed real random words so the call type-checks\n * without an `as` cast.\n */\nfunction sjclEncrypt(password: string, plaintext: string, params: sjcl.SjclCipherParams): string {\n  const salt = sjcl.random.randomWords(2);\n  const iv = sjcl.random.randomWords(4);\n  return sjcl.encrypt(password, plaintext, { ...params, salt, iv });\n}\n\n/**\n * Exercises the real `decryptV1WithCrypto` code path with `crypto-browserify`\n * injected as the crypto module. This is exactly what webpack bundles for the\n * browser (its `crypto` shim), so a green test here proves the browser build\n * stays byte-compatible with SJCL-produced envelopes and the Node path.\n */\nfunction decryptV1Browser(password: string, ciphertext: string): Promise<string> {\n  return decryptV1WithCrypto(password, ciphertext, browserCrypto);\n}\n\ndescribe('decryptV1 browser path (crypto-browserify shim)', () => {\n  const password = 'myPassword';\n  const plaintext = 'Hello, Browser!';\n\n  it('produces the same plaintext as sjcl.decrypt', async () => {\n    const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });\n    assert.strictEqual(await decryptV1Browser(password, ciphertext), sjcl.decrypt(password, ciphertext));\n  });\n\n  it('handles adata (AAD)', async () => {\n    const ciphertext = sjclEncrypt(password, plaintext, {\n      iter: 10000,\n      ks: 256,\n      ts: 64,\n      mode: 'ccm',\n      adata: 'ctx-A',\n    });\n    assert.strictEqual(await decryptV1Browser(password, ciphertext), plaintext);\n  });\n\n  it('handles UTF-8 password + plaintext', async () => {\n    const utf8Password = 'pässwörd中文🔐';\n    const utf8Plaintext = 'passphrase: 秘密キー ☃🔑';\n    const ciphertext = sjclEncrypt(utf8Password, utf8Plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });\n    assert.strictEqual(await decryptV1Browser(utf8Password, ciphertext), utf8Plaintext);\n  });\n\n  it('handles large plaintext (>64 KiB, forces L=3 nonce framing)', async () => {\n    const large = 'x'.repeat(70_000);\n    const ciphertext = sjclEncrypt(password, large, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });\n    assert.strictEqual(await decryptV1Browser(password, ciphertext), large);\n  });\n\n  it('handles aes-128 envelopes', async () => {\n    const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 128, ts: 64, mode: 'ccm' });\n    assert.strictEqual(await decryptV1Browser(password, ciphertext), plaintext);\n  });\n\n  it('handles 128-bit tag envelopes', async () => {\n    const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 128, mode: 'ccm' });\n    assert.strictEqual(await decryptV1Browser(password, ciphertext), plaintext);\n  });\n\n  it('rejects wrong password', async () => {\n    const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });\n    await assert.rejects(() => decryptV1Browser('wrongPassword', ciphertext));\n  });\n\n  it('rejects envelope with iter above cap before running PBKDF2', async () => {\n    const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });\n    const envelope = JSON.parse(ciphertext);\n    envelope.iter = V1_MAX_ITER + 1;\n    const start = Date.now();\n    await assert.rejects(() => decryptV1Browser(password, JSON.stringify(envelope)), /iter/);\n    assert.ok(Date.now() - start < 100, 'must reject before any KDF work');\n  });\n\n  it('parity across 50 randomised inputs', async () => {\n    const { randomBytes } = await import('crypto');\n    for (let i = 0; i < 50; i++) {\n      const pw = randomBytes(16).toString('hex');\n      const pt = randomBytes(1 + Math.floor(Math.random() * 500)).toString('base64');\n      const ciphertext = sjclEncrypt(pw, pt, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });\n      assert.strictEqual(await decryptV1Browser(pw, ciphertext), pt, `iteration ${i}`);\n    }\n  });\n\n  it('Box A + Box B: shim decrypt matches SJCL byte-for-byte', async () => {\n    for (const [label, ct] of [\n      ['A', KEYCARD_BOX_A],\n      ['B', KEYCARD_BOX_B],\n    ] as const) {\n      const sjclResult = sjcl.decrypt(KEYCARD_PASSWORD, ct);\n      const shimResult = await decryptV1Browser(KEYCARD_PASSWORD, ct);\n      assert.strictEqual(shimResult, sjclResult, `Box ${label} mismatch`);\n      assert.ok(shimResult.startsWith(KEYCARD_PLAINTEXT_PREFIX));\n    }\n  });\n});\n"]}

package/dist/test/unit/decryptV1.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decryptV1.d.ts.map

package/dist/test/unit/decryptV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decryptV1.d.ts","sourceRoot":"","sources":["../../../test/unit/decryptV1.ts"],"names":[],"mappings":""}