@bitgo-beta/sdk-api 1.10.1-beta.2084 → 1.10.1-beta.2086

package/dist/test/unit/v1/keychains.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=keychains.d.ts.map

package/dist/test/unit/v1/keychains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keychains.d.ts","sourceRoot":"","sources":["../../../../test/unit/v1/keychains.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,CAAC"}

package/dist/test/unit/v1/keychains.js

@@ -0,0 +1,114 @@
+"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 });
+require("should");
+const sinon = __importStar(require("sinon"));
+const nock_1 = __importDefault(require("nock"));
+const Keychains = require('../../../src/v1/keychains');
+const ROOT = 'https://app.example.local';
+/**
+ * The deprecated v1 keychains updatePassword (src/v1/keychains.ts) fetches the user's
+ * server-stored encryptedXprvs, re-encrypts each with the new password, and preserves
+ * each envelope's version (isV2Envelope ? 2 : 1). It deliberately ignores both
+ * `encryptionVersion` and `encryptionSession` -- v1 stays v1 during a v2 rotation and
+ * no session is ever consumed. These tests pin that wire behavior so the rollback
+ * contract documented in WCN-2640 cannot regress.
+ */
+describe('v1 Keychains.updatePassword', function () {
+    const v1Envelope = JSON.stringify({ v: 1, iter: 10000, salt: 'c2FsdA==', iv: 'aXY=', ct: 'Y3Q=' });
+    const v2Envelope = JSON.stringify({ v: 2, m: 65536, t: 3, p: 4, salt: 'c2FsdA==', iv: 'aXY=', ct: 'Y3Q=' });
+    const undecryptableEnvelope = JSON.stringify({ v: 1, iter: 10000, salt: 'YmFk', iv: 'aXY=', ct: 'Y3Q=' });
+    function makeBitgo(stored, decryptResults, encryptStub) {
+        return {
+            url: (path) => `${ROOT}/api/v1${path}`,
+            post: () => ({ result: async () => ({ version: 25, keychains: stored }) }),
+            decrypt: async ({ input }) => {
+                const result = decryptResults[input];
+                if (result === undefined) {
+                    throw new Error('decryption failed');
+                }
+                return result;
+            },
+            encrypt: encryptStub,
+        };
+    }
+    afterEach(function () {
+        nock_1.default.cleanAll();
+        sinon.restore();
+    });
+    it('ignores encryptionSession and preserves per-envelope versions under a v2 rotation', async function () {
+        const stored = { xpubV1: v1Envelope, xpubV2: v2Envelope };
+        (0, nock_1.default)(ROOT).post('/api/v1/user/encrypted').reply(200, { version: 25, keychains: stored });
+        const encryptStub = sinon.stub().resolves('re-encrypted');
+        const keychains = new Keychains(makeBitgo(stored, { [v1Envelope]: 'plain-v1', [v2Envelope]: 'plain-v2' }, encryptStub));
+        const session = {
+            encrypt: sinon.stub().resolves('session-encrypted'),
+            decrypt: sinon.stub().resolves('session-decrypted'),
+            destroy: sinon.stub(),
+        };
+        const result = await keychains.updatePassword({
+            oldPassword: 'oldpw',
+            newPassword: 'newpw',
+            encryptionVersion: 2,
+            encryptionSession: session,
+        });
+        // the v1-leg never touches the session: no encrypt, no destroy (destroy is the caller's job)
+        session.encrypt.called.should.equal(false);
+        session.destroy.called.should.equal(false);
+        // re-encryption preserves each envelope's own version: v1 -> encryptionVersion 1,
+        // v2 -> encryptionVersion 2, NOT the caller's encryptionVersion: 2 opt-in
+        encryptStub.calledTwice.should.equal(true);
+        encryptStub.getCall(0).args[0].encryptionVersion.should.equal(1);
+        encryptStub.getCall(1).args[0].encryptionVersion.should.equal(2);
+        encryptStub.alwaysCalledWithMatch({ password: 'newpw' }).should.equal(true);
+        result.keychains.should.deepEqual({ xpubV1: 're-encrypted', xpubV2: 're-encrypted' });
+        result.version.should.equal(25);
+    });
+    it('keeps keychains that cannot be decrypted with the old password unchanged', async function () {
+        const stored = { xpubV1: v1Envelope, xpubV2: v2Envelope, xpubUndecryptable: undecryptableEnvelope };
+        (0, nock_1.default)(ROOT).post('/api/v1/user/encrypted').reply(200, { version: 25, keychains: stored });
+        const encryptStub = sinon.stub().resolves('re-encrypted');
+        const keychains = new Keychains(makeBitgo(stored, { [v1Envelope]: 'plain-v1', [v2Envelope]: 'plain-v2' }, encryptStub));
+        const result = await keychains.updatePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });
+        encryptStub.calledTwice.should.equal(true);
+        result.keychains.xpubUndecryptable.should.equal(undecryptableEnvelope);
+        result.keychains.xpubV1.should.equal('re-encrypted');
+        result.keychains.xpubV2.should.equal('re-encrypted');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keychains.js","sourceRoot":"","sources":["../../../../test/unit/v1/keychains.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport * as sinon from 'sinon';\nimport nock from 'nock';\nimport type { IEncryptionSession } from '@bitgo-beta/sdk-core';\n// CJS module.exports assignment; require idiom matches src/bitgoAPI.ts. The\n// structural contract below pins the surface this test exercises.\ninterface V1UpdatePasswordResult {\n  keychains: Record<string, string>;\n  version: number;\n}\n\ninterface V1Bitgo {\n  url(path: string): string;\n  post(url: string): { result(): Promise<unknown> };\n  decrypt(params: { input: string; password: string }): Promise<string>;\n  encrypt(params: { input: string; password: string; encryptionVersion?: number }): Promise<string>;\n}\n\ntype V1KeychainsCtor = new (bitgo: V1Bitgo) => {\n  updatePassword(params: {\n    oldPassword: string;\n    newPassword: string;\n    encryptionVersion?: number;\n    encryptionSession?: IEncryptionSession;\n  }): Promise<V1UpdatePasswordResult>;\n};\n\nconst Keychains: V1KeychainsCtor = require('../../../src/v1/keychains');\n\nconst ROOT = 'https://app.example.local';\n\n/**\n * The deprecated v1 keychains updatePassword (src/v1/keychains.ts) fetches the user's\n * server-stored encryptedXprvs, re-encrypts each with the new password, and preserves\n * each envelope's version (isV2Envelope ? 2 : 1). It deliberately ignores both\n * `encryptionVersion` and `encryptionSession` -- v1 stays v1 during a v2 rotation and\n * no session is ever consumed. These tests pin that wire behavior so the rollback\n * contract documented in WCN-2640 cannot regress.\n */\ndescribe('v1 Keychains.updatePassword', function () {\n  const v1Envelope = JSON.stringify({ v: 1, iter: 10000, salt: 'c2FsdA==', iv: 'aXY=', ct: 'Y3Q=' });\n  const v2Envelope = JSON.stringify({ v: 2, m: 65536, t: 3, p: 4, salt: 'c2FsdA==', iv: 'aXY=', ct: 'Y3Q=' });\n  const undecryptableEnvelope = JSON.stringify({ v: 1, iter: 10000, salt: 'YmFk', iv: 'aXY=', ct: 'Y3Q=' });\n\n  function makeBitgo(\n    stored: Record<string, string>,\n    decryptResults: Record<string, string>,\n    encryptStub: sinon.SinonStub\n  ) {\n    return {\n      url: (path: string) => `${ROOT}/api/v1${path}`,\n      post: () => ({ result: async () => ({ version: 25, keychains: stored }) }),\n      decrypt: async ({ input }: { input: string }) => {\n        const result = decryptResults[input];\n        if (result === undefined) {\n          throw new Error('decryption failed');\n        }\n        return result;\n      },\n      encrypt: encryptStub,\n    };\n  }\n\n  afterEach(function () {\n    nock.cleanAll();\n    sinon.restore();\n  });\n\n  it('ignores encryptionSession and preserves per-envelope versions under a v2 rotation', async function () {\n    const stored = { xpubV1: v1Envelope, xpubV2: v2Envelope };\n    nock(ROOT).post('/api/v1/user/encrypted').reply(200, { version: 25, keychains: stored });\n\n    const encryptStub = sinon.stub().resolves('re-encrypted');\n    const keychains = new Keychains(\n      makeBitgo(stored, { [v1Envelope]: 'plain-v1', [v2Envelope]: 'plain-v2' }, encryptStub)\n    );\n\n    const session: IEncryptionSession = {\n      encrypt: sinon.stub().resolves('session-encrypted'),\n      decrypt: sinon.stub().resolves('session-decrypted'),\n      destroy: sinon.stub(),\n    };\n\n    const result = await keychains.updatePassword({\n      oldPassword: 'oldpw',\n      newPassword: 'newpw',\n      encryptionVersion: 2,\n      encryptionSession: session,\n    });\n\n    // the v1-leg never touches the session: no encrypt, no destroy (destroy is the caller's job)\n    (session.encrypt as sinon.SinonStub).called.should.equal(false);\n    (session.destroy as sinon.SinonStub).called.should.equal(false);\n\n    // re-encryption preserves each envelope's own version: v1 -> encryptionVersion 1,\n    // v2 -> encryptionVersion 2, NOT the caller's encryptionVersion: 2 opt-in\n    encryptStub.calledTwice.should.equal(true);\n    encryptStub.getCall(0).args[0].encryptionVersion.should.equal(1);\n    encryptStub.getCall(1).args[0].encryptionVersion.should.equal(2);\n    encryptStub.alwaysCalledWithMatch({ password: 'newpw' }).should.equal(true);\n\n    result.keychains.should.deepEqual({ xpubV1: 're-encrypted', xpubV2: 're-encrypted' });\n    result.version.should.equal(25);\n  });\n\n  it('keeps keychains that cannot be decrypted with the old password unchanged', async function () {\n    const stored = { xpubV1: v1Envelope, xpubV2: v2Envelope, xpubUndecryptable: undecryptableEnvelope };\n    nock(ROOT).post('/api/v1/user/encrypted').reply(200, { version: 25, keychains: stored });\n\n    const encryptStub = sinon.stub().resolves('re-encrypted');\n    const keychains = new Keychains(\n      makeBitgo(stored, { [v1Envelope]: 'plain-v1', [v2Envelope]: 'plain-v2' }, encryptStub)\n    );\n\n    const result = await keychains.updatePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });\n\n    encryptStub.calledTwice.should.equal(true);\n    result.keychains.xpubUndecryptable.should.equal(undecryptableEnvelope);\n    result.keychains.xpubV1.should.equal('re-encrypted');\n    result.keychains.xpubV2.should.equal('re-encrypted');\n  });\n});\n"]}