@simplewebauthn/server 7.4.0 → 8.0.0-alpha.0

package/esm/registration/verifications/tpm/constants.js

@@ -0,0 +1,182 @@
+// deno-lint-ignore-file no-dupe-keys
+/**
+ * A whole lotta domain knowledge is captured here, with hazy connections to source
+ * documents. Good places to start searching for more info on these values are the
+ * following Trusted Computing Group TPM Library docs linked in the WebAuthn API:
+ *
+ * - https://www.trustedcomputinggroup.org/wp-content/uploads/TPM-Rev-2.0-Part-1-Architecture-01.38.pdf
+ * - https://www.trustedcomputinggroup.org/wp-content/uploads/TPM-Rev-2.0-Part-2-Structures-01.38.pdf
+ * - https://www.trustedcomputinggroup.org/wp-content/uploads/TPM-Rev-2.0-Part-3-Commands-01.38.pdf
+ */
+/**
+ * 6.9 TPM_ST (Structure Tags)
+ */
+export const TPM_ST = {
+    0x00c4: 'TPM_ST_RSP_COMMAND',
+    0x8000: 'TPM_ST_NULL',
+    0x8001: 'TPM_ST_NO_SESSIONS',
+    0x8002: 'TPM_ST_SESSIONS',
+    0x8014: 'TPM_ST_ATTEST_NV',
+    0x8015: 'TPM_ST_ATTEST_COMMAND_AUDIT',
+    0x8016: 'TPM_ST_ATTEST_SESSION_AUDIT',
+    0x8017: 'TPM_ST_ATTEST_CERTIFY',
+    0x8018: 'TPM_ST_ATTEST_QUOTE',
+    0x8019: 'TPM_ST_ATTEST_TIME',
+    0x801a: 'TPM_ST_ATTEST_CREATION',
+    0x8021: 'TPM_ST_CREATION',
+    0x8022: 'TPM_ST_VERIFIED',
+    0x8023: 'TPM_ST_AUTH_SECRET',
+    0x8024: 'TPM_ST_HASHCHECK',
+    0x8025: 'TPM_ST_AUTH_SIGNED',
+    0x8029: 'TPM_ST_FU_MANIFEST',
+};
+/**
+ * 6.3 TPM_ALG_ID
+ */
+export const TPM_ALG = {
+    0x0000: 'TPM_ALG_ERROR',
+    0x0001: 'TPM_ALG_RSA',
+    0x0004: 'TPM_ALG_SHA',
+    // @ts-ignore 2300
+    0x0004: 'TPM_ALG_SHA1',
+    0x0005: 'TPM_ALG_HMAC',
+    0x0006: 'TPM_ALG_AES',
+    0x0007: 'TPM_ALG_MGF1',
+    0x0008: 'TPM_ALG_KEYEDHASH',
+    0x000a: 'TPM_ALG_XOR',
+    0x000b: 'TPM_ALG_SHA256',
+    0x000c: 'TPM_ALG_SHA384',
+    0x000d: 'TPM_ALG_SHA512',
+    0x0010: 'TPM_ALG_NULL',
+    0x0012: 'TPM_ALG_SM3_256',
+    0x0013: 'TPM_ALG_SM4',
+    0x0014: 'TPM_ALG_RSASSA',
+    0x0015: 'TPM_ALG_RSAES',
+    0x0016: 'TPM_ALG_RSAPSS',
+    0x0017: 'TPM_ALG_OAEP',
+    0x0018: 'TPM_ALG_ECDSA',
+    0x0019: 'TPM_ALG_ECDH',
+    0x001a: 'TPM_ALG_ECDAA',
+    0x001b: 'TPM_ALG_SM2',
+    0x001c: 'TPM_ALG_ECSCHNORR',
+    0x001d: 'TPM_ALG_ECMQV',
+    0x0020: 'TPM_ALG_KDF1_SP800_56A',
+    0x0021: 'TPM_ALG_KDF2',
+    0x0022: 'TPM_ALG_KDF1_SP800_108',
+    0x0023: 'TPM_ALG_ECC',
+    0x0025: 'TPM_ALG_SYMCIPHER',
+    0x0026: 'TPM_ALG_CAMELLIA',
+    0x0040: 'TPM_ALG_CTR',
+    0x0041: 'TPM_ALG_OFB',
+    0x0042: 'TPM_ALG_CBC',
+    0x0043: 'TPM_ALG_CFB',
+    0x0044: 'TPM_ALG_ECB',
+};
+/**
+ * 6.4 TPM_ECC_CURVE
+ */
+export const TPM_ECC_CURVE = {
+    0x0000: 'TPM_ECC_NONE',
+    0x0001: 'TPM_ECC_NIST_P192',
+    0x0002: 'TPM_ECC_NIST_P224',
+    0x0003: 'TPM_ECC_NIST_P256',
+    0x0004: 'TPM_ECC_NIST_P384',
+    0x0005: 'TPM_ECC_NIST_P521',
+    0x0010: 'TPM_ECC_BN_P256',
+    0x0011: 'TPM_ECC_BN_P638',
+    0x0020: 'TPM_ECC_SM2_P256',
+};
+/**
+ * Sourced from https://trustedcomputinggroup.org/resource/vendor-id-registry/
+ *
+ * Latest version:
+ * https://trustedcomputinggroup.org/wp-content/uploads/TCG-TPM-Vendor-ID-Registry-Version-1.02-Revision-1.00.pdf
+ */
+export const TPM_MANUFACTURERS = {
+    'id:414D4400': {
+        name: 'AMD',
+        id: 'AMD',
+    },
+    'id:41544D4C': {
+        name: 'Atmel',
+        id: 'ATML',
+    },
+    'id:4252434D': {
+        name: 'Broadcom',
+        id: 'BRCM',
+    },
+    'id:49424d00': {
+        name: 'IBM',
+        id: 'IBM',
+    },
+    'id:49465800': {
+        name: 'Infineon',
+        id: 'IFX',
+    },
+    'id:494E5443': {
+        name: 'Intel',
+        id: 'INTC',
+    },
+    'id:4C454E00': {
+        name: 'Lenovo',
+        id: 'LEN',
+    },
+    'id:4E534D20': {
+        name: 'National Semiconductor',
+        id: 'NSM',
+    },
+    'id:4E545A00': {
+        name: 'Nationz',
+        id: 'NTZ',
+    },
+    'id:4E544300': {
+        name: 'Nuvoton Technology',
+        id: 'NTC',
+    },
+    'id:51434F4D': {
+        name: 'Qualcomm',
+        id: 'QCOM',
+    },
+    'id:534D5343': {
+        name: 'SMSC',
+        id: 'SMSC',
+    },
+    'id:53544D20': {
+        name: 'ST Microelectronics',
+        id: 'STM',
+    },
+    'id:534D534E': {
+        name: 'Samsung',
+        id: 'SMSN',
+    },
+    'id:534E5300': {
+        name: 'Sinosun',
+        id: 'SNS',
+    },
+    'id:54584E00': {
+        name: 'Texas Instruments',
+        id: 'TXN',
+    },
+    'id:57454300': {
+        name: 'Winbond',
+        id: 'WEC',
+    },
+    'id:524F4343': {
+        name: 'Fuzhouk Rockchip',
+        id: 'ROCC',
+    },
+    'id:FFFFF1D0': {
+        name: 'FIDO Alliance',
+        id: 'FIDO',
+    },
+};
+/**
+ * Match TPM public area curve ID's to `crv` numbers used in COSE public keys
+ */
+export const TPM_ECC_CURVE_COSE_CRV_MAP = {
+    TPM_ECC_NIST_P256: 1,
+    TPM_ECC_NIST_P384: 2,
+    TPM_ECC_NIST_P521: 3,
+    TPM_ECC_BN_P256: 1,
+    TPM_ECC_SM2_P256: 1, // p256
+};

