@trezor/connect 9.1.4 → 9.1.5

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+# 9.1.5
+
+-   feat(suite): T2B1 replace Model R name by official Trezor Safe 3 name (7460372ed1)
+-   feat(connect): add authenticateDevice method (45b99c0813, af907a296d, 249ddc358a)
+-   feat(connect): btg, dash, dgb, nmc, vrc no support for T2B1 (0819ff6fc1)
+-   feat(suite): support t2b1 firmware installation (9ef2bf627a)
+-   fix(connect): get firmware status and release after ensuring internal model (dca3333c2d)
+-   fix(connect-popup): webusb in popup if iframe is on same origin as host (e571971586)
+-   feat(connect-web): trust-issues query string param (b1b6e3f287)
+-   feat(connect-plugin-stellar): Update stellar-sdk and stellar-base (ee7e67db04)
+-   chore(connect): t1 emulator with pin (33c6ca58bf)
+-   fix(connect-popup): allow decimal custom fee entry (bf20f23f05, 8a8d93b5e8)
+-   feat(connect-explorer): add rebootToBootloader method (9996676358)
+-   fix(connect): wrong version format in discovery (19b13d1d4c)
+-   feat(connect-popup): logger in sharedworker collecting from all environments (732bc7d, 2521c7c, 6501dfa4fd)
+-   chore(connect): do not lowercase device color (7229b88c20)
+
 # 9.1.4
 
 -   feat(connect-popup): add metamask extension id to known third party (f137b3e4d6)

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.1.4
+API version 9.1.5
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)

package/lib/api/authenticateDevice.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { AuthenticateDeviceParams } from '../types/api/authenticateDevice';
+export default class AuthenticateDevice extends AbstractMethod<'authenticateDevice', AuthenticateDeviceParams> {
+    init(): void;
+    run(): Promise<import("../types/api/authenticateDevice").AuthenticateDeviceResult>;
+}
+//# sourceMappingURL=authenticateDevice.d.ts.map

package/lib/api/authenticateDevice.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+const paramsValidator_1 = require("./common/paramsValidator");
+const deviceAuthenticityConfig_1 = require("../data/deviceAuthenticityConfig");
+const verifyAuthenticityProof_1 = require("./firmware/verifyAuthenticityProof");
+class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useEmptyPassphrase = true;
+        this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'config', type: 'object' },
+            { name: 'allowDebugKeys', type: 'boolean' },
+        ]);
+        if (payload.config) {
+            (0, paramsValidator_1.validateParams)(payload.config, [{ name: 'timestamp', type: 'string', required: true }]);
+            (0, paramsValidator_1.validateParams)(payload.config.T2B1, [
+                { name: 'rootPubKeys', type: 'array', required: true },
+                { name: 'caPubKeys', type: 'array', required: true },
+            ]);
+        }
+        this.params = {
+            config: payload.config,
+            allowDebugKeys: payload.allowDebugKeys,
+        };
+    }
+    async run() {
+        const challenge = (0, verifyAuthenticityProof_1.getRandomChallenge)();
+        const { message } = await this.device
+            .getCommands()
+            .typedCall('AuthenticateDevice', 'AuthenticityProof', {
+            challenge: challenge.toString('hex'),
+        });
+        const config = this.params.config || deviceAuthenticityConfig_1.deviceAuthenticityConfig;
+        const valid = await (0, verifyAuthenticityProof_1.verifyAuthenticityProof)({
+            ...message,
+            challenge,
+            config,
+            allowDebugKeys: this.params.allowDebugKeys,
+            deviceModel: this.device.features.internal_model,
+        });
+        return valid;
+    }
+}
+exports.default = AuthenticateDevice;
+//# sourceMappingURL=authenticateDevice.js.map

package/lib/api/checkFirmwareAuthenticity.js

