@bitgo-beta/sdk-api 1.10.1-beta.2094 → 1.10.1-beta.2096

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bitgo-beta/sdk-api",
-    "version": "1.10.1-beta.2094",
+    "version": "1.10.1-beta.2096",
     "description": "REST wrapper for BitGoJS",
     "main": "./dist/src/index.js",
     "types": "./dist/src/index.d.ts",
@@ -40,12 +40,12 @@
         ]
     },
     "dependencies": {
-        "@bitgo-beta/argon2": "0.0.1-beta.435",
-        "@bitgo-beta/sdk-core": "8.2.1-beta.2106",
-        "@bitgo-beta/sdk-hmac": "1.0.1-beta.1498",
-        "@bitgo-beta/sjcl": "1.0.2-beta.2372",
-        "@bitgo-beta/unspents": "0.13.2-beta.2116",
-        "@bitgo-beta/utxo-lib": "8.0.3-beta.2119",
+        "@bitgo-beta/argon2": "0.0.1-beta.437",
+        "@bitgo-beta/sdk-core": "8.2.1-beta.2108",
+        "@bitgo-beta/sdk-hmac": "1.0.1-beta.1500",
+        "@bitgo-beta/sjcl": "1.0.2-beta.2374",
+        "@bitgo-beta/unspents": "0.13.2-beta.2118",
+        "@bitgo-beta/utxo-lib": "8.0.3-beta.2121",
         "@types/superagent": "4.1.15",
         "bitcoinjs-message": "npm:@bitgo-forks/bitcoinjs-message@1.0.0-master.3",
         "debug": "3.1.0",
@@ -58,16 +58,13 @@
         "secrets.js-grempe": "^1.1.0",
         "superagent": "^9.0.1"
     },
-    "devDependencies": {
-        "crypto-browserify": "^3.12.0"
-    },
     "overrides": {
         "degenerator": "5.0.0"
     },
     "resolutions": {
         "degenerator": "5.0.0"
     },
-    "gitHead": "d9e7516ac891df98153ee3381693ca37e1473323",
+    "gitHead": "2add91a6f5c0cc3bab05e0a8f71dedf2189101d9",
     "files": [
         "dist"
     ]

package/dist/src/decryptV1.d.ts

