@ohos-ports/trezor-device-authenticity 1.1.2-beta.1

package/README.md

@@ -0,0 +1,7 @@
+# @trezor/device-authenticity
+
+[![NPM](https://img.shields.io/npm/v/@trezor/device-authenticity.svg)](https://www.npmjs.org/package/@trezor/device-authenticity)
+
+Functionality regarding Trezor device authenticity verification in Connect, i.e. cryptographic verification of a secure element response.
+
+Not to be mistaken with `@suite-common/device-authenticity`, which concerns with processing of Connect response in Suite, and implements it into Redux.

package/lib/config/deviceAuthenticityBlacklistConfig.d.ts

@@ -0,0 +1,3 @@
+import type { DeviceAuthenticityBlacklistConfig } from './deviceAuthenticityBlacklistConfigTypes';
+export declare const deviceAuthenticityBlacklistConfig: DeviceAuthenticityBlacklistConfig;
+//# sourceMappingURL=deviceAuthenticityBlacklistConfig.d.ts.map

package/lib/config/deviceAuthenticityBlacklistConfig.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deviceAuthenticityBlacklistConfig = void 0;
+exports.deviceAuthenticityBlacklistConfig = {
+  version: 1,
+  blacklistedCaPubKeys: [],
+  debug: {
+    blacklistedCaPubKeys: []
+  }
+};
+//# sourceMappingURL=deviceAuthenticityBlacklistConfig.js.map

package/lib/config/deviceAuthenticityBlacklistConfigTypes.d.ts

@@ -0,0 +1,11 @@
+import { Static } from '@trezor/schema-utils';
+export type DeviceAuthenticityBlacklistConfig = Static<typeof DeviceAuthenticityBlacklistConfig>;
+export declare const DeviceAuthenticityBlacklistConfig: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+    blacklistedCaPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+}>, import("@trezor/schema-utils").TObject<{
+    version: import("@trezor/schema-utils").TNumber;
+    debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        blacklistedCaPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+    }>>;
+}>]>;
+//# sourceMappingURL=deviceAuthenticityBlacklistConfigTypes.d.ts.map

package/lib/config/deviceAuthenticityBlacklistConfigTypes.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeviceAuthenticityBlacklistConfig = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const CertPubKeysBlacklist = schema_utils_1.Type.Object({
+  blacklistedCaPubKeys: schema_utils_1.Type.Array(schema_utils_1.Type.String())
+});
+exports.DeviceAuthenticityBlacklistConfig = schema_utils_1.Type.Intersect([CertPubKeysBlacklist, schema_utils_1.Type.Object({
+  version: schema_utils_1.Type.Number(),
+  debug: schema_utils_1.Type.Optional(CertPubKeysBlacklist)
+})]);
+//# sourceMappingURL=deviceAuthenticityBlacklistConfigTypes.js.map

package/lib/config/deviceAuthenticityConfig.d.ts

@@ -0,0 +1,3 @@
+import type { DeviceAuthenticityConfig } from './deviceAuthenticityConfigTypes';
+export declare const deviceAuthenticityConfig: DeviceAuthenticityConfig;
+//# sourceMappingURL=deviceAuthenticityConfig.d.ts.map