package/esm/registration/verifications/tpm/parseCertInfo.js

@@ -0,0 +1,58 @@
+import { TPM_ALG, TPM_ST } from './constants.js';
+import { isoUint8Array } from '../../../helpers/iso/index.js';
+/**
+ * Cut up a TPM attestation's certInfo into intelligible chunks
+ */
+export function parseCertInfo(certInfo) {
+    let pointer = 0;
+    const dataView = isoUint8Array.toDataView(certInfo);
+    // Get a magic constant
+    const magic = dataView.getUint32(pointer);
+    pointer += 4;
+    // Determine the algorithm used for attestation
+    const typeBuffer = dataView.getUint16(pointer);
+    pointer += 2;
+    const type = TPM_ST[typeBuffer];
+    // The name of a parent entity, can be ignored
+    const qualifiedSignerLength = dataView.getUint16(pointer);
+    pointer += 2;
+    const qualifiedSigner = certInfo.slice(pointer, pointer += qualifiedSignerLength);
+    // Get the expected hash of `attsToBeSigned`
+    const extraDataLength = dataView.getUint16(pointer);
+    pointer += 2;
+    const extraData = certInfo.slice(pointer, pointer += extraDataLength);
+    // Information about the TPM device's internal clock, can be ignored
+    const clock = certInfo.slice(pointer, pointer += 8);
+    const resetCount = dataView.getUint32(pointer);
+    pointer += 4;
+    const restartCount = dataView.getUint32(pointer);
+    pointer += 4;
+    const safe = !!certInfo.slice(pointer, pointer += 1);
+    const clockInfo = { clock, resetCount, restartCount, safe };
+    // TPM device firmware version
+    const firmwareVersion = certInfo.slice(pointer, pointer += 8);
+    // Attested Name
+    const attestedNameLength = dataView.getUint16(pointer);
+    pointer += 2;
+    const attestedName = certInfo.slice(pointer, pointer += attestedNameLength);
+    const attestedNameDataView = isoUint8Array.toDataView(attestedName);
+    // Attested qualified name, can be ignored
+    const qualifiedNameLength = dataView.getUint16(pointer);
+    pointer += 2;
+    const qualifiedName = certInfo.slice(pointer, pointer += qualifiedNameLength);
+    const attested = {
+        nameAlg: TPM_ALG[attestedNameDataView.getUint16(0)],
+        nameAlgBuffer: attestedName.slice(0, 2),
+        name: attestedName,
+        qualifiedName,
+    };
+    return {
+        magic,
+        type,
+        qualifiedSigner,
+        extraData,
+        clockInfo,
+        firmwareVersion,
+        attested,
+    };
+}