@@ -14,15 +14,17 @@ class CheckFirmwareAuthenticity extends AbstractMethod_1.AbstractMethod {
         this.useDeviceState = false;
     }
     async run() {
+        var _a;
         const { device } = this;
-        const deviceVersion = `${device.features.major_version}.${device.features.minor_version}.${device.features.patch_version}`;
-        const releases = (0, firmwareInfo_1.getReleases)(device.features.major_version);
-        const release = releases.find(release => release.version.join('.') === deviceVersion);
+        const firmwareVersion = `${device.features.major_version}.${device.features.minor_version}.${device.features.patch_version}`;
+        const releases = (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model);
+        const release = releases.find(release => release.version.join('.') === firmwareVersion);
         if (!release) {
             throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: No release found for device firmware');
         }
-        const baseUrl = `https://data.trezor.io/firmware/${device.features.major_version}`;
-        const fwUrl = `${baseUrl}/trezor-${deviceVersion}${device.firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly.bin' : '.bin'}`;
+        const deviceModelPath = `${device.features.internal_model}`.toLowerCase();
+        const baseUrl = `https://data.trezor.io/firmware/${deviceModelPath}`;
+        const fwUrl = `${baseUrl}/trezor-${deviceModelPath}-${firmwareVersion}${device.firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly.bin' : '.bin'}`;
         const fw = await (0, assets_1.httpRequest)(fwUrl, 'binary');
         if (!fw) {
             throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: firmware binary not found');

package/lib/api/common/paramsValidator.js

@@ -68,25 +68,22 @@ const validateCoinPath = (path, coinInfo) => {
 };
 exports.validateCoinPath = validateCoinPath;
 const getFirmwareRange = (method, coinInfo, currentRange) => {
-    const current = JSON.parse(JSON.stringify(currentRange));
+    const range = JSON.parse(JSON.stringify(currentRange));
+    const models = Object.keys(range);
     if (coinInfo) {
-        if (!coinInfo.support || typeof coinInfo.support.trezor1 !== 'string') {
-            current['1'].min = '0';
-        }
-        else if (utils_1.versionUtils.isNewer(coinInfo.support.trezor1, current['1'].min)) {
-            current['1'].min = coinInfo.support.trezor1;
-        }
-        if (!coinInfo.support || typeof coinInfo.support.trezor2 !== 'string') {
-            current['2'].min = '0';
-        }
-        else if (utils_1.versionUtils.isNewer(coinInfo.support.trezor2, current['2'].min)) {
-            current['2'].min = coinInfo.support.trezor2;
-        }
+        models.forEach(model => {
+            if (!coinInfo.support || typeof coinInfo.support[model] !== 'string') {
+                range[model].min = '0';
+            }
+            else if (range[model].min !== '0' &&
+                utils_1.versionUtils.isNewer(coinInfo.support[model], range[model].min)) {
+                range[model].min = coinInfo.support[model];
+            }
+        });
     }
-    const coinType = coinInfo ? coinInfo.type : null;
-    const shortcut = coinInfo ? coinInfo.shortcut.toLowerCase() : null;
-    const { supportedFirmware } = config_1.config;
-    const ranges = supportedFirmware
+    const coinType = coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.type;
+    const shortcut = coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.shortcut.toLowerCase();
+    const configRules = config_1.config.supportedFirmware
         .filter(rule => {
         if (rule.methods) {
             return rule.methods.includes(method);
@@ -96,45 +93,42 @@ const getFirmwareRange = (method, coinInfo, currentRange) => {
         }
         return true;
     })
-        .filter(c => {
-        if (c.coinType) {
-            return c.coinType === coinType;
+        .filter(rule => {
+        if (rule.coinType) {
+            return rule.coinType === coinType;
         }
-        if (c.coin) {
-            return (typeof c.coin === 'string' ? [c.coin] : c.coin).includes(shortcut);
+        if (rule.coin) {
+            return (typeof rule.coin === 'string' ? [rule.coin] : rule.coin).includes(shortcut);
         }
-        return c.methods || c.capabilities;
+        return rule.methods || rule.capabilities;
     });
-    ranges.forEach(range => {
-        const { min, max } = range;
-        if (min) {
-            const [t1, t2] = min;
-            if (t1 === '0' ||
-                current['1'].min === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['1'].min, t1)) {
-                current['1'].min = t1;
-            }
-            if (t2 === '0' ||
-                current['2'].min === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['2'].min, t2)) {
-                current['2'].min = t2;
-            }
-        }
-        if (max) {
-            const [t1, t2] = max;
-            if (t1 === '0' ||
-                current['1'].max === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['1'].max, t1)) {
-                current['1'].max = t1;
-            }
-            if (t2 === '0' ||
-                current['2'].max === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['2'].max, t2)) {
-                current['2'].max = t2;
-            }
+    configRules.forEach(rule => {
+        if (rule.min) {
+            models.forEach(model => {
+                const modelMin = rule.min[model];
+                if (modelMin) {
+                    if (modelMin === '0' ||
+                        range[model].min === '0' ||
+                        !utils_1.versionUtils.isNewerOrEqual(range[model].min, modelMin)) {
+                        range[model].min = modelMin;
+                    }
+                }
+            });
+        }
+        if (rule.max) {
+            models.forEach(model => {
+                const modelMax = rule.max[model];
+                if (modelMax) {
+                    if (modelMax === '0' ||
+                        range[model].max === '0' ||
+                        !utils_1.versionUtils.isNewerOrEqual(range[model].max, modelMax)) {
+                        range[model].max = modelMax;
+                    }
+                }
+            });
         }
     });
-    return current;
+    return range;
 };
 exports.getFirmwareRange = getFirmwareRange;
 //# sourceMappingURL=paramsValidator.js.map

package/lib/api/ethereum/ethereumDefinitions.js

@@ -93,8 +93,9 @@ const ethereumNetworkInfoFromDefinition = (definition) => ({
     shortcut: definition.symbol,
     support: {
         connect: true,
-        trezor1: '1.6.2',
-        trezor2: '2.0.7',
+        T1B1: '1.6.2',
+        T2T1: '2.0.7',
+        T2B1: '2.6.1',
     },
     blockchainLink: undefined,
 });

package/lib/api/firmware/getBinary.js

@@ -10,7 +10,7 @@ const getBinary = ({ features, releases, baseUrl, version, btcOnly, intermediary
         throw new Error('Features of unexpected shape provided');
     }
     if (intermediaryVersion) {
-        return (0, assets_1.httpRequest)(`${baseUrl}/firmware/1/trezor-inter-v${intermediaryVersion}.bin`, 'binary');
+        return (0, assets_1.httpRequest)(`${baseUrl}/firmware/t1b1/trezor-t1b1-inter-v${intermediaryVersion}.bin`, 'binary');
     }
     const infoByBootloader = (0, firmwareInfo_1.getInfo)({ features, releases });
     const releaseByFirmware = releases.find(r => version &&

package/lib/api/firmware/verifyAuthenticityProof.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { PROTO } from '../../constants';
+import { DeviceAuthenticityConfig } from '../../data/deviceAuthenticityConfig';
+import { AuthenticateDeviceResult } from '../../types/api/authenticateDevice';
+interface AuthenticityProofData extends PROTO.AuthenticityProof {
+    challenge: Buffer;
+    config: DeviceAuthenticityConfig;
+    allowDebugKeys?: boolean;
+    deviceModel: keyof typeof PROTO.DeviceModelInternal;
+}
+export declare const getRandomChallenge: () => Buffer;
+export declare const verifyAuthenticityProof: ({ certificates, signature, challenge, config, allowDebugKeys, deviceModel, }: AuthenticityProofData) => Promise<AuthenticateDeviceResult>;
+export {};
+//# sourceMappingURL=verifyAuthenticityProof.d.ts.map

package/lib/api/firmware/verifyAuthenticityProof.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAuthenticityProof = exports.getRandomChallenge = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const utils_1 = require("@trezor/utils");
+const x509certificate_1 = require("./x509certificate");
+const verifySignature = async (rawKey, data, signature) => {
+    const signer = crypto.createVerify('sha256');
+    signer.update(Buffer.from(data));
+    const SubtleCrypto = typeof window !== 'undefined' ? window.crypto.subtle : crypto.subtle;
+    if (!SubtleCrypto) {
+        throw new Error('SubtleCrypto not supported');
+    }
+    const ecPubKey = await SubtleCrypto.importKey('raw', rawKey, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['verify']);
+    const spkiPubKey = await SubtleCrypto.exportKey('spki', ecPubKey);
+    const key = `-----BEGIN PUBLIC KEY-----\n${Buffer.from(spkiPubKey).toString('base64')}\n-----END PUBLIC KEY-----`;
+    return signer.verify({ key }, Buffer.from(signature));
+};
+const getRandomChallenge = () => crypto.randomBytes(32);
+exports.getRandomChallenge = getRandomChallenge;
+const verifyAuthenticityProof = async ({ certificates, signature, challenge, config, allowDebugKeys, deviceModel, }) => {
+    const modelConfig = config[deviceModel];
+    if (!modelConfig) {
+        throw new Error(`Pubkeys for ${deviceModel} not found in config`);
+    }
+    const { caPubKeys, debug } = modelConfig;
+    const caCert = (0, x509certificate_1.parseCertificate)(new Uint8Array(Buffer.from(certificates[1], 'hex')));
+    const caPubKey = Buffer.from(caCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes).toString('hex');
+    const deviceCert = (0, x509certificate_1.parseCertificate)(new Uint8Array(Buffer.from(certificates[0], 'hex')));
+    const rootPubKeys = allowDebugKeys
+        ? modelConfig.rootPubKeys.concat((debug === null || debug === void 0 ? void 0 : debug.rootPubKeys) || [])
+        : modelConfig.rootPubKeys;
+    const isCertSignedByRootPubkey = await Promise.all(rootPubKeys.map(rootPubKey => verifySignature(Buffer.from(rootPubKey, 'hex'), caCert.tbsCertificate.asn1.raw, caCert.signatureValue.bits.bytes)));
+    const rootPubKeyIndex = isCertSignedByRootPubkey.findIndex(valid => !!valid);
+    const rootPubKey = rootPubKeys[rootPubKeyIndex];
+    const isDebugRootPubKey = debug === null || debug === void 0 ? void 0 : debug.rootPubKeys.includes(rootPubKey);
+    const caCertValidityFrom = caCert.tbsCertificate.validity.from.getTime();
+    if (caCertValidityFrom > new Date().getTime()) {
+        throw new Error(`CA validity from ${caCertValidityFrom} cant't be in the future!`);
+    }
+    if (!rootPubKey) {
+        const configExpired = new Date(config.timestamp).getTime() < caCertValidityFrom;
+        return {
+            valid: false,
+            configExpired,
+            caPubKey,
+            error: 'ROOT_PUBKEY_NOT_FOUND',
+        };
+    }
+    const [subject] = deviceCert.tbsCertificate.subject;
+    if (!subject.parameters || subject.algorithm !== '2.5.4.3') {
+        throw new Error('Missing certificate subject');
+    }
+    const subjectValue = Buffer.from(subject.parameters.asn1.contents.subarray(0, 4)).toString();
+    if (subjectValue !== deviceModel) {
+        return {
+            valid: false,
+            caPubKey,
+            error: 'INVALID_DEVICE_MODEL',
+        };
+    }
+    const isDeviceCertValid = await verifySignature(Buffer.from(caCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes), deviceCert.tbsCertificate.asn1.raw, deviceCert.signatureValue.bits.bytes);
+    const challengePrefix = Buffer.from('AuthenticateDevice:');
+    const prefixedChallenge = Buffer.concat([
+        utils_1.bufferUtils.getChunkSize(challengePrefix.length),
+        challengePrefix,
+        utils_1.bufferUtils.getChunkSize(challenge.length),
+        challenge,
+    ]);
+    const isSignatureValid = await verifySignature(Buffer.from(deviceCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes), prefixedChallenge, Buffer.from(signature, 'hex'));
+    if (rootPubKey && isDeviceCertValid && isSignatureValid) {
+        if ((!isDebugRootPubKey && !caPubKeys.includes(caPubKey)) ||
+            (isDebugRootPubKey && !(debug === null || debug === void 0 ? void 0 : debug.caPubKeys.includes(caPubKey)))) {
+            const configExpired = new Date(config.timestamp).getTime() < caCertValidityFrom;
+            return {
+                valid: false,
+                configExpired,
+                caPubKey,
+                error: 'CA_PUBKEY_NOT_FOUND',
+            };
+        }
+        return {
+            valid: true,
+            caPubKey,
+            debugKey: isDebugRootPubKey,
+        };
+    }
+    if (!isDeviceCertValid) {
+        return {
+            valid: false,
+            caPubKey,
+            error: 'INVALID_DEVICE_CERTIFICATE',
+        };
+    }
+    return {
+        valid: false,
+        caPubKey,
+        error: 'INVALID_DEVICE_SIGNATURE',
+    };
+};
+exports.verifyAuthenticityProof = verifyAuthenticityProof;
+//# sourceMappingURL=verifyAuthenticityProof.js.map

package/lib/api/firmware/x509certificate.d.ts

@@ -0,0 +1,73 @@
+interface Asn1 {
+    cls: number;
+    tag: number;
+    structured: boolean;
+    byteLength: number;
+    contents: Uint8Array;
+    raw: Uint8Array;
+}
+export declare const parseName: (asn1: Asn1) => {
+    asn1: Asn1;
+    algorithm: string;
+    parameters: {
+        asn1: Asn1;
+    } | null;
+}[];
+export declare const parseCertificate: (byteArray: Uint8Array) => {
+    asn1: Asn1;
+    tbsCertificate: {
+        asn1: Asn1;
+        version: Asn1;
+        serialNumber: Asn1;
+        signature: {
+            asn1: Asn1;
+            algorithm: string;
+            parameters: {
+                asn1: Asn1;
+            } | null;
+        };
+        issuer: Asn1;
+        validity: {
+            from: Date;
+            to: Date;
+        };
+        subject: {
+            asn1: Asn1;
+            algorithm: string;
+            parameters: {
+                asn1: Asn1;
+            } | null;
+        }[];
+        subjectPublicKeyInfo: {
+            asn1: Asn1;
+            algorithm: {
+                asn1: Asn1;
+                algorithm: string;
+                parameters: {
+                    asn1: Asn1;
+                } | null;
+            };
+            bits: {
+                unusedBits: number;
+                bytes: Uint8Array;
+            };
+        };
+        extensions: Asn1;
+    };
+    signatureAlgorithm: {
+        asn1: Asn1;
+        algorithm: string;
+        parameters: {
+            asn1: Asn1;
+        } | null;
+    };
+    signatureValue: {
+        asn1: Asn1;
+        bits: {
+            unusedBits: number;
+            bytes: Uint8Array;
+        };
+    };
+};
+export {};
+//# sourceMappingURL=x509certificate.d.ts.map

package/lib/api/firmware/x509certificate.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCertificate = exports.parseName = void 0;
+const derToAsn1 = (byteArray) => {
+    let position = 0;
+    function getTag() {
+        let tag = byteArray[0] & 0x1f;
+        position += 1;
+        if (tag === 0x1f) {
+            tag = 0;
+            while (byteArray[position] >= 0x80) {
+                tag = tag * 128 + byteArray[position] - 0x80;
+                position += 1;
+            }
+            tag = tag * 128 + byteArray[position] - 0x80;
+            position += 1;
+        }
+        return tag;
+    }
+    function getLength() {
+        let length = 0;
+        if (byteArray[position] < 0x80) {
+            length = byteArray[position];
+            position += 1;
+        }
+        else {
+            const numberOfDigits = byteArray[position] & 0x7f;
+            position += 1;
+            length = 0;
+            for (let i = 0; i < numberOfDigits; i++) {
+                length = length * 256 + byteArray[position];
+                position += 1;
+            }
+        }
+        return length;
+    }
+    const cls = (byteArray[0] & 0xc0) / 64;
+    const structured = (byteArray[0] & 0x20) === 0x20;
+    const tag = getTag();
+    let length = getLength();
+    let byteLength;
+    let contents;
+    if (length === 0x80) {
+        length = 0;
+        while (byteArray[position + length] !== 0 || byteArray[position + length + 1] !== 0) {
+            length += 1;
+        }
+        byteLength = position + length + 2;
+        contents = byteArray.subarray(position, position + length);
+    }
+    else {
+        byteLength = position + length;
+        contents = byteArray.subarray(position, byteLength);
+    }
+    const raw = byteArray.subarray(0, byteLength);
+    return {
+        cls,
+        tag,
+        structured,
+        byteLength,
+        contents,
+        raw,
+    };
+};
+const derToAsn1List = (byteArray) => {
+    const result = [];
+    let nextPosition = 0;
+    while (nextPosition < byteArray.length) {
+        const nextPiece = derToAsn1(byteArray.subarray(nextPosition));
+        result.push(nextPiece);
+        nextPosition += nextPiece.byteLength;
+    }
+    return result;
+};
+const derBitStringValue = (byteArray) => ({
+    unusedBits: byteArray[0],
+    bytes: byteArray.subarray(1),
+});
+const parseSignatureValue = (asn1) => {
+    if (asn1.cls !== 0 || asn1.tag !== 3 || asn1.structured) {
+        throw new Error('Bad signature value. Not a BIT STRING.');
+    }
+    return {
+        asn1,
+        bits: derBitStringValue(asn1.contents),
+    };
+};
+const derObjectIdentifierValue = (byteArray) => {
+    let oid = `${Math.floor(byteArray[0] / 40)}.${byteArray[0] % 40}`;
+    let position = 1;
+    while (position < byteArray.length) {
+        let nextInteger = 0;
+        while (byteArray[position] >= 0x80) {
+            nextInteger = nextInteger * 0x80 + (byteArray[position] & 0x7f);
+            position += 1;
+        }
+        nextInteger = nextInteger * 0x80 + byteArray[position];
+        position += 1;
+        oid += `.${nextInteger}`;
+    }
+    return oid;
+};
+const parseAlgorithmIdentifier = (asn1) => {
+    if (asn1.cls !== 0 || asn1.tag !== 16 || !asn1.structured) {
+        throw new Error('Bad algorithm identifier. Not a SEQUENCE.');
+    }
+    const pieces = derToAsn1List(asn1.contents);
+    if (pieces.length > 2) {
+        throw new Error('Bad algorithm identifier. Contains too many child objects.');
+    }
+    const encodedAlgorithm = pieces[0];
+    if (encodedAlgorithm.cls !== 0 || encodedAlgorithm.tag !== 6 || encodedAlgorithm.structured) {
+        throw new Error('Bad algorithm identifier. Does not begin with an OBJECT IDENTIFIER.');
+    }
+    const algorithm = derObjectIdentifierValue(encodedAlgorithm.contents);
+    return {
+        asn1,
+        algorithm,
+        parameters: pieces.length === 2 ? { asn1: pieces[1] } : null,
+    };
+};
+const parseName = (asn1) => derToAsn1List(asn1.contents).map(item => {
+    const attrSet = derToAsn1(item.contents);
+    return parseAlgorithmIdentifier(attrSet);
+});
+exports.parseName = parseName;
+const parseSubjectPublicKeyInfo = (asn1) => {
+    if (asn1.cls !== 0 || asn1.tag !== 16 || !asn1.structured) {
+        throw new Error('Bad SPKI. Not a SEQUENCE.');
+    }
+    const pieces = derToAsn1List(asn1.contents);
+    if (pieces.length !== 2) {
+        throw new Error('Bad SubjectPublicKeyInfo. Wrong number of child objects.');
+    }
+    return {
+        asn1,
+        algorithm: parseAlgorithmIdentifier(pieces[0]),
+        bits: derBitStringValue(pieces[1].contents),
+    };
+};
+const parseUtcTime = (time) => {
+    let offset = 4;
+    let yearOffset = 0;
+    if (time.tag === 23) {
+        offset = 2;
+        yearOffset = 2000;
+    }
+    const utc = Buffer.from(time.contents).toString();
+    const year = yearOffset + Number(utc.substring(0, offset));
+    const month = Number(utc.substring(offset, offset + 2)) - 1;
+    const day = Number(utc.substring(offset + 2, offset + 4));
+    const hour = Number(utc.substring(offset + 4, offset + 6));
+    const minute = Number(utc.substring(offset + 6, offset + 8));
+    const date = new Date();
+    date.setUTCFullYear(year, month, day);
+    date.setUTCHours(hour, minute, 0);
+    return date;
+};
+const parseValidity = (asn1) => {
+    const [from, to] = derToAsn1List(asn1.contents);
+    return {
+        from: parseUtcTime(from),
+        to: parseUtcTime(to),
+    };
+};
+const parseTBSCertificate = (asn1) => {
+    if (asn1.cls !== 0 || asn1.tag !== 16 || !asn1.structured) {
+        throw new Error("This can't be a TBSCertificate. Wrong data type.");
+    }
+    const pieces = derToAsn1List(asn1.contents);
+    if (pieces.length < 7) {
+        throw new Error('Bad TBS Certificate. There are fewer than the seven required children.');
+    }
+    return {
+        asn1,
+        version: pieces[0],
+        serialNumber: pieces[1],
+        signature: parseAlgorithmIdentifier(pieces[2]),
+        issuer: pieces[3],
+        validity: parseValidity(pieces[4]),
+        subject: (0, exports.parseName)(pieces[5]),
+        subjectPublicKeyInfo: parseSubjectPublicKeyInfo(pieces[6]),
+        extensions: pieces[7],
+    };
+};
+const parseCertificate = (byteArray) => {
+    const asn1 = derToAsn1(byteArray);
+    if (asn1.cls !== 0 || asn1.tag !== 16 || !asn1.structured) {
+        throw new Error("This can't be an X.509 certificate. Wrong data type.");
+    }
+    const pieces = derToAsn1List(asn1.contents);
+    if (pieces.length !== 3) {
+        throw new Error('Certificate contains more than the three specified children.');
+    }
+    return {
+        asn1,
+        tbsCertificate: parseTBSCertificate(pieces[0]),
+        signatureAlgorithm: parseAlgorithmIdentifier(pieces[1]),
+        signatureValue: parseSignatureValue(pieces[2]),
+    };
+};
+exports.parseCertificate = parseCertificate;
+//# sourceMappingURL=x509certificate.js.map

package/lib/api/firmwareUpdate.js

@@ -53,6 +53,7 @@ class FirmwareUpdate extends AbstractMethod_1.AbstractMethod {
         return uiResp.payload;
     }
     async run() {
+        var _a;
         const { device, params } = this;
         let binary;
         try {
@@ -62,7 +63,7 @@ class FirmwareUpdate extends AbstractMethod_1.AbstractMethod {
             else {
                 binary = await (0, firmware_1.getBinary)({
                     features: device.features,
-                    releases: (0, firmwareInfo_1.getReleases)(device.features.major_version),
+                    releases: (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model),
                     version: params.version,
                     btcOnly: params.btcOnly,
                     baseUrl: params.baseUrl,