@ledgerhq/revault-sdk 0.27.16 → 0.28.1

package/lib/engine.js

@@ -1,6 +1,7 @@
-import { a as DisconnectedDevice, c as APPID_VAULT_ADMINISTRATOR, d as SCRIPT_IDS, f as STR_ROLES, i as withDevicePolling, l as PAGINATED_STATUS, n as isTransportStatusError, o as LockedDeviceError, s as createApiDevice, u as PATHS } from "./device-DBzLykrI.js";
+import { c as LockedDeviceError, d as PAGINATED_STATUS, f as PATHS, i as isTransportStatusError, l as createApiDevice, m as STR_ROLES, o as withDevicePolling, p as SCRIPT_IDS, r as isPskMissingError, s as DisconnectedDevice, u as APPID_VAULT_ADMINISTRATOR } from "./device-Bo6m3O1I.js";
 import { i as fetchAllCursor, r as fetchAll, t as buildTrpcContext } from "./utils-CW0gdJME.js";
 import invariant from "invariant";
+import { match } from "ts-pattern";
 import { from, lastValueFrom } from "rxjs";
 import { createTRPCClient, httpLink } from "@trpc/client";
 import superjson from "superjson";
@@ -62,6 +63,43 @@ const buildAttestation = (params) => {
 	totalLengthBuffer.writeUInt16BE(data.length, 0);
 	return Buffer.concat([totalLengthBuffer, data]);
 };
+const buildPskRefreshPayload = (params) => {
+	const sigBuffer = Buffer.from(params.handshakeAttestation.signature, "base64");
+	const sigLengthBuffer = Buffer.alloc(1);
+	sigLengthBuffer.writeUIntBE(sigBuffer.length, 0, 1);
+	const certBuffer = Buffer.from(params.handshakeAttestation.certificate, "base64");
+	const certLengthBuffer = Buffer.alloc(1);
+	certLengthBuffer.writeUIntBE(certBuffer.length, 0, 1);
+	const pubBuffer = Buffer.from(params.handshakeAttestation.attestationPub, "base64");
+	const certChainData = Buffer.concat([
+		sigLengthBuffer,
+		sigBuffer,
+		pubBuffer,
+		certLengthBuffer,
+		certBuffer
+	]);
+	const handshakeBuffer = Buffer.from(params.handshake, "base64");
+	invariant(handshakeBuffer.length <= 255, `PSK refresh handshake too long: ${handshakeBuffer.length} bytes (max 255)`);
+	const handshakeLengthBuffer = Buffer.alloc(1);
+	handshakeLengthBuffer.writeUInt8(handshakeBuffer.length, 0);
+	const encryptedPayloadBuffer = Buffer.from(params.encryptedPairingPayload, "base64");
+	invariant(encryptedPayloadBuffer.length <= 255, `PSK encrypted payload too long: ${encryptedPayloadBuffer.length} bytes (max 255)`);
+	const encryptedPayloadLengthBuffer = Buffer.alloc(1);
+	encryptedPayloadLengthBuffer.writeUInt8(encryptedPayloadBuffer.length, 0);
+	const certChainDataLengthBuff = Buffer.alloc(2);
+	certChainDataLengthBuff.writeUInt16BE(certChainData.length, 0);
+	const data = Buffer.concat([
+		handshakeLengthBuffer,
+		handshakeBuffer,
+		certChainDataLengthBuff,
+		certChainData,
+		encryptedPayloadLengthBuffer,
+		encryptedPayloadBuffer
+	]);
+	const totalLengthBuffer = Buffer.alloc(2);
+	totalLengthBuffer.writeUInt16BE(data.length, 0);
+	return Buffer.concat([totalLengthBuffer, data]);
+};
 /* v8 ignore next -- @preserve */
 const genericRetryOnError = (err) => {
 	if (err instanceof LockedDeviceError) return true;
@@ -211,8 +249,10 @@ function createRealDevice(options, logger) {
 				181
 			];
 			const res = await run((transport) => transport.exchange(Buffer.from(apdu)));
-			const hex = Buffer.from(res).toString("hex");
-			return hex !== "6f45" && hex !== "6a87";
+			const swHex = res.subarray(res.length - 2).toString("hex");
+			if (swHex === "6f45" || swHex === "6a87") return "NO_PAIRING";
+			if (swHex === "6065") return "PSK_MISSING";
+			return "OK";
 		},
 		initPairingHandshake: async () => {
 			const res = await run((transport) => transport.send(224, 70, 0, 0));
@@ -318,6 +358,21 @@ function createRealDevice(options, logger) {
 				0
 			], final));
 		},