package/esm/registration/verifications/tpm/parsePubArea.js

@@ -0,0 +1,94 @@
+import { TPM_ALG, TPM_ECC_CURVE } from './constants.js';
+import { isoUint8Array } from '../../../helpers/iso/index.js';
+/**
+ * Break apart a TPM attestation's pubArea buffer
+ *
+ * See 12.2.4 TPMT_PUBLIC here:
+ * https://trustedcomputinggroup.org/wp-content/uploads/TPM-Rev-2.0-Part-2-Structures-00.96-130315.pdf
+ */
+export function parsePubArea(pubArea) {
+    let pointer = 0;
+    const dataView = isoUint8Array.toDataView(pubArea);
+    const type = TPM_ALG[dataView.getUint16(pointer)];
+    pointer += 2;
+    const nameAlg = TPM_ALG[dataView.getUint16(pointer)];
+    pointer += 2;
+    // Get some authenticator attributes(?)
+    // const objectAttributesInt = pubArea.slice(pointer, (pointer += 4)).readUInt32BE(0);
+    const objectAttributesInt = dataView.getUint32(pointer);
+    pointer += 4;
+    const objectAttributes = {
+        fixedTPM: !!(objectAttributesInt & 1),
+        stClear: !!(objectAttributesInt & 2),
+        fixedParent: !!(objectAttributesInt & 8),
+        sensitiveDataOrigin: !!(objectAttributesInt & 16),
+        userWithAuth: !!(objectAttributesInt & 32),
+        adminWithPolicy: !!(objectAttributesInt & 64),
+        noDA: !!(objectAttributesInt & 512),
+        encryptedDuplication: !!(objectAttributesInt & 1024),
+        restricted: !!(objectAttributesInt & 32768),
+        decrypt: !!(objectAttributesInt & 65536),
+        signOrEncrypt: !!(objectAttributesInt & 131072),
+    };
+    // Slice out the authPolicy of dynamic length
+    const authPolicyLength = dataView.getUint16(pointer);
+    pointer += 2;
+    const authPolicy = pubArea.slice(pointer, pointer += authPolicyLength);
+    // Extract additional curve params according to type
+    const parameters = {};
+    let unique = Uint8Array.from([]);
+    if (type === 'TPM_ALG_RSA') {
+        const symmetric = TPM_ALG[dataView.getUint16(pointer)];
+        pointer += 2;
+        const scheme = TPM_ALG[dataView.getUint16(pointer)];
+        pointer += 2;
+        const keyBits = dataView.getUint16(pointer);
+        pointer += 2;
+        const exponent = dataView.getUint32(pointer);
+        pointer += 4;
+        parameters.rsa = { symmetric, scheme, keyBits, exponent };
+        /**
+         * See 11.2.4.5 TPM2B_PUBLIC_KEY_RSA here:
+         * https://trustedcomputinggroup.org/wp-content/uploads/TPM-Rev-2.0-Part-2-Structures-00.96-130315.pdf
+         */
+        // const uniqueLength = pubArea.slice(pointer, (pointer += 2)).readUInt16BE(0);
+        const uniqueLength = dataView.getUint16(pointer);
+        pointer += 2;
+        unique = pubArea.slice(pointer, pointer += uniqueLength);
+    }
+    else if (type === 'TPM_ALG_ECC') {
+        const symmetric = TPM_ALG[dataView.getUint16(pointer)];
+        pointer += 2;
+        const scheme = TPM_ALG[dataView.getUint16(pointer)];
+        pointer += 2;
+        const curveID = TPM_ECC_CURVE[dataView.getUint16(pointer)];
+        pointer += 2;
+        const kdf = TPM_ALG[dataView.getUint16(pointer)];
+        pointer += 2;
+        parameters.ecc = { symmetric, scheme, curveID, kdf };
+        /**
+         * See 11.2.5.1 TPM2B_ECC_PARAMETER here:
+         * https://trustedcomputinggroup.org/wp-content/uploads/TPM-Rev-2.0-Part-2-Structures-00.96-130315.pdf
+         */
+        // Retrieve X
+        const uniqueXLength = dataView.getUint16(pointer);
+        pointer += 2;
+        const uniqueX = pubArea.slice(pointer, pointer += uniqueXLength);
+        // Retrieve Y
+        const uniqueYLength = dataView.getUint16(pointer);
+        pointer += 2;
+        const uniqueY = pubArea.slice(pointer, pointer += uniqueYLength);
+        unique = isoUint8Array.concat([uniqueX, uniqueY]);
+    }
+    else {
+        throw new Error(`Unexpected type "${type}" (TPM)`);
+    }
+    return {
+        type,
+        nameAlg,
+        objectAttributes,
+        authPolicy,
+        parameters,
+        unique,
+    };
+}