package/lib/config/deviceAuthenticityConfig.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deviceAuthenticityConfig = void 0;
+exports.deviceAuthenticityConfig = {
+  version: 2,
+  T2B1: {
+    rootPubKeysOptiga: ['04ca97480ac0d7b1e6efafe518cd433cec2bf8ab9822d76eafd34363b55d63e60380bff20acc75cde03cffcb50ab6f8ce70c878e37ebc58ff7cca0a83b16b15fa5'],
+    debug: {
+      rootPubKeysOptiga: ['047f77368dea2d4d61e989f474a56723c3212dacf8a808d8795595ef38441427c4389bc454f02089d7f08b873005e4c28d432468997871c0bf286fd3861e21e96a']
+    }
+  },
+  T3B1: {
+    rootPubKeysOptiga: ['045b5c3fdd01f3602092834209b86df0ca86a9faf25cac35c73bf6237d66eb21eafcec3706f1ccd5eb4cc7f2fa1751213eccb1c78389afba89a5788ff31ee46a5d'],
+    debug: {
+      rootPubKeysOptiga: ['047f77368dea2d4d61e989f474a56723c3212dacf8a808d8795595ef38441427c4389bc454f02089d7f08b873005e4c28d432468997871c0bf286fd3861e21e96a']
+    }
+  },
+  T3T1: {
+    rootPubKeysOptiga: ['041854b27fb1d9f65abb66828e78c9dc0ca301e66081ab0c6a4d104f9df1cd0ad5a7c75f77a8c092f55cf825d2abaf734f934c9394d5e75f75a5a06a5ee9be93ae'],
+    debug: {
+      rootPubKeysOptiga: ['04e48b69cd7962068d3cca3bcc6b1747ef496c1e28b5529e34ad7295215ea161dbe8fb08ae0479568f9d2cb07630cb3e52f4af0692102da5873559e45e9fa72959']
+    }
+  },
+  T3W1: {
+    rootPubKeysOptiga: ['040dde0d3e0d4da593fac6fd02a461d0e7eef238aca55c7c50b4e9ec37f3873303b6429ef1c9b78b4411a7dcbbc5dde5225979c1c2da3b073e82b1ed3f5f9825bb'],
+    rootPubKeysTropic: ['59237acd17134061d655b3f8d624573ca06ce8d862f38ba4e05140ce1d3d609d'],
+    debug: {
+      rootPubKeysOptiga: ['04521192e173a9da4e3023f747d836563725372681eba3079c56ff11b2fc137ab189eb4155f371127651b5594f8c332fc1e9c0f3b80d4212822668b63189706578'],
+      rootPubKeysTropic: []
+    }
+  }
+};
+//# sourceMappingURL=deviceAuthenticityConfig.js.map

package/lib/config/deviceAuthenticityConfigTypes.d.ts

@@ -0,0 +1,47 @@
+import { Static } from '@trezor/schema-utils';
+export type DeviceAuthenticityConfig = Static<typeof DeviceAuthenticityConfig>;
+export declare const DeviceAuthenticityConfig: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+    T2B1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+        rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+    }>, import("@trezor/schema-utils").TObject<{
+        debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+        }>>;
+    }>]>;
+    T3B1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+        rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+    }>, import("@trezor/schema-utils").TObject<{
+        debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+        }>>;
+    }>]>;
+    T3T1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+        rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+    }>, import("@trezor/schema-utils").TObject<{
+        debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+        }>>;
+    }>]>;
+    T3W1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+        rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+    }>, import("@trezor/schema-utils").TObject<{
+        debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeysOptiga: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            rootPubKeysTropic: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>>;
+        }>>;
+    }>]>;
+}>, import("@trezor/schema-utils").TObject<{
+    T1B1: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+    T2T1: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+    UNKNOWN: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+}>]>, import("@trezor/schema-utils").TObject<{
+    version: import("@trezor/schema-utils").TNumber;
+}>]>;
+//# sourceMappingURL=deviceAuthenticityConfigTypes.d.ts.map

