@bitgo-beta/sdk-api 1.10.1-beta.210 → 1.10.1-beta.2100

package/dist/src/decryptV1.d.ts

@@ -0,0 +1,39 @@
+import * as t from 'io-ts';
+/**
+ * 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 v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope with Node's native
+ * `node:crypto`.
+ *
+ * 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 {};
+//# 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":"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

@@ -0,0 +1,125 @@
+"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.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");
+/**
+ * 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 v1 (SJCL PBKDF2-SHA256 + AES-CCM) envelope with Node's native
+ * `node:crypto`.
+ *
+ * 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 decryptV1(password, ciphertext) {
+    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_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');
+}
+//# 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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * convert a 4 element Uint8Array to a 4 byte Number
  *
@@ -6,9 +5,46 @@
  * @return 4 byte number
  */
 export declare function bytesToWord(bytes?: Uint8Array | number[]): number;
-export declare function encrypt(password: string, plaintext: string, { salt, iv }?: {
-    salt?: Buffer | undefined;
-    iv?: Buffer | undefined;
-}): string;
-export declare function decrypt(password: string, ciphertext: string): string;
+/**
+ * Encrypt `plaintext` with `password`. Defaults to v2 (Argon2id + AES-256-GCM).
+ *
+ * Pass `encryptionVersion: 1` to produce a legacy v1 (SJCL) envelope; this is the
+ * only supported way to request v1 encryption.
+ */
+export declare function encrypt(password: string, plaintext: string, options?: {
+    salt?: Buffer;
+    iv?: Buffer;
+    adata?: string;
+    encryptionVersion?: 1 | 2;
+}): Promise<string>;
+/**
+ * v1 decrypt with an SJCL safety net.
+ *
+ * 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
+ * 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.
+ * `isBrowser` defaults to a real runtime check but is exposed so tests can
+ * exercise the browser-only branch under Node.
+ */
+export declare function decryptV1WithFallback(password: string, ciphertext: string, native?: (pw: string, ct: string) => Promise<string>, isBrowser?: boolean): 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":";AAGA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,MAAM,CAMjE;AAED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,EAAE,IAAqB,EAAE,EAAoB,EAAE;;;CAAK,GACnD,MAAM,CAoBR;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAEpE"}
+{"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

@@ -1,8 +1,56 @@
 "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.decrypt = exports.encrypt = exports.bytesToWord = void 0;
-const sjcl = require("@bitgo-beta/sjcl");
+exports.bytesToWord = bytesToWord;
+exports.encrypt = encrypt;
+exports.decryptV1WithFallback = decryptV1WithFallback;
+exports.decrypt = decrypt;
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
 const crypto_1 = require("crypto");
+const decryptV1_1 = require("./decryptV1");
+const encryptV2_1 = require("./encryptV2");
+/**
+ * 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.
+ */
+function isBrowserRuntime() {
+    return typeof window !== 'undefined' || typeof self !== 'undefined';
+}
 /**
  * convert a 4 element Uint8Array to a 4 byte Number
  *
@@ -15,14 +63,19 @@ function bytesToWord(bytes) {
     }
     return bytes.reduce((num, byte) => num * 0x100 + byte, 0);
 }
-exports.bytesToWord = bytesToWord;
-function encrypt(password, plaintext, { salt = crypto_1.randomBytes(8), iv = crypto_1.randomBytes(16) } = {}) {
-    if (salt.length !== 8) {
-        throw new Error(`salt must be 8 bytes`);
-    }
-    if (iv.length !== 16) {
-        throw new Error(`iv must be 16 bytes`);
-    }
+/**
+ * Internal v1 (SJCL PBKDF2-SHA256 + AES-256-CCM) encrypt helper.
+ *
+ * Not exported as part of the public encrypt/decrypt surface: callers must not use
+ * this directly. v1 output is requested via `encrypt(..., { encryptionVersion: 1 })`.
+ */
+function encryptV1(password, plaintext, options) {
+    const salt = options?.salt || (0, crypto_1.randomBytes)(8);
+    if (salt.length !== 8)
+        throw new Error('salt must be 8 bytes');
+    const iv = options?.iv || (0, crypto_1.randomBytes)(16);
+    if (iv.length !== 16)
+        throw new Error('iv must be 16 bytes');
     const encryptOptions = {
         iter: 10000,
         ks: 256,
@@ -34,11 +87,114 @@ function encrypt(password, plaintext, { salt = crypto_1.randomBytes(8), iv = cry
             bytesToWord(iv.slice(12, 16)),
         ],
     };
+    if (options?.adata)
+        encryptOptions.adata = options.adata;
     return sjcl.encrypt(password, plaintext, encryptOptions);
 }
-exports.encrypt = encrypt;
-function decrypt(password, ciphertext) {
-    return sjcl.decrypt(password, ciphertext);
+/**
+ * Encrypt `plaintext` with `password`. Defaults to v2 (Argon2id + AES-256-GCM).
+ *
+ * Pass `encryptionVersion: 1` to produce a legacy v1 (SJCL) envelope; this is the
+ * only supported way to request v1 encryption.
+ */
+async function encrypt(password, plaintext, options) {
+    if (options?.encryptionVersion === 1) {
+        return encryptV1(password, plaintext, options);
+    }
+    return (0, encryptV2_1.encryptV2)(password, plaintext, { adata: options?.adata });
 }
-exports.decrypt = decrypt;
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 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 isIterCapViolation(err) {
+    return err instanceof Error && /iter:\s*expected integer|iter out of range/i.test(err.message);
+}
+/**
+ * v1 decrypt with an SJCL safety net.
+ *
+ * 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
+ * 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.
+ * `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()) {
+    if (isBrowser) {
+        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 {
+        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;
+    try {
+        const envelope = JSON.parse(ciphertext);
+        envelopeVersion = envelope.v;
+    }
+    catch {
+        throw new Error('decrypt: ciphertext is not valid JSON');
+    }
+    if (envelopeVersion === 2) {
+        // Do not catch: wrong password on v2 must not silently fall through to v1.
+        return (0, encryptV2_1.decryptV2)(password, ciphertext);
+    }
+    if (envelopeVersion !== undefined && envelopeVersion !== 1) {
+        throw new Error(`decrypt: unknown envelope version ${envelopeVersion}`);
+    }
+    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, 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"]}

package/dist/src/encryptV2.d.ts

@@ -0,0 +1,67 @@
+import * as t from 'io-ts';
+/** Default Argon2id parameters per RFC 9106 second recommendation
+ * @see https://www.rfc-editor.org/rfc/rfc9106#section-4
+ */
+export declare const ARGON2_DEFAULTS: {
+    readonly memorySize: 65536;
+    readonly iterations: 3;
+    readonly parallelism: 4;
+    readonly hashLength: 32;
+    readonly saltLength: 16;
+};
+/** AES-256-GCM IV length in bytes */
+export declare const GCM_IV_LENGTH = 12;
+/** HKDF per-call salt length in bytes */
+export declare const HKDF_SALT_LENGTH = 32;
+declare const V2EnvelopeCodec: t.IntersectionC<[t.TypeC<{
+    v: t.LiteralC<2>;
+    iv: t.Type<string, string, unknown>;
+    ct: t.Type<string, string, unknown>;
+}>, t.PartialC<{
+    m: t.Type<number, number, unknown>;
+    t: t.Type<number, number, unknown>;
+    p: t.Type<number, number, unknown>;
+    salt: t.Type<string, string, unknown>;
+    /** Base64-encoded HKDF salt -- session envelopes and HKDF-only envelopes */
+    hkdfSalt: t.Type<string, string, unknown>;
+    /** Additional authenticated data for context binding (e.g. transaction hash + derivation path) */
+    adata: t.StringC;
+}>]>;
+export type V2Envelope = t.TypeOf<typeof V2EnvelopeCodec>;
+export declare function argon2ToHkdfKey(password: string, salt: Uint8Array, params: {
+    memorySize: number;
+    iterations: number;
+    parallelism: number;
+}): Promise<CryptoKey>;
+export declare function hkdfDeriveAesKey(hkdfKey: CryptoKey, hkdfSalt: Uint8Array, usage: KeyUsage, info?: Uint8Array): Promise<CryptoKey>;
+export declare function aesGcmEncrypt(key: CryptoKey, iv: Uint8Array, plaintext: string, additionalData?: Uint8Array): Promise<Uint8Array>;
+export declare function aesGcmDecrypt(key: CryptoKey, iv: Uint8Array, ct: Uint8Array, additionalData?: Uint8Array): Promise<string>;
+export declare function parseV2Envelope(ciphertext: string): V2Envelope;
+/**
+ * Encrypt plaintext using Argon2id KDF + AES-256-GCM.
+ *
+ * Returns a self-describing JSON v2 envelope containing all Argon2id parameters,
+ * salt, IV, and ciphertext -- fully standalone for decryption.
+ *
+ * For multi-call operations (MPC signing, wallet creation), prefer
+ * createEncryptionSession to run Argon2id once and derive per-call keys via HKDF.
+ */
+export declare function encryptV2(password: string, plaintext: string, options?: {
+    salt?: Uint8Array;
+    iv?: Uint8Array;
+    memorySize?: number;
+    iterations?: number;
+    parallelism?: number;
+    adata?: string;
+}): Promise<string>;
+/**
+ * Decrypt a v2 envelope. Auto-detects shape:
+ *   - Standard  (Argon2 params, no hkdfSalt): Argon2id -> AES-GCM
+ *   - Session   (Argon2 params + hkdfSalt): Argon2id -> HKDF -> AES-GCM
+ *   - HKDF-only (hkdfSalt, no Argon2 params): HKDF(password) -> AES-GCM
+ *
+ * All parameters are stored in the envelope -- no session context required.
+ */
+export declare function decryptV2(password: string, ciphertext: string): Promise<string>;
+export {};
+//# sourceMappingURL=encryptV2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryptV2.d.ts","sourceRoot":"","sources":["../../src/encryptV2.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAK3B;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAaX,qCAAqC;AACrC,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,yCAAyC;AACzC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAcnC,QAAA,MAAM,eAAe;;;;;;;;;IAWjB,4EAA4E;;IAE5E,kGAAkG;;IAGpG,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAgD1D,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACtE,OAAO,CAAC,SAAS,CAAC,CAGpB;AAOD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,QAAQ,EACf,IAAI,GAAE,UAA8B,GACnC,OAAO,CAAC,SAAS,CAAC,CAQpB;AAED,wBAAsB,aAAa,CACjC,GAAG,EAAE,SAAS,EACd,EAAE,EAAE,UAAU,EACd,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,UAAU,GAC1B,OAAO,CAAC,UAAU,CAAC,CAKrB;AAED,wBAAsB,aAAa,CACjC,GAAG,EAAE,SAAS,EACd,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,UAAU,EACd,cAAc,CAAC,EAAE,UAAU,GAC1B,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAY9D;AAID;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACA,OAAO,CAAC,MAAM,CAAC,CA0BjB;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA6BrF"}