package/{dist → esm}/registration/verifications/tpm/verifyAttestationTPM.d.ts

@@ -1,2 +1,2 @@
-import type { AttestationFormatVerifierOpts } from '../../verifyRegistrationResponse';
+import type { AttestationFormatVerifierOpts } from '../../verifyRegistrationResponse.js';
 export declare function verifyAttestationTPM(options: AttestationFormatVerifierOpts): Promise<boolean>;

package/esm/registration/verifications/tpm/verifyAttestationTPM.js

@@ -0,0 +1,323 @@
+import { AsnParser, Certificate, ExtendedKeyUsage, id_ce_extKeyUsage, id_ce_subjectAltName, SubjectAlternativeName, } from '../../../deps.js';
+import { decodeCredentialPublicKey } from '../../../helpers/decodeCredentialPublicKey.js';
+import { COSEALG, COSEKEYS, isCOSEAlg, isCOSEPublicKeyEC2, isCOSEPublicKeyRSA, } from '../../../helpers/cose.js';
+import { toHash } from '../../../helpers/toHash.js';
+import { convertCertBufferToPEM } from '../../../helpers/convertCertBufferToPEM.js';
+import { validateCertificatePath } from '../../../helpers/validateCertificatePath.js';
+import { getCertificateInfo } from '../../../helpers/getCertificateInfo.js';
+import { verifySignature } from '../../../helpers/verifySignature.js';
+import { isoUint8Array } from '../../../helpers/iso/index.js';
+import { MetadataService } from '../../../services/metadataService.js';
+import { verifyAttestationWithMetadata } from '../../../metadata/verifyAttestationWithMetadata.js';
+import { TPM_ECC_CURVE_COSE_CRV_MAP, TPM_MANUFACTURERS } from './constants.js';
+import { parseCertInfo } from './parseCertInfo.js';
+import { parsePubArea } from './parsePubArea.js';
+export async function verifyAttestationTPM(options) {
+    const { aaguid, attStmt, authData, credentialPublicKey, clientDataHash, rootCertificates, } = options;
+    const ver = attStmt.get('ver');
+    const sig = attStmt.get('sig');
+    const alg = attStmt.get('alg');
+    const x5c = attStmt.get('x5c');
+    const pubArea = attStmt.get('pubArea');
+    const certInfo = attStmt.get('certInfo');
+    /**
+     * Verify structures
+     */
+    if (ver !== '2.0') {
+        throw new Error(`Unexpected ver "${ver}", expected "2.0" (TPM)`);
+    }
+    if (!sig) {
+        throw new Error('No attestation signature provided in attestation statement (TPM)');
+    }
+    if (!alg) {
+        throw new Error(`Attestation statement did not contain alg (TPM)`);
+    }
+    if (!isCOSEAlg(alg)) {
+        throw new Error(`Attestation statement contained invalid alg ${alg} (TPM)`);
+    }
+    if (!x5c) {
+        throw new Error('No attestation certificate provided in attestation statement (TPM)');
+    }
+    if (!pubArea) {
+        throw new Error('Attestation statement did not contain pubArea (TPM)');
+    }
+    if (!certInfo) {
+        throw new Error('Attestation statement did not contain certInfo (TPM)');
+    }
+    const parsedPubArea = parsePubArea(pubArea);
+    const { unique, type: pubType, parameters } = parsedPubArea;
+    // Verify that the public key specified by the parameters and unique fields of pubArea is
+    // identical to the credentialPublicKey in the attestedCredentialData in authenticatorData.
+    const cosePublicKey = decodeCredentialPublicKey(credentialPublicKey);
+    if (pubType === 'TPM_ALG_RSA') {
+        if (!isCOSEPublicKeyRSA(cosePublicKey)) {
+            throw new Error(`Credential public key with kty ${cosePublicKey.get(COSEKEYS.kty)} did not match ${pubType}`);
+        }
+        const n = cosePublicKey.get(COSEKEYS.n);
+        const e = cosePublicKey.get(COSEKEYS.e);
+        if (!n) {
+            throw new Error('COSE public key missing n (TPM|RSA)');
+        }
+        if (!e) {
+            throw new Error('COSE public key missing e (TPM|RSA)');
+        }
+        if (!isoUint8Array.areEqual(unique, n)) {
+            throw new Error('PubArea unique is not same as credentialPublicKey (TPM|RSA)');
+        }
+        if (!parameters.rsa) {
+            throw new Error(`Parsed pubArea type is RSA, but missing parameters.rsa (TPM|RSA)`);
+        }
+        const eBuffer = e;
+        // If `exponent` is equal to 0x00, then exponent is the default RSA exponent of 2^16+1 (65537)
+        const pubAreaExponent = parameters.rsa.exponent || 65537;
+        // Do some bit shifting to get to an integer
+        const eSum = eBuffer[0] + (eBuffer[1] << 8) + (eBuffer[2] << 16);
+        if (pubAreaExponent !== eSum) {
+            throw new Error(`Unexpected public key exp ${eSum}, expected ${pubAreaExponent} (TPM|RSA)`);
+        }
+    }
+    else if (pubType === 'TPM_ALG_ECC') {
+        if (!isCOSEPublicKeyEC2(cosePublicKey)) {
+            throw new Error(`Credential public key with kty ${cosePublicKey.get(COSEKEYS.kty)} did not match ${pubType}`);
+        }
+        const crv = cosePublicKey.get(COSEKEYS.crv);
+        const x = cosePublicKey.get(COSEKEYS.x);
+        const y = cosePublicKey.get(COSEKEYS.y);
+        if (!crv) {
+            throw new Error('COSE public key missing crv (TPM|ECC)');
+        }
+        if (!x) {
+            throw new Error('COSE public key missing x (TPM|ECC)');
+        }
+        if (!y) {
+            throw new Error('COSE public key missing y (TPM|ECC)');
+        }
+        if (!isoUint8Array.areEqual(unique, isoUint8Array.concat([x, y]))) {
+            throw new Error('PubArea unique is not same as public key x and y (TPM|ECC)');
+        }
+        if (!parameters.ecc) {
+            throw new Error(`Parsed pubArea type is ECC, but missing parameters.ecc (TPM|ECC)`);
+        }
+        const pubAreaCurveID = parameters.ecc.curveID;
+        const pubAreaCurveIDMapToCOSECRV = TPM_ECC_CURVE_COSE_CRV_MAP[pubAreaCurveID];
+        if (pubAreaCurveIDMapToCOSECRV !== crv) {
+            throw new Error(`Public area key curve ID "${pubAreaCurveID}" mapped to "${pubAreaCurveIDMapToCOSECRV}" which did not match public key crv of "${crv}" (TPM|ECC)`);
+        }
+    }
+    else {
+        throw new Error(`Unsupported pubArea.type "${pubType}"`);
+    }
+    const parsedCertInfo = parseCertInfo(certInfo);
+    const { magic, type: certType, attested, extraData } = parsedCertInfo;
+    if (magic !== 0xff544347) {
+        throw new Error(`Unexpected magic value "${magic}", expected "0xff544347" (TPM)`);
+    }
+    if (certType !== 'TPM_ST_ATTEST_CERTIFY') {
+        throw new Error(`Unexpected type "${certType}", expected "TPM_ST_ATTEST_CERTIFY" (TPM)`);
+    }
+    // Hash pubArea to create pubAreaHash using the nameAlg in attested
+    const pubAreaHash = await toHash(pubArea, attestedNameAlgToCOSEAlg(attested.nameAlg));
+    // Concatenate attested.nameAlg and pubAreaHash to create attestedName.
+    const attestedName = isoUint8Array.concat([
+        attested.nameAlgBuffer,
+        pubAreaHash,
+    ]);
+    // Check that certInfo.attested.name is equals to attestedName.
+    if (!isoUint8Array.areEqual(attested.name, attestedName)) {
+        throw new Error(`Attested name comparison failed (TPM)`);
+    }
+    // Concatenate authData with clientDataHash to create attToBeSigned
+    const attToBeSigned = isoUint8Array.concat([authData, clientDataHash]);
+    // Hash attToBeSigned using the algorithm specified in attStmt.alg to create attToBeSignedHash
+    const attToBeSignedHash = await toHash(attToBeSigned, alg);
+    // Check that certInfo.extraData is equals to attToBeSignedHash.
+    if (!isoUint8Array.areEqual(extraData, attToBeSignedHash)) {
+        throw new Error('CertInfo extra data did not equal hashed attestation (TPM)');
+    }
+    /**
+     * Verify signature
+     */
+    if (x5c.length < 1) {
+        throw new Error('No certificates present in x5c array (TPM)');
+    }
+    // Pick a leaf AIK certificate of the x5c array and parse it.
+    const leafCertInfo = getCertificateInfo(x5c[0]);
+    const { basicConstraintsCA, version, subject, notAfter, notBefore } = leafCertInfo;
+    if (basicConstraintsCA) {
+        throw new Error('Certificate basic constraints CA was not `false` (TPM)');
+    }
+    // Check that certificate is of version 3 (value must be set to 2).
+    if (version !== 2) {
+        throw new Error('Certificate version was not `3` (ASN.1 value of 2) (TPM)');
+    }
+    // Check that Subject sequence is empty.
+    if (subject.combined.length > 0) {
+        throw new Error('Certificate subject was not empty (TPM)');
+    }
+    // Check that certificate is currently valid
+    let now = new Date();
+    if (notBefore > now) {
+        throw new Error(`Certificate not good before "${notBefore.toString()}" (TPM)`);
+    }
+    // Check that certificate has not expired
+    now = new Date();
+    if (notAfter < now) {
+        throw new Error(`Certificate not good after "${notAfter.toString()}" (TPM)`);
+    }
+    /**
+     * Plumb the depths of the certificate's ASN.1-formatted data for some values we need to verify
+     */
+    const parsedCert = AsnParser.parse(x5c[0], Certificate);
+    if (!parsedCert.tbsCertificate.extensions) {
+        throw new Error('Certificate was missing extensions (TPM)');
+    }
+    let subjectAltNamePresent;
+    let extKeyUsage;
+    parsedCert.tbsCertificate.extensions.forEach((ext) => {
+        if (ext.extnID === id_ce_subjectAltName) {
+            subjectAltNamePresent = AsnParser.parse(ext.extnValue, SubjectAlternativeName);
+        }
+        else if (ext.extnID === id_ce_extKeyUsage) {
+            extKeyUsage = AsnParser.parse(ext.extnValue, ExtendedKeyUsage);
+        }
+    });
+    // Check that certificate contains subjectAltName (2.5.29.17) extension,
+    if (!subjectAltNamePresent) {
+        throw new Error('Certificate did not contain subjectAltName extension (TPM)');
+    }
+    // TPM-specific values are buried within `directoryName`, so first make sure there are values
+    // there.
+    if (!subjectAltNamePresent[0].directoryName?.[0].length) {
+        throw new Error('Certificate subjectAltName extension directoryName was empty (TPM)');
+    }
+    const { tcgAtTpmManufacturer, tcgAtTpmModel, tcgAtTpmVersion } = getTcgAtTpmValues(subjectAltNamePresent[0].directoryName);
+    if (!tcgAtTpmManufacturer || !tcgAtTpmModel || !tcgAtTpmVersion) {
+        throw new Error('Certificate contained incomplete subjectAltName data (TPM)');
+    }
+    if (!extKeyUsage) {
+        throw new Error('Certificate did not contain ExtendedKeyUsage extension (TPM)');
+    }
+    // Check that tcpaTpmManufacturer (2.23.133.2.1) field is set to a valid manufacturer ID.
+    if (!TPM_MANUFACTURERS[tcgAtTpmManufacturer]) {
+        throw new Error(`Could not match TPM manufacturer "${tcgAtTpmManufacturer}" (TPM)`);
+    }
+    // Check that certificate contains extKeyUsage (2.5.29.37) extension and it must contain
+    // tcg-kp-AIKCertificate (2.23.133.8.3) OID.
+    if (extKeyUsage[0] !== '2.23.133.8.3') {
+        throw new Error(`Unexpected extKeyUsage "${extKeyUsage[0]}", expected "2.23.133.8.3" (TPM)`);
+    }
+    // TODO: If certificate contains id-fido-gen-ce-aaguid(1.3.6.1.4.1.45724.1.1.4) extension, check
+    // that it’s value is set to the same AAGUID as in authData.
+    // Run some metadata checks if a statement exists for this authenticator
+    const statement = await MetadataService.getStatement(aaguid);
+    if (statement) {
+        try {
+            await verifyAttestationWithMetadata({
+                statement,
+                credentialPublicKey,
+                x5c,
+                attestationStatementAlg: alg,
+            });
+        }
+        catch (err) {
+            const _err = err;
+            throw new Error(`${_err.message} (TPM)`);
+        }
+    }
+    else {
+        try {
+            // Try validating the certificate path using the root certificates set via SettingsService
+            await validateCertificatePath(x5c.map(convertCertBufferToPEM), rootCertificates);
+        }
+        catch (err) {
+            const _err = err;
+            throw new Error(`${_err.message} (TPM)`);
+        }
+    }
+    // Verify signature over certInfo with the public key extracted from AIK certificate.
+    // In the wise words of Yuriy Ackermann: "Get Martini friend, you are done!"
+    return verifySignature({
+        signature: sig,
+        data: certInfo,
+        x509Certificate: x5c[0],
+        hashAlgorithm: alg,
+    });
+}
+/**
+ * Contain logic for pulling TPM-specific values out of subjectAlternativeName extension
+ */
+function getTcgAtTpmValues(root) {
+    const oidManufacturer = '2.23.133.2.1';
+    const oidModel = '2.23.133.2.2';
+    const oidVersion = '2.23.133.2.3';
+    let tcgAtTpmManufacturer;
+    let tcgAtTpmModel;
+    let tcgAtTpmVersion;
+    /**
+     * Iterate through the following potential structures:
+     *
+     * (Good, follows the spec)
+     * https://trustedcomputinggroup.org/wp-content/uploads/TCG_IWG_EKCredentialProfile_v2p3_r2_pub.pdf (page 33)
+     * Name [
+     *   RelativeDistinguishedName [
+     *     AttributeTypeAndValue { type, value }
+     *   ]
+     *   RelativeDistinguishedName [
+     *     AttributeTypeAndValue { type, value }
+     *   ]
+     *   RelativeDistinguishedName [
+     *     AttributeTypeAndValue { type, value }
+     *   ]
+     * ]
+     *
+     * (Bad, does not follow the spec)
+     * Name [
+     *   RelativeDistinguishedName [
+     *     AttributeTypeAndValue { type, value }
+     *     AttributeTypeAndValue { type, value }
+     *     AttributeTypeAndValue { type, value }
+     *   ]
+     * ]
+     *
+     * Both structures have been seen in the wild and need to be supported
+     */
+    root.forEach((relName) => {
+        relName.forEach((attr) => {
+            if (attr.type === oidManufacturer) {
+                tcgAtTpmManufacturer = attr.value.toString();
+            }
+            else if (attr.type === oidModel) {
+                tcgAtTpmModel = attr.value.toString();
+            }
+            else if (attr.type === oidVersion) {
+                tcgAtTpmVersion = attr.value.toString();
+            }
+        });
+    });
+    return {
+        tcgAtTpmManufacturer,
+        tcgAtTpmModel,
+        tcgAtTpmVersion,
+    };
+}
+/**
+ * Convert TPM-specific SHA algorithm ID's with COSE-specific equivalents. Note that the choice to
+ * use ECDSA SHA IDs is arbitrary; any such COSEALG that would map to SHA-256 in
+ * `mapCoseAlgToWebCryptoAlg()`
+ *
+ * SHA IDs referenced from here:
+ *
+ * https://trustedcomputinggroup.org/wp-content/uploads/TCG_TPM2_r1p59_Part2_Structures_pub.pdf
+ */
+function attestedNameAlgToCOSEAlg(alg) {
+    if (alg === 'TPM_ALG_SHA256') {
+        return COSEALG.ES256;
+    }
+    else if (alg === 'TPM_ALG_SHA384') {
+        return COSEALG.ES384;
+    }
+    else if (alg === 'TPM_ALG_SHA512') {
+        return COSEALG.ES512;
+    }
+    throw new Error(`Unexpected TPM attested name alg ${alg}`);
+}

package/{dist → esm}/registration/verifications/verifyAttestationAndroidKey.d.ts

@@ -1,4 +1,4 @@
-import type { AttestationFormatVerifierOpts } from '../verifyRegistrationResponse';
+import type { AttestationFormatVerifierOpts } from '../verifyRegistrationResponse.js';
 /**
  * Verify an attestation response with fmt 'android-key'
  */