package/lib/config/deviceAuthenticityConfigTypes.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeviceAuthenticityConfig = void 0;
+const protobuf_1 = require("@trezor/protobuf");
+const schema_utils_1 = require("@trezor/schema-utils");
+const CertPubKeys = schema_utils_1.Type.Object({
+  rootPubKeysOptiga: schema_utils_1.Type.Array(schema_utils_1.Type.String()),
+  rootPubKeysTropic: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.String()))
+});
+const ModelsWithKeys = schema_utils_1.Type.Exclude(schema_utils_1.Type.KeyOfEnum(protobuf_1.MessagesSchema.DeviceModelInternal), schema_utils_1.Type.Union([schema_utils_1.Type.Literal('T1B1'), schema_utils_1.Type.Literal('T2T1'), schema_utils_1.Type.Literal('UNKNOWN')]));
+const ModelsWithoutKeys = schema_utils_1.Type.Extract(schema_utils_1.Type.KeyOfEnum(protobuf_1.MessagesSchema.DeviceModelInternal), schema_utils_1.Type.Union([schema_utils_1.Type.Literal('T1B1'), schema_utils_1.Type.Literal('T2T1'), schema_utils_1.Type.Literal('UNKNOWN')]));
+const ModelPubKeys = schema_utils_1.Type.Intersect([schema_utils_1.Type.Record(ModelsWithKeys, schema_utils_1.Type.Intersect([CertPubKeys, schema_utils_1.Type.Object({
+  debug: schema_utils_1.Type.Optional(CertPubKeys)
+})])), schema_utils_1.Type.Partial(schema_utils_1.Type.Record(ModelsWithoutKeys, schema_utils_1.Type.Undefined()))]);
+exports.DeviceAuthenticityConfig = schema_utils_1.Type.Intersect([ModelPubKeys, schema_utils_1.Type.Object({
+  version: schema_utils_1.Type.Number()
+})]);
+//# sourceMappingURL=deviceAuthenticityConfigTypes.js.map

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export { verifyAuthenticityProof, verifySignatureP256 } from './verifyAuthenticityProof';
+export { type AlgorithmName, parseName, parseCertificate } from './x509certificate';
+export { getRandomChallenge } from './utils';
+export type { VerifySignature, VerifyAuthenticityProofParams, VerifyAuthenticityProofResult, } from './types';
+export { deviceAuthenticityBlacklistConfig } from './config/deviceAuthenticityBlacklistConfig';
+export { DeviceAuthenticityBlacklistConfig } from './config/deviceAuthenticityBlacklistConfigTypes';
+export { deviceAuthenticityConfig } from './config/deviceAuthenticityConfig';
+export { DeviceAuthenticityConfig } from './config/deviceAuthenticityConfigTypes';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeviceAuthenticityConfig = exports.deviceAuthenticityConfig = exports.DeviceAuthenticityBlacklistConfig = exports.deviceAuthenticityBlacklistConfig = exports.getRandomChallenge = exports.parseCertificate = exports.parseName = exports.verifySignatureP256 = exports.verifyAuthenticityProof = void 0;
+var verifyAuthenticityProof_1 = require("./verifyAuthenticityProof");
+Object.defineProperty(exports, "verifyAuthenticityProof", {
+  enumerable: true,
+  get: function () {
+    return verifyAuthenticityProof_1.verifyAuthenticityProof;
+  }
+});
+Object.defineProperty(exports, "verifySignatureP256", {
+  enumerable: true,
+  get: function () {
+    return verifyAuthenticityProof_1.verifySignatureP256;
+  }
+});
+var x509certificate_1 = require("./x509certificate");
+Object.defineProperty(exports, "parseName", {
+  enumerable: true,
+  get: function () {
+    return x509certificate_1.parseName;
+  }
+});
+Object.defineProperty(exports, "parseCertificate", {
+  enumerable: true,
+  get: function () {
+    return x509certificate_1.parseCertificate;
+  }
+});
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getRandomChallenge", {
+  enumerable: true,
+  get: function () {
+    return utils_1.getRandomChallenge;
+  }
+});
+var deviceAuthenticityBlacklistConfig_1 = require("./config/deviceAuthenticityBlacklistConfig");
+Object.defineProperty(exports, "deviceAuthenticityBlacklistConfig", {
+  enumerable: true,
+  get: function () {
+    return deviceAuthenticityBlacklistConfig_1.deviceAuthenticityBlacklistConfig;
+  }
+});
+var deviceAuthenticityBlacklistConfigTypes_1 = require("./config/deviceAuthenticityBlacklistConfigTypes");
+Object.defineProperty(exports, "DeviceAuthenticityBlacklistConfig", {
+  enumerable: true,
+  get: function () {
+    return deviceAuthenticityBlacklistConfigTypes_1.DeviceAuthenticityBlacklistConfig;
+  }
+});
+var deviceAuthenticityConfig_1 = require("./config/deviceAuthenticityConfig");
+Object.defineProperty(exports, "deviceAuthenticityConfig", {
+  enumerable: true,
+  get: function () {
+    return deviceAuthenticityConfig_1.deviceAuthenticityConfig;
+  }
+});
+var deviceAuthenticityConfigTypes_1 = require("./config/deviceAuthenticityConfigTypes");
+Object.defineProperty(exports, "DeviceAuthenticityConfig", {
+  enumerable: true,
+  get: function () {
+    return deviceAuthenticityConfigTypes_1.DeviceAuthenticityConfig;
+  }
+});
+//# sourceMappingURL=index.js.map

