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

package/libESM/verifyAuthenticityProof.js

@@ -0,0 +1,162 @@
+import { ed25519 } from "@noble/curves/ed25519.js";
+import * as crypto from "crypto";
+import { getSubtleCrypto } from "@trezor/crypto-utils";
+import { bufferUtils } from "@trezor/utils";
+import { getRootPubKeyBlacklist, getRootPubKeys } from "./utils.js";
+import { parseCertificate } from "./x509certificate.js";
+export const verifySignatureP256 = async (rawKey, data, signature) => {
+  const signer = crypto.createVerify('sha256');
+  signer.update(Buffer.from(data));
+  const SubtleCrypto = 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;
+  }
+};
+const verifySignatureEd25519 = (rawKey, data, signature) => {
+  try {
+    return ed25519.verify(signature, data, rawKey);
+  } catch {
+    return false;
+  }
+};
+const getVerifyFn = algorithmName => {
+  if (algorithmName === 'P-256') return 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}`);
+  }
+};
+export const verifyAuthenticityProof = async ({
+  challenge,
+  certificates,
+  signature,
+  deviceModel,
+  allowDebugKeys,
+  config,
+  blacklistConfig,
+  challengePrefix = 'AuthenticateDevice:',
+  bufferChunks = []
+}) => {
+  const allRootPubKeys = getRootPubKeys({
+    config,
+    deviceModel,
+    allowDebugKeys
+  });
+  const rootPubKeyBlacklist = getRootPubKeyBlacklist({
+    blacklistConfig,
+    allowDebugKeys
+  });
+  const [deviceCert, caCert] = certificates.map((c, i) => {
+    const cert = 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 => [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'
+  };
+};
+//# sourceMappingURL=verifyAuthenticityProof.js.map

package/libESM/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

package/libESM/x509certificate.js

@@ -0,0 +1,269 @@
+const parseOidToAlgorithmName = oid => {
+  if (oid === '1.2.840.10045.4.3.2') return 'P-256';
+  if (oid === '1.3.101.112') return 'Ed25519';
+  return 'unknown';
+};
+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();
+  if (byteArray[position] === 0x80) {
+    throw new Error('Unsupported length encoding');
+  }
+  const length = getLength();
+  const byteLength = position + length;
+  const 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 algorithmOid = derObjectIdentifierValue(encodedAlgorithm.contents);
+  const algorithmName = parseOidToAlgorithmName(algorithmOid);
+  return {
+    asn1,
+    algorithmOid,
+    algorithmName,
+    parameters: pieces.length === 2 ? {
+      asn1: pieces[1]
+    } : null
+  };
+};
+export const parseName = asn1 => derToAsn1List(asn1.contents).map(item => {
+  const attrSet = derToAsn1(item.contents);
+  return parseAlgorithmIdentifier(attrSet);
+});
+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 parseExtensions = data => {
+  const asn1 = derToAsn1(data.contents);
+  if (asn1.cls !== 0 || asn1.tag !== 16 || !asn1.structured) {
+    throw new Error("This can't be a Extension. Wrong data type.");
+  }
+  const readBoolean = value => {
+    if (!value) return false;
+    if (value.cls !== 0 || value.tag !== 1 || value.contents.length !== 1 || value.structured) {
+      throw new Error("This can't be a boolean. Wrong data type.");
+    }
+    if (![0x00, 0xff].includes(value.contents[0])) {
+      throw new Error('Invalid boolean value.');
+    }
+    return value.contents[0] === 0xff;
+  };
+  const readBitString = uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    const tag = buffer.readUInt8(0);
+    if (tag !== 3) {
+      throw new Error("This can't be a bit string. Wrong data type.");
+    }
+    const length = buffer.readUInt8(1);
+    const unusedBits = buffer.readUInt8(2);
+    const bitStringBytes = buffer.subarray(3, 3 + length - 1);
+    const bitString = bitStringBytes.reduce((str, byte) => str + byte.toString(2).padStart(8, '0'), '');
+    return bitString.slice(0, bitString.length - unusedBits);
+  };
+  const readInteger = value => {
+    if (!value) return undefined;
+    if (value.cls !== 0 || value.tag !== 2 || value.contents.length !== 1 || value.structured) {
+      throw new Error("This can't be a integer. Wrong data type.");
+    }
+    return Buffer.from(value.contents).readInt8();
+  };
+  const extensions = [];
+  derToAsn1List(asn1.contents).forEach(item => {
+    const [id, ...pieces] = derToAsn1List(item.contents);
+    if (id.cls !== 0 || id.tag !== 6 || id.structured) {
+      throw new Error('Bad extension. Does not begin with an OBJECT IDENTIFIER.');
+    }
+    const algorithm = derObjectIdentifierValue(id.contents);
+    const critical = pieces.length > 1 ? readBoolean(pieces[0]) : false;
+    const extnValue = pieces.length > 1 ? pieces[1] : pieces[0];
+    if (extnValue.cls !== 0 || extnValue.tag !== 4 || extnValue.structured) {
+      throw new Error("This can't be a octet string. Wrong data type.");
+    }
+    if (algorithm === '2.5.29.15') {
+      extensions.push({
+        key: 'keyUsage',
+        critical,
+        keyCertSign: readBitString(extnValue.contents)[5]
+      });
+    } else if (algorithm === '2.5.29.19') {
+      const fields = derToAsn1List(derToAsn1(extnValue.contents).contents);
+      const ca = fields.length > 0 && fields[0].tag === 1 ? fields[0] : undefined;
+      const len = fields.length > 0 && fields[0].tag === 2 ? fields[0] : fields[1];
+      extensions.push({
+        key: 'basicConstraints',
+        critical,
+        cA: readBoolean(ca),
+        pathLenConstraint: readInteger(len)
+      });
+    } else {
+      extensions.push({
+        key: algorithm,
+        critical,
+        ...item
+      });
+    }
+  });
+  return extensions;
+};
+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: parseName(pieces[5]),
+    subjectPublicKeyInfo: parseSubjectPublicKeyInfo(pieces[6]),
+    extensions: parseExtensions(pieces[7])
+  };
+};
+export 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])
+  };
+};
+//# sourceMappingURL=x509certificate.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ohos-ports/trezor-device-authenticity",
+  "version": "1.1.2-beta.1",
+  "author": "Trezor <info@trezor.io>",
+  "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/device-authenticity",
+  "description": "Utils for authenticity verification of trezor device secure element response.",
+  "npmPublishAccess": "public",
+  "license": "See LICENSE.md in repo root",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/trezor-device-authenticity/1.1.2"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "exports": {
+      ".": {
+        "import": "./libESM/index.js",
+        "require": "./lib/index.js"
+      }
+    }
+  },
+  "main": "lib/index.js",
+  "files": [
+    "lib/",
+    "libESM/",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "build:lib": "yarn build:lib:cjs && yarn build:lib:esm",
+    "build:lib:cjs": "yarn g:rimraf ./lib && yarn g:tsc --build tsconfig.lib.json && ../../scripts/publish/replace-imports.sh ./lib cjs",
+    "build:lib:esm": "yarn g:rimraf ./libESM && yarn g:tsc --build tsconfig.libESM.json && ../../scripts/publish/replace-imports.sh ./libESM esm",
+    "depcheck": "yarn g:depcheck",
+    "type-check": "yarn g:tsc --build",
+    "test:unit": "yarn g:jest",
+    "lint:js": "yarn g:eslint '**/*.{ts,tsx,js}'",
+    "prepublishOnly": "yarn tsx ../../scripts/publish/prepublishNPM.js",
+    "prepublish": "yarn tsx ../../scripts/publish/prepublish.js"
+  },
+  "dependencies": {
+    "@noble/curves": "^2.0.1",
+    "@trezor/crypto-utils": "1.2.0",
+    "@trezor/protobuf": "1.5.2",
+    "@trezor/schema-utils": "1.4.0",
+    "@trezor/utils": "9.5.0"
+  },
+  "devDependencies": {
+    "@ohos-ports/tsx": "^4.22.4-beta.4"
+  },
+  "exports": {
+    ".": {
+      "import": "./libESM/index.js",
+      "require": "./lib/index.js"
+    }
+  },
+  "types": "lib/index.d.ts"
+}