@trezor/connect 9.7.0-beta.1 → 9.7.0

package/lib/device/workflow/checkFirmwareHash.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.checkFirmwareHash = void 0;
 const crypto_1 = require("crypto");
 const utils_1 = require("@trezor/utils");
@@ -8,77 +11,84 @@ const DataManager_1 = require("../../data/DataManager");
 const firmwareInfo_1 = require("../../data/firmwareInfo");
 const firmwareUtils_1 = require("../../utils/firmwareUtils");
 const createFailResult = (error, errorPayload) => ({
-    success: false,
-    error,
-    errorPayload,
+  success: false,
+  error,
+  errorPayload
 });
-const checkFirmwareHash = async ({ device, logger, }) => {
-    const enabled = DataManager_1.DataManager.getSettings('enableFirmwareHashCheck');
-    if (!enabled)
-        return createFailResult('check-skipped');
-    const firmwareVersion = device.getVersion();
-    if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
-        return null;
-    }
-    const firmwareType = (0, firmwareUtils_1.getFirmwareType)(device.features);
-    const release = await (0, firmwareInfo_1.getReleaseByVersion)(device.features, firmwareVersion, firmwareType);
-    if (!release)
-        return createFailResult('unknown-release');
-    const firmwareLocation = (0, firmwareInfo_1.getFirmwareLocation)({
-        firmwareVersion,
-        remotePath: release.url,
-        deviceModel: device.features.internal_model,
-        firmwareType: (0, firmwareUtils_1.getFirmwareType)(device.features),
-    });
-    const { baseUrl, path } = firmwareLocation;
-    const timeoutThresholdsPerModel = DataManager_1.DataManager.getSettings('firmwareHashCheckTimeouts');
-    if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
-        return null;
-    }
-    const checkSupported = !device.unavailableCapabilities.getFirmwareHash;
-    if (!checkSupported)
-        return createFailResult('check-unsupported');
-    const firmwareBinary = await (0, firmware_1.getBinaryOptional)({
-        baseUrl,
-        path,
-        release,
+const checkFirmwareHash = async ({
+  device,
+  logger
+}) => {
+  const enabled = DataManager_1.DataManager.getSettings('enableFirmwareHashCheck');
+  if (!enabled) return createFailResult('check-skipped');
+  const firmwareVersion = device.getVersion();
+  if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
+    return null;
+  }
+  const firmwareType = (0, firmwareUtils_1.getFirmwareType)(device.features);
+  const release = await (0, firmwareInfo_1.getReleaseByVersion)(device.features, firmwareVersion, firmwareType);
+  if (!release) return createFailResult('unknown-release');
+  const firmwareLocation = (0, firmwareInfo_1.getFirmwareLocation)({
+    firmwareVersion,
+    remotePath: release.url,
+    deviceModel: device.features.internal_model,
+    firmwareType: (0, firmwareUtils_1.getFirmwareType)(device.features)
+  });
+  const {
+    baseUrl,
+    path
+  } = firmwareLocation;
+  const timeoutThresholdsPerModel = DataManager_1.DataManager.getSettings('firmwareHashCheckTimeouts');
+  if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
+    return null;
+  }
+  const checkSupported = !device.unavailableCapabilities.getFirmwareHash;
+  if (!checkSupported) return createFailResult('check-unsupported');
+  const firmwareBinary = await (0, firmware_1.getBinaryOptional)({
+    baseUrl,
+    path,
+    release
+  });
+  if (firmwareBinary === null) {
+    return createFailResult('check-unsupported');
+  }
+  if (firmwareBinary.binary.byteLength < 200) {
+    logger.warn(`Firmware binary for hash check suspiciously small (< 200 b)`);
+    return createFailResult('check-unsupported');
+  }
+  const strippedBinary = (0, firmware_1.stripFwHeaders)(firmwareBinary.binary);
+  const {
+    hash: expectedHash,
+    challenge
+  } = (0, firmware_1.calculateFirmwareHash)({
+    internal_model: device.features.internal_model,
+    firmwareVersion,
+    fw: strippedBinary,
+    key: (0, crypto_1.randomBytes)(32)
+  });
+  try {
+    const ts = performance.now();
+    const deviceResponse = await device.getCurrentSession().typedCall('GetFirmwareHash', 'FirmwareHash', {
+      challenge
     });
-    if (firmwareBinary === null) {
-        return createFailResult('check-unsupported');
-    }
-    if (firmwareBinary.binary.byteLength < 200) {
-        logger.warn(`Firmware binary for hash check suspiciously small (< 200 b)`);
-        return createFailResult('check-unsupported');
+    if (!deviceResponse?.message?.hash) {
+      return createFailResult('other-error', 'Device response is missing hash');
     }
-    const strippedBinary = (0, firmware_1.stripFwHeaders)(firmwareBinary.binary);
-    const { hash: expectedHash, challenge } = (0, firmware_1.calculateFirmwareHash)({
-        internal_model: device.features.internal_model,
-        firmwareVersion,
-        fw: strippedBinary,
-        key: (0, crypto_1.randomBytes)(32),
-    });
-    try {
-        const ts = performance.now();
-        const deviceResponse = await device
-            .getCurrentSession()
-            .typedCall('GetFirmwareHash', 'FirmwareHash', { challenge });
-        if (!deviceResponse?.message?.hash) {
-            return createFailResult('other-error', 'Device response is missing hash');
-        }
-        if (deviceResponse.message.hash !== expectedHash) {
-            return createFailResult('hash-mismatch');
-        }
-        const duration = performance.now() - ts;
-        logger.debug('GetFirmwareHash time', duration);
-        const timeoutThreshold = timeoutThresholdsPerModel?.[device.features.internal_model];
-        if (timeoutThreshold !== undefined && duration > timeoutThreshold) {
-            return createFailResult('takes-too-long');
-        }
-        return { success: true };
+    if (deviceResponse.message.hash !== expectedHash) {
+      return createFailResult('hash-mismatch');
     }
-    catch (errorPayload) {
-        return createFailResult('other-error', (0, utils_1.serializeError)(errorPayload));
+    const duration = performance.now() - ts;
+    logger.debug('GetFirmwareHash time', duration);
+    const timeoutThreshold = timeoutThresholdsPerModel?.[device.features.internal_model];
+    if (timeoutThreshold !== undefined && duration > timeoutThreshold) {
+      return createFailResult('takes-too-long');
     }
+    return {
+      success: true
+    };
+  } catch (errorPayload) {
+    return createFailResult('other-error', (0, utils_1.serializeError)(errorPayload));
+  }
 };
 exports.checkFirmwareHash = checkFirmwareHash;
 //# sourceMappingURL=checkFirmwareHash.js.map

package/lib/device/workflow/checkFirmwareHashWithRetries.js

@@ -1,41 +1,44 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.checkFirmwareHashWithRetries = void 0;
 const utils_1 = require("@trezor/utils");
 const constants_1 = require("../../constants");
 const checkFirmwareHash_1 = require("./checkFirmwareHash");
 const PROBE_CHECK_TIME_RETRIES = 4;
-const probeCheckTime = async (context) => {
-    for (let i = 0; i < PROBE_CHECK_TIME_RETRIES; i++) {
-        const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
-        if (result !== null && (result.success || result.error !== 'takes-too-long')) {
-            context.device.setAuthenticityChecks(result);
-            return;
-        }
+const probeCheckTime = async context => {
+  for (let i = 0; i < PROBE_CHECK_TIME_RETRIES; i++) {
+    const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
+    if (result !== null && (result.success || result.error !== 'takes-too-long')) {
+      context.device.setAuthenticityChecks(result);
+      return;
     }
+  }
 };
-const checkFirmwareHashWithRetries = async (context) => {
-    const lastResult = context.device.getAuthenticityChecks().firmwareHash;
-    const notDoneYet = lastResult === null;
-    const attemptsDone = lastResult?.attemptCount ?? 0;
-    if (attemptsDone >= constants_1.FIRMWARE.HASH_CHECK_MAX_ATTEMPTS)
-        return;
-    const wasError = lastResult !== null && !lastResult.success;
-    const wasErrorRetriable = wasError && (0, utils_1.isArrayMember)(lastResult.error, constants_1.FIRMWARE.HASH_CHECK_RETRIABLE_ERRORS);
-    const lastErrorPayload = wasError ? lastResult?.errorPayload : null;
-    if (notDoneYet || wasErrorRetriable) {
-        const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
-        context.device.setAuthenticityChecks(result);
-        if (result === null)
-            return;
-        result.attemptCount = attemptsDone + 1;
-        if (!result.success && result.error === 'takes-too-long') {
-            await probeCheckTime(context);
-        }
-        if (result.success && lastErrorPayload) {
-            result.warningPayload = { lastErrorPayload };
-        }
+const checkFirmwareHashWithRetries = async context => {
+  const lastResult = context.device.getAuthenticityChecks().firmwareHash;
+  const notDoneYet = lastResult === null;
+  const attemptsDone = lastResult?.attemptCount ?? 0;
+  if (attemptsDone >= constants_1.FIRMWARE.HASH_CHECK_MAX_ATTEMPTS) return;
+  const wasError = lastResult !== null && !lastResult.success;
+  const wasErrorRetriable = wasError && (0, utils_1.isArrayMember)(lastResult.error, constants_1.FIRMWARE.HASH_CHECK_RETRIABLE_ERRORS);
+  const lastErrorPayload = wasError ? lastResult?.errorPayload : null;
+  if (notDoneYet || wasErrorRetriable) {
+    const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
+    context.device.setAuthenticityChecks(result);
+    if (result === null) return;
+    result.attemptCount = attemptsDone + 1;
+    if (!result.success && result.error === 'takes-too-long') {
+      await probeCheckTime(context);
     }
+    if (result.success && lastErrorPayload) {
+      result.warningPayload = {
+        lastErrorPayload
+      };
+    }
+  }
 };
 exports.checkFirmwareHashWithRetries = checkFirmwareHashWithRetries;
 //# sourceMappingURL=checkFirmwareHashWithRetries.js.map

package/lib/device/workflow/handshake.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.handshakeCancel = void 0;
 const protocol_1 = require("@trezor/protocol");
 const transport_1 = require("@trezor/transport");
@@ -7,48 +10,54 @@ const utils_1 = require("@trezor/utils");
 const errors_1 = require("../../constants/errors");
 const CANCEL_TIMEOUT = 1_000;
 const ATTEMPTS_LIMIT = 10;
-const isLegacyBridge = (transport) => transport.name === 'BridgeTransport' &&
-    !utils_1.versionUtils.isNewerOrEqual(transport.version, '3.0.0');
-const handshakeCancel = async ({ device, logger, signal }) => {
-    if (device.features || device.getThpState()?.properties) {
-        return;
+const isLegacyBridge = transport => transport.name === 'BridgeTransport' && !utils_1.versionUtils.isNewerOrEqual(transport.version, '3.0.0');
+const handshakeCancel = async ({
+  device,
+  logger,
+  signal
+}) => {
+  if (device.features || device.getThpState()?.properties) {
+    return;
+  }
+  const timeout = device.possibleT1 ? CANCEL_TIMEOUT : undefined;
+  logger?.debug('handshake Cancel start');
+  const send = await device.getCurrentSession().send('Cancel', {}, {
+    signal,
+    timeout
+  });
+  if (!send.success) {
+    logger?.debug(`handshake Cancel send error ${send.error}`);
+    return;
+  }
+  logger?.debug('handshake Cancel sent');
+  for (let attempt = 0; attempt < ATTEMPTS_LIMIT; ++attempt) {
+    logger?.debug(`handshake Cancel read attempt ${attempt}`);
+    const result = await device.getCurrentSession().receive({
+      signal,
+      timeout
+    });
+    if (!result.success && result.error.message === transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
+      if (isLegacyBridge(device.transport)) {
+        await (0, utils_1.resolveAfter)(501);
+      }
+      await device.acquire();
     }
-    const timeout = device.possibleT1 ? CANCEL_TIMEOUT : undefined;
-    logger?.debug('handshake Cancel start');
-    const send = await device.getCurrentSession().send('Cancel', {}, { signal, timeout });
-    if (!send.success) {
-        logger?.debug(`handshake Cancel send error ${send.error}`);
-        return;
+    if (!result.success && result.error.message !== protocol_1.PROTOCOL_MALFORMED) {
+      logger?.debug(`handshake Cancel read error: ${result.error}`);
+      return;
+    } else if (result.success) {
+      logger?.debug(`handshake Cancel read success: ${result.payload.type}`);
+      if (result.payload.type === 'Failure' && result.payload.message.code === 'Failure_InvalidProtocol') {
+        logger?.debug(`handshake Cancel protocol v2 detected`);
+        await device.setupThp();
+      }
+      if (result.payload.type === 'Failure' && result.payload.message.code === 'Failure_Busy') {
+        throw (0, errors_1.TypedError)(result.payload.message.code, result.payload.message.message);
+      }
+      return;
     }
-    logger?.debug('handshake Cancel sent');
-    for (let attempt = 0; attempt < ATTEMPTS_LIMIT; ++attempt) {
-        logger?.debug(`handshake Cancel read attempt ${attempt}`);
-        const result = await device.getCurrentSession().receive({ signal, timeout });
-        if (!result.success && result.error.message === transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
-            if (isLegacyBridge(device.transport)) {
-                await (0, utils_1.resolveAfter)(501);
-            }
-            await device.acquire();
-        }
-        if (!result.success && result.error.message !== protocol_1.PROTOCOL_MALFORMED) {
-            logger?.debug(`handshake Cancel read error: ${result.error}`);
-            return;
-        }
-        else if (result.success) {
-            logger?.debug(`handshake Cancel read success: ${result.payload.type}`);
-            if (result.payload.type === 'Failure' &&
-                result.payload.message.code === 'Failure_InvalidProtocol') {
-                logger?.debug(`handshake Cancel protocol v2 detected`);
-                await device.setupThp();
-            }
-            if (result.payload.type === 'Failure' &&
-                result.payload.message.code === 'Failure_Busy') {
-                throw (0, errors_1.TypedError)(result.payload.message.code, result.payload.message.message);
-            }
-            return;
-        }
-    }
-    logger?.debug(`handshake Cancel attempts limit reached`);
+  }
+  logger?.debug(`handshake Cancel attempts limit reached`);
 };
 exports.handshakeCancel = handshakeCancel;
 //# sourceMappingURL=handshake.js.map

package/lib/device/workflow/index.js

@@ -1,6 +1,14 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.validateState = void 0;
 var validateState_1 = require("./validateState");
-Object.defineProperty(exports, "validateState", { enumerable: true, get: function () { return validateState_1.validateState; } });
+Object.defineProperty(exports, "validateState", {
+  enumerable: true,
+  get: function () {
+    return validateState_1.validateState;
+  }
+});
 //# sourceMappingURL=index.js.map

package/lib/device/workflow/trezorPushNotification.js

@@ -1,77 +1,81 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.trezorPushNotificationHandler = void 0;
 const protocol_1 = require("@trezor/protocol");
 const utils_1 = require("@trezor/utils");
 const device_1 = require("../../events/device");
 const thp_1 = require("../thp");
 const setupDeviceMode = async (device, mode) => {
-    if (mode === protocol_1.TrezorPushNotificationMode.BootloaderMode && !device.features) {
-        device.setBusy('rebooting');
-        await device.acquire();
-        await device.getFeatures();
-        await device.release();
+  if (mode === protocol_1.TrezorPushNotificationMode.BootloaderMode && !device.features) {
+    device.setBusy('rebooting');
+    await device.acquire();
+    await device.getFeatures();
+    await device.release();
+  }
+  if (mode === protocol_1.TrezorPushNotificationMode.NormalMode && (!device.features || !device.getThpState())) {
+    device.setBusy('rebooting');
+    await device.setupThp();
+    await device.acquire();
+    await (0, utils_1.resolveAfter)(1000);
+    await (0, thp_1.getThpChannel)(device, false);
+    if (device.getThpState()?.phase === 'paired') {
+      await device.getFeatures();
+    } else {
+      device.setBusy('thp-locked');
+      device.lifecycle.emit(device_1.DEVICE.CHANGED);
     }
-    if (mode === protocol_1.TrezorPushNotificationMode.NormalMode &&
-        (!device.features || !device.getThpState())) {
-        device.setBusy('rebooting');
-        await device.setupThp();
+    await device.release();
+  }
+};
+const trezorPushNotificationHandler = async ({
+  device,
+  message
+}) => {
+  const decodedResult = protocol_1.tpn.decode(message);
+  if (!decodedResult.success) return;
+  const decoded = decodedResult.payload;
+  device.lifecycle.emit(device_1.DEVICE.TREZOR_PUSH_NOTIFICATION, decoded);
+  const {
+    type,
+    mode
+  } = decoded;
+  const modeChanged = mode === protocol_1.TrezorPushNotificationMode.BootloaderMode && (device.getThpState()?.properties || device.features && !device.features.bootloader_mode) || mode === protocol_1.TrezorPushNotificationMode.NormalMode && device.features?.bootloader_mode;
+  if (modeChanged) {
+    device.reset();
+    device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'rebooting');
+    device.lifecycle.emit(device_1.DEVICE.CHANGED);
+  }
+  switch (type) {
+    case protocol_1.TrezorPushNotificationType.SETTING_CHANGE:
+    case protocol_1.TrezorPushNotificationType.PIN_CHANGE:
+    case protocol_1.TrezorPushNotificationType.NOTIFY_POWER_STATUS_CHANGE:
+      if (!device.isUsed()) {
         await device.acquire();
-        await (0, utils_1.resolveAfter)(1000);
-        await (0, thp_1.getThpChannel)(device, false);
-        if (device.getThpState()?.phase === 'paired') {
-            await device.getFeatures();
-        }
-        else {
-            device.setBusy('thp-locked');
-            device.lifecycle.emit(device_1.DEVICE.CHANGED);
-        }
+        await device.getFeatures();
         await device.release();
-    }
-};
-const trezorPushNotificationHandler = async ({ device, message }) => {
-    const decoded = protocol_1.tpn.decode(message);
-    device.lifecycle.emit(device_1.DEVICE.TREZOR_PUSH_NOTIFICATION, decoded);
-    const { type, mode } = decoded;
-    const modeChanged = (mode === protocol_1.TrezorPushNotificationMode.BootloaderMode &&
-        (device.getThpState()?.properties ||
-            (device.features && !device.features.bootloader_mode))) ||
-        (mode === protocol_1.TrezorPushNotificationMode.NormalMode && device.features?.bootloader_mode);
-    if (modeChanged) {
-        device.reset();
-        device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'rebooting');
-        device.lifecycle.emit(device_1.DEVICE.CHANGED);
-    }
-    switch (type) {
-        case protocol_1.TrezorPushNotificationType.SETTING_CHANGE:
-        case protocol_1.TrezorPushNotificationType.PIN_CHANGE:
-        case protocol_1.TrezorPushNotificationType.NOTIFY_POWER_STATUS_CHANGE:
-            if (!device.isUsed()) {
-                await device.acquire();
-                await device.getFeatures();
-                await device.release();
-            }
-            break;
-        case protocol_1.TrezorPushNotificationType.LOCK:
-            device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode
-                ? 'bootloader-locked'
-                : 'hard-locked');
-            device.lifecycle.emit(device_1.DEVICE.CHANGED);
-            break;
-        case protocol_1.TrezorPushNotificationType.UNLOCK:
-            await setupDeviceMode(device, decoded.mode);
-            break;
-        case protocol_1.TrezorPushNotificationType.SOFTLOCK:
-            device.setBusy('pin-locked');
-            device.lifecycle.emit(device_1.DEVICE.CHANGED);
-            break;
-        case protocol_1.TrezorPushNotificationType.SOFTUNLOCK:
-            device.setBusy(device.features ? undefined : 'thp-locked');
-            device.lifecycle.emit(device_1.DEVICE.CHANGED);
-            break;
-        default:
-            break;
-    }
+      }
+      break;
+    case protocol_1.TrezorPushNotificationType.LOCK:
+      device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'hard-locked');
+      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+      break;
+    case protocol_1.TrezorPushNotificationType.UNLOCK:
+      await setupDeviceMode(device, decoded.mode);
+      break;
+    case protocol_1.TrezorPushNotificationType.SOFTLOCK:
+      device.setBusy('pin-locked');
+      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+      break;
+    case protocol_1.TrezorPushNotificationType.SOFTUNLOCK:
+      device.setBusy(device.features ? undefined : 'thp-locked');
+      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+      break;
+    default:
+      break;
+  }
 };
 exports.trezorPushNotificationHandler = trezorPushNotificationHandler;
 //# sourceMappingURL=trezorPushNotification.js.map