package/lib/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/types.ts","../src/utils.ts","../src/verifyAuthenticityProof.ts","../src/x509certificate.ts","../src/config/deviceAuthenticityBlacklistConfig.ts","../src/config/deviceAuthenticityBlacklistConfigTypes.ts","../src/config/deviceAuthenticityConfig.ts","../src/config/deviceAuthenticityConfigTypes.ts"],"version":"5.8.3"}

package/lib/types.d.ts

@@ -0,0 +1,27 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { DeviceAuthenticityBlacklistConfig } from './config/deviceAuthenticityBlacklistConfigTypes';
+import type { DeviceAuthenticityConfig } from './config/deviceAuthenticityConfigTypes';
+export type VerifySignature = (rawKey: Buffer, data: Uint8Array, signature: Uint8Array) => boolean | Promise<boolean>;
+export type VerifyAuthenticityProofParams = {
+    challenge: Buffer;
+    certificates: string[];
+    signature: string;
+    deviceModel: keyof typeof PROTO.DeviceModelInternal;
+    config: DeviceAuthenticityConfig;
+    blacklistConfig: DeviceAuthenticityBlacklistConfig;
+    allowDebugKeys?: boolean;
+    challengePrefix?: string;
+    bufferChunks?: Buffer[];
+};
+export type VerifyAuthenticityProofResult = {
+    valid: true;
+    caPubKey: string;
+    rootPubKey: string;
+    error?: typeof undefined;
+} | {
+    valid: false;
+    caPubKey?: string;
+    rootPubKey?: string;
+    error: 'ROOT_PUBKEY_NOT_FOUND' | 'CA_PUBKEY_BLACKLISTED' | 'INVALID_DEVICE_MODEL' | 'INVALID_DEVICE_CERTIFICATE' | 'INVALID_DEVICE_SIGNATURE' | 'RESPONSE_PAYLOAD_MISSING';
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/lib/utils.d.ts

@@ -0,0 +1,17 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { DeviceAuthenticityBlacklistConfig } from './config/deviceAuthenticityBlacklistConfigTypes';
+import type { DeviceAuthenticityConfig } from './config/deviceAuthenticityConfigTypes';
+export declare const getRandomChallenge: () => Buffer<ArrayBufferLike>;
+type GetRootPubKeyBlacklistParams = {
+    blacklistConfig: DeviceAuthenticityBlacklistConfig;
+    allowDebugKeys?: boolean;
+};
+export declare const getRootPubKeyBlacklist: ({ blacklistConfig, allowDebugKeys, }: GetRootPubKeyBlacklistParams) => string[];
+type GetRootPubKeysParams = {
+    config: DeviceAuthenticityConfig;
+    deviceModel: keyof typeof PROTO.DeviceModelInternal;
+    allowDebugKeys?: boolean;
+};
+export declare const getRootPubKeys: ({ config, deviceModel, allowDebugKeys, }: GetRootPubKeysParams) => string[];
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRootPubKeys = exports.getRootPubKeyBlacklist = exports.getRandomChallenge = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const getRandomChallenge = () => crypto.randomBytes(32);
+exports.getRandomChallenge = getRandomChallenge;
+const getRootPubKeyBlacklist = ({
+  blacklistConfig,
+  allowDebugKeys
+}) => {
+  const normalBlacklist = blacklistConfig.blacklistedCaPubKeys ?? [];
+  const debugBlacklist = blacklistConfig.debug?.blacklistedCaPubKeys ?? [];
+  return allowDebugKeys ? normalBlacklist.concat(debugBlacklist) : normalBlacklist;
+};
+exports.getRootPubKeyBlacklist = getRootPubKeyBlacklist;
+const getRootPubKeys = ({
+  config,
+  deviceModel,
+  allowDebugKeys
+}) => {
+  const modelConfig = config[deviceModel];
+  if (modelConfig === undefined) {
+    throw new Error(`Pubkeys for ${deviceModel} not found in config`);
+  }
+  const rootPubKeysNormalOptiga = modelConfig.rootPubKeysOptiga ?? [];
+  const rootPubKeysNormalTropic = modelConfig.rootPubKeysTropic ?? [];
+  const rootPubKeysDebugOptiga = modelConfig.debug?.rootPubKeysOptiga ?? [];
+  const rootPubKeysDebugTropic = modelConfig.debug?.rootPubKeysTropic ?? [];
+  const rootPubKeysNormal = [...rootPubKeysNormalOptiga, ...rootPubKeysNormalTropic];
+  if (!allowDebugKeys) return rootPubKeysNormal;
+  return [...rootPubKeysNormal, ...rootPubKeysDebugOptiga, ...rootPubKeysDebugTropic];
+};
+exports.getRootPubKeys = getRootPubKeys;
+//# sourceMappingURL=utils.js.map

package/lib/verifyAuthenticityProof.d.ts

@@ -0,0 +1,4 @@
+import { VerifyAuthenticityProofParams, VerifyAuthenticityProofResult, VerifySignature } from './types';
+export declare const verifySignatureP256: VerifySignature;
+export declare const verifyAuthenticityProof: ({ challenge, certificates, signature, deviceModel, allowDebugKeys, config, blacklistConfig, challengePrefix, bufferChunks, }: VerifyAuthenticityProofParams) => Promise<VerifyAuthenticityProofResult>;
+//# sourceMappingURL=verifyAuthenticityProof.d.ts.map

package/lib/verifyAuthenticityProof.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.verifyAuthenticityProof = exports.verifySignatureP256 = void 0;
+const tslib_1 = require("tslib");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const crypto = tslib_1.__importStar(require("crypto"));
+const crypto_utils_1 = require("@trezor/crypto-utils");
+const utils_1 = require("@trezor/utils");
+const utils_2 = require("./utils");
+const x509certificate_1 = require("./x509certificate");
+const verifySignatureP256 = async (rawKey, data, signature) => {
+  const signer = crypto.createVerify('sha256');
+  signer.update(Buffer.from(data));
+  const SubtleCrypto = (0, crypto_utils_1.getSubtleCrypto)();
+  try {
+    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));
+  } catch {
+    return false;
+  }
+};
+exports.verifySignatureP256 = verifySignatureP256;
+const verifySignatureEd25519 = (rawKey, data, signature) => {
+  try {
+    return ed25519_js_1.ed25519.verify(signature, data, rawKey);
+  } catch {
+    return false;
+  }
+};
+const getVerifyFn = algorithmName => {
+  if (algorithmName === 'P-256') return exports.verifySignatureP256;
+  if (algorithmName === 'Ed25519') return verifySignatureEd25519;
+  throw new Error(`Unsupported signature algorithm.`);
+};
+const validateCaCertExtensions = (cert, pathLen) => {
+  let hasKeyUsage,
+    hasBasicConstraints = false;
+  cert.tbsCertificate.extensions.forEach(ext => {
+    if (ext.key === 'keyUsage') {
+      if (ext.keyCertSign !== '1') {
+        throw new Error(`CA keyCertSign not set`);
+      }
+      hasKeyUsage = true;
+    } else if (ext.key === 'basicConstraints') {
+      if (!ext.cA) {
+        throw new Error(`CA basicConstraints.cA not set`);
+      }
+      if (typeof ext.pathLenConstraint != 'number') {
+        throw new Error('CA basicConstraints.pathLenConstraint not set');
+      }
+      if (ext.pathLenConstraint < pathLen) {
+        throw new Error('Issuer was not permitted to issue certificate');
+      }
+      hasBasicConstraints = true;
+    } else if (ext.critical) {
+      throw new Error(`Unknown critical extension ${ext.key} in CA certificate`);
+    }
+  });
+  if (!hasKeyUsage || !hasBasicConstraints) {
+    throw new Error(`CA missing extensions keyUsage: ${hasKeyUsage}, basicConstraints: ${hasBasicConstraints}`);
+  }
+};
+const verifyAuthenticityProof = async ({
+  challenge,
+  certificates,
+  signature,
+  deviceModel,
+  allowDebugKeys,
+  config,
+  blacklistConfig,
+  challengePrefix = 'AuthenticateDevice:',
+  bufferChunks = []
+}) => {
+  const allRootPubKeys = (0, utils_2.getRootPubKeys)({
+    config,
+    deviceModel,
+    allowDebugKeys
+  });
+  const rootPubKeyBlacklist = (0, utils_2.getRootPubKeyBlacklist)({
+    blacklistConfig,
+    allowDebugKeys
+  });
+  const [deviceCert, caCert] = certificates.map((c, i) => {
+    const cert = (0, x509certificate_1.parseCertificate)(new Uint8Array(Buffer.from(c, 'hex')));
+    if (i === 0) {
+      return cert;
+    }
+    validateCaCertExtensions(cert, i - 1);
+    return cert;
+  });
+  const deviceCertAlgName = deviceCert.signatureAlgorithm.algorithmName;
+  const caCertAlgName = caCert.signatureAlgorithm.algorithmName;
+  if (deviceCertAlgName !== caCertAlgName) {
+    throw new Error('Mismatched signature algorithms in device and CA certificates');
+  }
+  const verifySignatureFn = getVerifyFn(deviceCertAlgName);
+  const caPubKey = Buffer.from(caCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes).toString('hex');
+  const isCertSignedByRootPubkey = await Promise.all(allRootPubKeys.map(rootPubKey => verifySignatureFn(Buffer.from(rootPubKey, 'hex'), caCert.tbsCertificate.asn1.raw, caCert.signatureValue.bits.bytes)));
+  const rootPubKeyIndex = isCertSignedByRootPubkey.findIndex(valid => !!valid);
+  const rootPubKeyMatch = allRootPubKeys[rootPubKeyIndex];
+  const caCertValidityFrom = caCert.tbsCertificate.validity.from.getTime();
+  if (caCertValidityFrom > new Date().getTime()) {
+    throw new Error(`CA validity from ${caCertValidityFrom} can't be in the future!`);
+  }
+  if (rootPubKeyMatch === undefined) {
+    return {
+      valid: false,
+      caPubKey,
+      error: 'ROOT_PUBKEY_NOT_FOUND'
+    };
+  }
+  const [subject] = deviceCert.tbsCertificate.subject;
+  if (!subject.parameters || subject.algorithmOid !== '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,
+      rootPubKey: rootPubKeyMatch,
+      error: 'INVALID_DEVICE_MODEL'
+    };
+  }
+  const isDeviceCertValid = await verifySignatureFn(Buffer.from(caCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes), deviceCert.tbsCertificate.asn1.raw, deviceCert.signatureValue.bits.bytes);
+  const challengePrefixBuffer = Buffer.from(challengePrefix);
+  const chunks = bufferChunks && bufferChunks.length > 0 ? [challengePrefixBuffer, ...bufferChunks] : [challengePrefixBuffer, challenge];
+  const prefixedBuffer = Buffer.concat(chunks.flatMap(chunk => [utils_1.bufferUtils.getChunkSize(chunk.byteLength), chunk]));
+  const isSignatureValid = await verifySignatureFn(Buffer.from(deviceCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes), prefixedBuffer, Buffer.from(signature, 'hex'));
+  if (isDeviceCertValid && isSignatureValid) {
+    if (rootPubKeyBlacklist.includes(caPubKey)) {
+      return {
+        valid: false,
+        caPubKey,
+        rootPubKey: rootPubKeyMatch,
+        error: 'CA_PUBKEY_BLACKLISTED'
+      };
+    }
+    return {
+      valid: true,
+      caPubKey,
+      rootPubKey: rootPubKeyMatch
+    };
+  }
+  if (!isDeviceCertValid) {
+    return {
+      valid: false,
+      caPubKey,
+      rootPubKey: rootPubKeyMatch,
+      error: 'INVALID_DEVICE_CERTIFICATE'
+    };
+  }
+  return {
+    valid: false,
+    caPubKey,
+    rootPubKey: rootPubKeyMatch,
+    error: 'INVALID_DEVICE_SIGNATURE'
+  };
+};
+exports.verifyAuthenticityProof = verifyAuthenticityProof;
+//# sourceMappingURL=verifyAuthenticityProof.js.map