+		signRefreshPskAuth: async () => {
+			logger.info(`[device] signRefreshPskAuth`);
+			const res = await run((transport) => transport.send(224, 85, 0, 0));
+			return res.slice(0, res.length - 2).toString("base64");
+		},
+		finalizePskRefresh: async (params) => {
+			logger.info(`[device] finalizePskRefresh`);
+			const payload = buildPskRefreshPayload(params);
+			await run((transport) => sendByChunk(transport, [
+				224,
+				83,
+				0,
+				0
+			], payload));
+		},
 		startKKPatternAsResponder: async (params) => {
 			logger.info(`[device] startKKPatternAsResponder`);
 			const data = buildAttestation(params);
@@ -343,6 +398,18 @@ function createRealDevice(options, logger) {
 				SCRIPT_IDS.ACCOUNT_MANAGER_SESSION
 			], data));
 		},
+		startPskSession: async (params) => {
+			logger.info(`[device] startPskSession`);
+			invariant(params.nonce.length === 64, `PSK nonce must be 32 bytes (64 hex chars), got ${params.nonce.length} chars`);
+			invariant(params.partitionId.length === 32, `partitionId must be 16 bytes (32 hex chars), got ${params.partitionId.length} chars`);
+			const data = Buffer.concat([Buffer.from(params.nonce, "hex"), Buffer.from(params.partitionId, "hex")]);
+			await run((transport) => sendByChunk(transport, [
+				224,
+				80,
+				0,
+				0
+			], data));
+		},
 		validateVaultOperation: async (params) => {
 			logger.info(`[device] validateVaultOperation`);
 			const path = getPathFromPathString(PATHS.VALIDATION);
@@ -423,6 +490,37 @@ const createClient = (options) => {
 };
 //#endregion
 //#region src/engine/index.ts
+const PSK_NONCE_BYTE_LEN = 32;
+const openSecureChannel = (device, challenge) => {
+	if (challenge.handshake.length === PSK_NONCE_BYTE_LEN * 2) return device.startPskSession({
+		nonce: challenge.handshake,
+		partitionId: challenge.partitionId
+	});
+	return device.startKPatternAsResponder({
+		handshake: challenge.handshake,
+		handshakeAttestation: challenge.handshakeAttestation,
+		partitionId: challenge.partitionId
+	});
+};
+const pairDevice = async ({ device, getPairing }) => {
+	const pairing = await getPairing(await device.getConfidentialityKey());
+	await device.setPairing({ pairing });
+};
+const refreshPsk = async ({ device, getRefreshPskData }) => {
+	const eph = await device.initPairingHandshake();
+	const [deviceAttestation, validationKeySignature] = await Promise.all([device.getAttestation(), device.signRefreshPskAuth({ ephemeralKey: eph.pubKey })]);
+	const refresh = await getRefreshPskData({
+		psdEphemeralKey: Buffer.from(eph.pubKey, "hex").toString("base64"),
+		psdEphemeralKeyAttestation: {
+			codeHash: deviceAttestation.attestation.codeHash,
+			attestationPub: deviceAttestation.attestation.attestationPub,
+			certificate: deviceAttestation.attestation.certificate,
+			signature: eph.signature
+		},
+		validationKeySignature
+	});
+	await device.finalizePskRefresh(refresh);
+};
 async function genericRegister({ device, name, role, getChallenge, submitChallenge, onScreenDisplayed }) {
 	const [attestation, u2fPubKey, confidentialityKey] = await Promise.all([
 		device.getAttestation(),
@@ -562,18 +660,55 @@ function createEngine(options, logger) {
 		});
 		if (engine.device && engine.__onboardingId) decorate((engine) => {
 			const { device, client, __onboardingId } = engine;
+			const isPskEnabled = async () => {
+				try {
+					return await client.onboarding.getPskFeatureFlag.query({ onboardingId: __onboardingId }) === true;
+				} catch {
+					return false;
+				}
+			};
 			async function enforcePairing() {
-				if (await device.hasPairing()) return;
-				const [{ pubKey }, confidentialityKey] = await Promise.all([device.getU2FPubKey(), device.getConfidentialityKey()]);
-				const pairing = await client.onboarding.pairDevicePartition.mutate({
-					pubKey,
-					onboardingId: __onboardingId,
-					data: {
-						confidentialityKeyCurve25519: confidentialityKey.confidentialityKeyCurve25519,
-						confidentialityKeySignature: confidentialityKey.confidentialityKeySignature
-					}
-				});
-				await device.setPairing({ pairing });
+				const status = await device.hasPairing();
+				if (status === "OK") return;
+				const pskEnabled = await isPskEnabled();
+				let pubKeyPromise;
+				const getPubKey = async () => {
+					pubKeyPromise ??= device.getU2FPubKey().then(({ pubKey }) => pubKey);
+					return pubKeyPromise;
+				};
+				const pairCurrentDevice = async () => {
+					const pubKey = await getPubKey();
+					await pairDevice({
+						device,
+						getPairing: (confidentialityKey) => client.onboarding.pairDevicePartition.mutate({
+							pubKey,
+							onboardingId: __onboardingId,
+							data: {
+								confidentialityKeyCurve25519: confidentialityKey.confidentialityKeyCurve25519,
+								confidentialityKeySignature: confidentialityKey.confidentialityKeySignature
+							}
+						})
+					});
+				};
+				const refreshCurrentPsk = async () => {
+					const pubKey = await getPubKey();
+					await refreshPsk({
+						device,
+						getRefreshPskData: (data) => client.onboarding.refreshPsk.mutate({
+							pubKey,
+							onboardingId: __onboardingId,
+							data
+						})
+					});
+				};
+				await match([status, pskEnabled]).with(["NO_PAIRING", false], async () => {
+					await pairCurrentDevice();
+				}).with(["NO_PAIRING", true], async () => {
+					await pairCurrentDevice();
+					await refreshCurrentPsk();
+				}).with(["PSK_MISSING", false], async () => {}).with(["PSK_MISSING", true], async () => {
+					await refreshCurrentPsk();
+				}).exhaustive();
 			}
 			return {
 				claimDevice: async (params) => {
@@ -635,11 +770,7 @@ function createEngine(options, logger) {
 				reviewSharedOwner: async (challenge, params) => {
 					await enforcePairing();
 					const { pubKey } = await device.getU2FPubKey();
-					await device.startKPatternAsResponder({
-						handshake: challenge.handshake,
-						handshakeAttestation: challenge.handshakeAttestation,
-						partitionId: challenge.partitionId
-					});
+					await openSecureChannel(device, challenge);
 					await params?.onScreenDisplayed?.();
 					const signature = await device.validateVaultOperation({ actions: challenge.wActions });
 					await client.onboarding.submitReviewByMasterAdminSignature.mutate({
@@ -651,11 +782,7 @@ function createEngine(options, logger) {
 				reviewExternalSigners: async (challenge, params) => {
 					await enforcePairing();
 					const { pubKey } = await device.getU2FPubKey();
-					await device.startKPatternAsResponder({
-						handshake: challenge.handshake,
-						handshakeAttestation: challenge.handshakeAttestation,
-						partitionId: challenge.partitionId
-					});
+					await openSecureChannel(device, challenge);
 					await params?.onScreenDisplayed?.();
 					const signature = await device.validateVaultOperation({ actions: challenge.wActions });
 					await client.onboarding.submitExternalSignersRegistration.mutate({
@@ -667,11 +794,7 @@ function createEngine(options, logger) {
 				collectSeedFragment: async (challenge, params) => {
 					await enforcePairing();
 					const [{ pubKey }, { attestation }] = await Promise.all([device.getU2FPubKey(), device.getAttestation()]);
-					await device.startKPatternAsResponder({
-						handshake: challenge.handshake,
-						handshakeAttestation: challenge.handshakeAttestation,
-						partitionId: challenge.partitionId
-					});
+					await openSecureChannel(device, challenge);
 					await params?.onScreenDisplayed?.();
 					const challengeResponse = await device.validateVaultOperation({ actions: challenge.wActions });
 					const kkPattern = await device.startKKPatternAsResponder({
@@ -767,22 +890,53 @@ function createEngine(options, logger) {
 		});
 		if (engine.device && engine.__workspaceName && engine.__psdToken) decorate((engine) => {
 			const { client, device } = engine;
+			const isPskEnabled = async () => {
+				try {
+					return await client.debug.getPskFeatureFlag.query() === true;
+				} catch {
+					return false;
+				}
+			};
 			async function enforcePairing() {
-				if (await device.hasPairing()) return;
-				const confidentialityKey = await device.getConfidentialityKey();
-				const pairing = await client.debug.pairDevicePartition.mutate({
-					confidentialityKeyCurve25519: confidentialityKey.confidentialityKeyCurve25519,
-					confidentialityKeySignature: confidentialityKey.confidentialityKeySignature
-				});
-				await device.setPairing({ pairing });
+				const status = await device.hasPairing();
+				if (status === "OK") return;
+				const pskEnabled = await isPskEnabled();
+				const pairCurrentDevice = async () => {
+					await pairDevice({
+						device,
+						getPairing: (confidentialityKey) => client.debug.pairDevicePartition.mutate({
+							confidentialityKeyCurve25519: confidentialityKey.confidentialityKeyCurve25519,
+							confidentialityKeySignature: confidentialityKey.confidentialityKeySignature
+						})
+					});
+				};
+				const refreshCurrentPsk = async () => {
+					await refreshPsk({
+						device,
+						getRefreshPskData: (data) => client.debug.refreshPsk.mutate(data)
+					});
+				};
+				await match([status, pskEnabled]).with(["NO_PAIRING", false], async () => {
+					await pairCurrentDevice();
+				}).with(["NO_PAIRING", true], async () => {
+					await pairCurrentDevice();
+					await refreshCurrentPsk();
+				}).with(["PSK_MISSING", false], async () => {}).with(["PSK_MISSING", true], async () => {
+					await refreshCurrentPsk();
+				}).exhaustive();
 			}
 			const approveChallenge = async (challenge, params) => {
 				await enforcePairing();
-				await device.startKPatternAsResponder({
-					handshake: challenge.handshake,
-					handshakeAttestation: challenge.handshakeAttestation,
-					partitionId: challenge.partitionId
-				});
+				try {
+					await openSecureChannel(device, challenge);
+				} catch (err) {
+					if (!isPskMissingError(err)) throw err;
+					if (!await isPskEnabled()) logger.warning("Discarding SW_PSK_MISSING: PSK secure channel is disabled");
+					else {
+						await enforcePairing();
+						await openSecureChannel(device, challenge);
+					}
+				}
 				await params?.onScreenDisplayed?.();
 				return await device.validateVaultOperation({ actions: challenge.wActions });
 			};