@@ -1,14 +1,4 @@
-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
@@ -36,24 +26,13 @@ declare const V1EnvelopeCodec: t.IntersectionC<[t.TypeC<{
 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.
+ * Decrypt a v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope with Node's native
+ * `node:crypto`.
  *
- * 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`.
+ * Node runtimes only: the `crypto` webpack substitutes in browser bundles
+ * (`crypto-browserify`) has no working AES-CCM, so `decryptV1WithFallback`
+ * routes browser runtimes straight to the frozen SJCL decoder instead of
+ * ever calling this.
  */
 export declare function decryptV1(password: string, ciphertext: string): Promise<string>;
 export {};

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

@@ -1 +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"}
+{"version":3,"file":"decryptV1.d.ts","sourceRoot":"","sources":["../../src/decryptV1.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAG3B;;;;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;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBrF"}

package/dist/src/decryptV1.js

@@ -35,13 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 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-beta/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
@@ -93,16 +91,15 @@ function ccmNonceLength(plaintextLen) {
     return 15 - L;
 }
 /**
- * Decrypt a parsed v1 envelope given a crypto module.
+ * Decrypt a v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope with Node's native
+ * `node:crypto`.
  *
- * 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.
+ * Node runtimes only: the `crypto` webpack substitutes in browser bundles
+ * (`crypto-browserify`) has no working AES-CCM, so `decryptV1WithFallback`
+ * routes browser runtimes straight to the frozen SJCL decoder instead of
+ * ever calling this.
  */
-async function decryptV1WithCrypto(password, ciphertext, crypto) {
+async function decryptV1(password, ciphertext) {
     const env = parseV1Envelope(ciphertext);
     const salt = Buffer.from(env.salt, 'base64');
     const ivFull = Buffer.from(env.iv, 'base64');
@@ -117,24 +114,12 @@ async function decryptV1WithCrypto(password, ciphertext, crypto) {
         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 });
+    const key = await (0, util_1.promisify)(crypto_1.pbkdf2)(password, salt, env.iter, keyBytes, 'sha256');
+    const decipher = (0, crypto_1.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-beta/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"]}
+//# 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-beta/sdk-core';\nimport { createDecipheriv, pbkdf2 } from 'crypto';\nimport * as t from 'io-ts';\nimport { promisify } from 'util';\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 v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope with Node's native\n * `node:crypto`.\n *\n * Node runtimes only: the `crypto` webpack substitutes in browser bundles\n * (`crypto-browserify`) has no working AES-CCM, so `decryptV1WithFallback`\n * routes browser runtimes straight to the frozen SJCL decoder instead of\n * ever calling this.\n */\nexport async function decryptV1(password: string, ciphertext: string): 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(pbkdf2)(password, salt, env.iter, keyBytes, 'sha256');\n\n  const decipher = 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"]}

package/dist/src/encrypt.d.ts

@@ -20,11 +20,16 @@ export declare function encrypt(password: string, plaintext: string, options?: {
 /**
  * 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.
+ * Node: native `node:crypto` first, SJCL fallback. 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.
+ *
+ * Browser/worker: skip the native attempt entirely (its polyfilled AES-CCM
+ * is broken) and go straight to `sjcl.decrypt`, after running the same
+ * `parseV1Envelope` iter-cap check the native path would run.
  *
  * The console.warn only fires when native fails AND SJCL succeeds -- i.e.
  * when the two engines disagree, which is the only signal worth

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

@@ -1 +1 @@
-{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../src/encrypt.ts"],"names":[],"mappings":"AAiCA;;;;;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;;;;;;;;;;;;;;;;;;GAkBG;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,EAC/D,SAAS,GAAE,OAA0B,GACpC,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAED;;;GAGG;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":"AAiBA;;;;;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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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,EAC/D,SAAS,GAAE,OAA4B,GACtC,OAAO,CAAC,MAAM,CAAC,CAgCjB;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBnF"}

package/dist/src/encrypt.js

@@ -42,30 +42,14 @@ const crypto_1 = require("crypto");
 const decryptV1_1 = require("./decryptV1");
 const encryptV2_1 = require("./encryptV2");
 /**
- * True when running in a bundled browser build. `browserify-aes` -- the AES
- * polyfill webpack substitutes for `node:crypto` in browser bundles -- has no
- * AES-CCM mode at all, so native v1 decrypt fails on literally every call
- * there. There's no point paying for the doomed native attempt (a full
- * PBKDF2 run) before falling back; go straight to SJCL.
+ * True in a browser main thread (`window`) or worker (`self`) runtime. The
+ * `crypto` webpack substitutes for `node:crypto` there (`crypto-browserify`,
+ * backed by `browserify-aes`) has no working AES-CCM, so a native v1 attempt
+ * would only pay for a doomed PBKDF2 run before falling back. Browser
+ * runtimes route v1 decrypt straight to SJCL instead.
  */
-const isBrowserRuntime = typeof window !== 'undefined';
-/**
- * SJCL has no upper bound on `iter`, so a hostile v1 envelope could burn CPU
- * running an inflated PBKDF2. Native decrypt's codec normally catches this
- * before any KDF work runs; the browser path skips native entirely, so it
- * needs this narrow check to preserve the same DoS protection.
- */
-function assertIterWithinCap(ciphertext) {
-    let iter;
-    try {
-        iter = JSON.parse(ciphertext)?.iter;
-    }
-    catch {
-        return; // malformed JSON -- let sjcl.decrypt raise its own error
-    }
-    if (typeof iter === 'number' && iter > decryptV1_1.V1_MAX_ITER) {
-        throw new Error(`v1 decrypt: iter ${iter} exceeds cap of ${decryptV1_1.V1_MAX_ITER}`);
-    }
+function isBrowserRuntime() {
+    return typeof window !== 'undefined' || typeof self !== 'undefined';
 }
 /**
  * convert a 4 element Uint8Array to a 4 byte Number
@@ -132,11 +116,16 @@ function isIterCapViolation(err) {
 /**
  * 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.
+ * Node: native `node:crypto` first, SJCL fallback. 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.
+ *
+ * Browser/worker: skip the native attempt entirely (its polyfilled AES-CCM
+ * is broken) and go straight to `sjcl.decrypt`, after running the same
+ * `parseV1Envelope` iter-cap check the native path would run.
  *
  * The console.warn only fires when native fails AND SJCL succeeds -- i.e.
  * when the two engines disagree, which is the only signal worth
@@ -148,9 +137,20 @@ function isIterCapViolation(err) {
  * `isBrowser` defaults to a real runtime check but is exposed so tests can
  * exercise the browser-only branch under Node.
  */
-async function decryptV1WithFallback(password, ciphertext, native = decryptV1_1.decryptV1, isBrowser = isBrowserRuntime) {
+async function decryptV1WithFallback(password, ciphertext, native = decryptV1_1.decryptV1, isBrowser = isBrowserRuntime()) {
     if (isBrowser) {
-        assertIterWithinCap(ciphertext);
+        try {
+            (0, decryptV1_1.parseV1Envelope)(ciphertext);
+        }
+        catch (parseErr) {
+            // Only honor the iter-cap violation: SJCL has no upper bound on `iter`,
+            // so falling through would let a hostile envelope burn CPU running an
+            // inflated PBKDF2. Any other shape rejection (e.g. a legacy envelope
+            // without a `v` field) is a form SJCL still accepts, so let
+            // sjcl.decrypt make the final call.
+            if (isIterCapViolation(parseErr))
+                throw parseErr;
+        }
         return sjcl.decrypt(password, ciphertext);
     }
     try {
@@ -197,4 +197,4 @@ async function decrypt(password, ciphertext) {
     }
     return decryptV1WithFallback(password, ciphertext);
 }
-//# 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-beta/sjcl';\nimport { randomBytes } from 'crypto';\n\nimport { decryptV1, V1_MAX_ITER } from './decryptV1';\nimport { decryptV2, encryptV2 } from './encryptV2';\n\n/**\n * True when running in a bundled browser build. `browserify-aes` -- the AES\n * polyfill webpack substitutes for `node:crypto` in browser bundles -- has no\n * AES-CCM mode at all, so native v1 decrypt fails on literally every call\n * there. There's no point paying for the doomed native attempt (a full\n * PBKDF2 run) before falling back; go straight to SJCL.\n */\nconst isBrowserRuntime = typeof window !== 'undefined';\n\n/**\n * SJCL has no upper bound on `iter`, so a hostile v1 envelope could burn CPU\n * running an inflated PBKDF2. Native decrypt's codec normally catches this\n * before any KDF work runs; the browser path skips native entirely, so it\n * needs this narrow check to preserve the same DoS protection.\n */\nfunction assertIterWithinCap(ciphertext: string): void {\n  let iter: unknown;\n  try {\n    iter = JSON.parse(ciphertext)?.iter;\n  } catch {\n    return; // malformed JSON -- let sjcl.decrypt raise its own error\n  }\n  if (typeof iter === 'number' && iter > V1_MAX_ITER) {\n    throw new Error(`v1 decrypt: iter ${iter} exceeds cap of ${V1_MAX_ITER}`);\n  }\n}\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 * `isBrowser` defaults to a real runtime check but is exposed so tests can\n * exercise the browser-only branch under Node.\n */\nexport async function decryptV1WithFallback(\n  password: string,\n  ciphertext: string,\n  native: (pw: string, ct: string) => Promise<string> = decryptV1,\n  isBrowser: boolean = isBrowserRuntime\n): Promise<string> {\n  if (isBrowser) {\n    assertIterWithinCap(ciphertext);\n    return sjcl.decrypt(password, ciphertext);\n  }\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"]}
+//# 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-beta/sjcl';\nimport { randomBytes } from 'crypto';\n\nimport { decryptV1, parseV1Envelope } from './decryptV1';\nimport { decryptV2, encryptV2 } from './encryptV2';\n\n/**\n * True in a browser main thread (`window`) or worker (`self`) runtime. The\n * `crypto` webpack substitutes for `node:crypto` there (`crypto-browserify`,\n * backed by `browserify-aes`) has no working AES-CCM, so a native v1 attempt\n * would only pay for a doomed PBKDF2 run before falling back. Browser\n * runtimes route v1 decrypt straight to SJCL instead.\n */\nfunction isBrowserRuntime(): boolean {\n  return typeof window !== 'undefined' || typeof self !== 'undefined';\n}\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 * Node: native `node:crypto` first, SJCL fallback. Design intent during\n * rollout: zero false negatives. Any native failure (envelope shape our\n * stricter codec rejects, framing bug, unsupported algorithm, auth-tag\n * mismatch, etc.) falls through to `sjcl.decrypt` so the caller is never\n * blocked. The only exception is an iter-cap violation, which is rethrown\n * to preserve DoS protection.\n *\n * Browser/worker: skip the native attempt entirely (its polyfilled AES-CCM\n * is broken) and go straight to `sjcl.decrypt`, after running the same\n * `parseV1Envelope` iter-cap check the native path would run.\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 * `isBrowser` defaults to a real runtime check but is exposed so tests can\n * exercise the browser-only branch under Node.\n */\nexport async function decryptV1WithFallback(\n  password: string,\n  ciphertext: string,\n  native: (pw: string, ct: string) => Promise<string> = decryptV1,\n  isBrowser: boolean = isBrowserRuntime()\n): Promise<string> {\n  if (isBrowser) {\n    try {\n      parseV1Envelope(ciphertext);\n    } catch (parseErr) {\n      // Only honor the iter-cap violation: SJCL has no upper bound on `iter`,\n      // so falling through would let a hostile envelope burn CPU running an\n      // inflated PBKDF2. Any other shape rejection (e.g. a legacy envelope\n      // without a `v` field) is a form SJCL still accepts, so let\n      // sjcl.decrypt make the final call.\n      if (isIterCapViolation(parseErr)) throw parseErr;\n    }\n    return sjcl.decrypt(password, ciphertext);\n  }\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"]}