package/lib/x509certificate.d.ts

@@ -0,0 +1,93 @@
+interface Asn1 {
+    cls: number;
+    tag: number;
+    structured: boolean;
+    byteLength: number;
+    contents: Uint8Array;
+    raw: Uint8Array;
+}
+type Oid = `${number}.${number}.${number}.${number}` | `${number}.${number}.${number}.${number}.${number}.${number}`;
+export type AlgorithmName = 'P-256' | 'Ed25519' | 'unknown';
+type Extension = {
+    key: 'keyUsage';
+    critical?: boolean;
+    keyCertSign: '0' | '1';
+} | {
+    key: 'basicConstraints';
+    critical?: boolean;
+    cA: boolean;
+    pathLenConstraint?: number;
+} | (Asn1 & {
+    key: Oid;
+    critical?: boolean;
+});
+export declare const parseName: (asn1: Asn1) => {
+    asn1: Asn1;
+    algorithmOid: Oid;
+    algorithmName: AlgorithmName;
+    parameters: {
+        asn1: Asn1;
+    } | null;
+}[];
+export declare const parseCertificate: (byteArray: Uint8Array) => {
+    asn1: Asn1;
+    tbsCertificate: {
+        asn1: Asn1;
+        version: Asn1;
+        serialNumber: Asn1;
+        signature: {
+            asn1: Asn1;
+            algorithmOid: Oid;
+            algorithmName: AlgorithmName;
+            parameters: {
+                asn1: Asn1;
+            } | null;
+        };
+        issuer: Asn1;
+        validity: {
+            from: Date;
+            to: Date;
+        };
+        subject: {
+            asn1: Asn1;
+            algorithmOid: Oid;
+            algorithmName: AlgorithmName;
+            parameters: {
+                asn1: Asn1;
+            } | null;
+        }[];
+        subjectPublicKeyInfo: {
+            asn1: Asn1;
+            algorithm: {
+                asn1: Asn1;
+                algorithmOid: Oid;
+                algorithmName: AlgorithmName;
+                parameters: {
+                    asn1: Asn1;
+                } | null;
+            };
+            bits: {
+                unusedBits: number;
+                bytes: Uint8Array<ArrayBufferLike>;
+            };
+        };
+        extensions: Extension[];
+    };
+    signatureAlgorithm: {
+        asn1: Asn1;
+        algorithmOid: Oid;
+        algorithmName: AlgorithmName;
+        parameters: {
+            asn1: Asn1;
+        } | null;
+    };
+    signatureValue: {
+        asn1: Asn1;
+        bits: {
+            unusedBits: number;
+            bytes: Uint8Array<ArrayBufferLike>;
+        };
+    };
+};
+export {};
+//# sourceMappingURL=x509certificate.d.ts.map