wherdr 0.0.0-stage → 1.2.0

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/generateChallenge.js

@@ -0,0 +1,24 @@
+import { isoCrypto } from './iso/index.js';
+/**
+ * Generate a suitably random value to be used as an attestation or assertion challenge
+ */
+export async function generateChallenge() {
+    /**
+     * WebAuthn spec says that 16 bytes is a good minimum:
+     *
+     * "In order to prevent replay attacks, the challenges MUST contain enough entropy to make
+     * guessing them infeasible. Challenges SHOULD therefore be at least 16 bytes long."
+     *
+     * Just in case, let's double it
+     */
+    const challenge = new Uint8Array(32);
+    await isoCrypto.getRandomValues(challenge);
+    return _generateChallengeInternals.stubThis(challenge);
+}
+/**
+ * Make it possible to stub the return value during testing
+ * @ignore Don't include this in docs output
+ */
+export const _generateChallengeInternals = {
+    stubThis: (value) => value,
+};

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/generateUserID.js

@@ -0,0 +1,20 @@
+import { isoCrypto } from './iso/index.js';
+/**
+ * Generate a suitably random value to be used as user ID
+ */
+export async function generateUserID() {
+    /**
+     * WebAuthn spec says user.id has a max length of 64 bytes. I prefer how 32 random bytes look
+     * after they're base64url-encoded so I'm choosing to go with that here.
+     */
+    const newUserID = new Uint8Array(32);
+    await isoCrypto.getRandomValues(newUserID);
+    return _generateUserIDInternals.stubThis(newUserID);
+}
+/**
+ * Make it possible to stub the return value during testing
+ * @ignore Don't include this in docs output
+ */
+export const _generateUserIDInternals = {
+    stubThis: (value) => value,
+};

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/getCertificateInfo.js

@@ -0,0 +1,77 @@
+import { AsnParser } from '@peculiar/asn1-schema';
+import { BasicConstraints, Certificate, id_ce_basicConstraints } from '@peculiar/asn1-x509';
+const issuerSubjectIDKey = {
+    '2.5.4.6': 'C',
+    '2.5.4.10': 'O',
+    '2.5.4.11': 'OU',
+    '2.5.4.3': 'CN',
+};
+/**
+ * Extract PEM certificate info
+ *
+ * @param pemCertificate Result from call to `convertASN1toPEM(x5c[0])`
+ */
+export function getCertificateInfo(leafCertBuffer) {
+    const x509 = AsnParser.parse(leafCertBuffer, Certificate);
+    const parsedCert = x509.tbsCertificate;
+    // Issuer
+    const issuer = { combined: '' };
+    parsedCert.issuer.forEach(([iss]) => {
+        const key = issuerSubjectIDKey[iss.type];
+        if (key) {
+            issuer[key] = iss.value.toString();
+        }
+    });
+    issuer.combined = issuerSubjectToString(issuer);
+    // Subject
+    const subject = { combined: '' };
+    parsedCert.subject.forEach(([iss]) => {
+        const key = issuerSubjectIDKey[iss.type];
+        if (key) {
+            subject[key] = iss.value.toString();
+        }
+    });
+    subject.combined = issuerSubjectToString(subject);
+    let basicConstraintsCA = false;
+    if (parsedCert.extensions) {
+        // console.log(parsedCert.extensions);
+        for (const ext of parsedCert.extensions) {
+            if (ext.extnID === id_ce_basicConstraints) {
+                const basicConstraints = AsnParser.parse(ext.extnValue, BasicConstraints);
+                basicConstraintsCA = basicConstraints.cA;
+            }
+        }
+    }
+    return {
+        issuer,
+        subject,
+        version: parsedCert.version,
+        basicConstraintsCA,
+        notBefore: parsedCert.validity.notBefore.getTime(),
+        notAfter: parsedCert.validity.notAfter.getTime(),
+        parsedCertificate: x509,
+    };
+}
+/**
+ * Stringify the parts of Issuer or Subject info for easier comparison of subject issuers with
+ * issuer subjects.
+ *
+ * The order might seem arbitrary, because it is. It should be enough that the two are stringified
+ * in the same order.
+ */
+function issuerSubjectToString(input) {
+    const parts = [];
+    if (input.C) {
+        parts.push(input.C);
+    }
+    if (input.O) {
+        parts.push(input.O);
+    }
+    if (input.OU) {
+        parts.push(input.OU);
+    }
+    if (input.CN) {
+        parts.push(input.CN);
+    }
+    return parts.join(' : ');
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/index.js

@@ -0,0 +1,17 @@
+export * from './convertAAGUIDToString.js';
+export * from './convertCertBufferToPEM.js';
+export * from './convertCOSEtoPKCS.js';
+export * from './decodeAttestationObject.js';
+export * from './decodeClientDataJSON.js';
+export * from './decodeCredentialPublicKey.js';
+export * from './generateChallenge.js';
+export * from './generateUserID.js';
+export * from './getCertificateInfo.js';
+export * from './isCertRevoked.js';
+export * from './parseAuthenticatorData.js';
+export * from './toHash.js';
+export * from './validateCertificatePath.js';
+export * from './verifySignature.js';
+export * from './iso/index.js';
+export * from '../metadata/verifyMDSBlob.js';
+export * as cose from './cose.js';

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/isCertRevoked.js

@@ -0,0 +1,96 @@
+import { AuthorityKeyIdentifierExtension, CRLDistributionPointsExtension, SubjectKeyIdentifierExtension, X509Crl, } from '@peculiar/x509';
+import { fetch } from './fetch.js';
+const cacheRevokedCerts = {};
+/**
+ * A method to pull a CRL from a certificate and compare its serial number to the list of revoked
+ * certificate serial numbers within the CRL.
+ *
+ * CRL certificate structure referenced from https://tools.ietf.org/html/rfc5280#page-117
+ */
+export async function isCertRevoked(cert) {
+    const { extensions } = cert;
+    if (!extensions) {
+        return false;
+    }
+    let extAuthorityKeyID;
+    let extSubjectKeyID;
+    let extCRLDistributionPoints;
+    extensions.forEach((ext) => {
+        if (ext instanceof AuthorityKeyIdentifierExtension) {
+            extAuthorityKeyID = ext;
+        }
+        else if (ext instanceof SubjectKeyIdentifierExtension) {
+            extSubjectKeyID = ext;
+        }
+        else if (ext instanceof CRLDistributionPointsExtension) {
+            extCRLDistributionPoints = ext;
+        }
+    });
+    // Check to see if we've got cached info for the cert's CA
+    let keyIdentifier = undefined;
+    if (extAuthorityKeyID && extAuthorityKeyID.keyId) {
+        keyIdentifier = extAuthorityKeyID.keyId;
+    }
+    else if (extSubjectKeyID) {
+        /**
+         * We might be dealing with a self-signed root certificate. Check the
+         * Subject key Identifier extension next.
+         */
+        keyIdentifier = extSubjectKeyID.keyId;
+    }
+    if (keyIdentifier) {
+        const cached = cacheRevokedCerts[keyIdentifier];
+        if (cached) {
+            const now = new Date();
+            // If there's a nextUpdate then make sure we're before it
+            if (!cached.nextUpdate || cached.nextUpdate > now) {
+                return cached.revokedCerts.indexOf(cert.serialNumber) >= 0;
+            }
+        }
+    }
+    const crlURL = extCRLDistributionPoints?.distributionPoints?.[0].distributionPoint?.fullName?.[0]
+        .uniformResourceIdentifier;
+    // If no URL is provided then we have nothing to check
+    if (!crlURL) {
+        return false;
+    }
+    // Download and read the CRL
+    let certListBytes;
+    try {
+        const respCRL = await fetch(crlURL);
+        certListBytes = await respCRL.arrayBuffer();
+    }
+    catch (_err) {
+        return false;
+    }
+    let data;
+    try {
+        data = new X509Crl(certListBytes);
+    }
+    catch (_err) {
+        // Something was malformed with the CRL, so pass
+        return false;
+    }
+    const newCached = {
+        revokedCerts: [],
+        nextUpdate: undefined,
+    };
+    // nextUpdate
+    if (data.nextUpdate) {
+        newCached.nextUpdate = data.nextUpdate;
+    }
+    // revokedCertificates
+    const revokedCerts = data.entries;
+    if (revokedCerts) {
+        for (const cert of revokedCerts) {
+            const revokedHex = cert.serialNumber;
+            newCached.revokedCerts.push(revokedHex);
+        }
+        // Cache the results
+        if (keyIdentifier) {
+            cacheRevokedCerts[keyIdentifier] = newCached;
+        }
+        return newCached.revokedCerts.indexOf(cert.serialNumber) >= 0;
+    }
+    return false;
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/index.js

@@ -0,0 +1,11 @@
+/**
+ * A collection of methods for isomorphic manipulation of trickier data types
+ *
+ * The goal with these is to make it easier to replace dependencies later that might not play well
+ * with specific server-like runtimes that expose global Web APIs (CloudFlare Workers, Deno, Bun,
+ * etc...), while also supporting execution in Node.
+ */
+export * as isoBase64URL from './isoBase64URL.js';
+export * as isoCBOR from './isoCBOR.js';
+export * as isoCrypto from './isoCrypto/index.js';
+export * as isoUint8Array from './isoUint8Array.js';

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoBase64URL.js

@@ -0,0 +1,72 @@
+/**
+ * A runtime-agnostic collection of methods for working with Base64URL encoding
+ * @module
+ */
+import base64 from '@hexagon/base64';
+/**
+ * Decode from a Base64URL-encoded string to an ArrayBuffer. Best used when converting a
+ * credential ID from a JSON string to an ArrayBuffer, like in allowCredentials or
+ * excludeCredentials.
+ *
+ * @param buffer Value to decode from base64
+ * @param to (optional) The decoding to use, in case it's desirable to decode from base64 instead
+ */
+export function toBuffer(base64urlString, from = 'base64url') {
+    const _buffer = base64.toArrayBuffer(base64urlString, from === 'base64url');
+    return new Uint8Array(_buffer);
+}
+/**
+ * Encode the given array buffer into a Base64URL-encoded string. Ideal for converting various
+ * credential response ArrayBuffers to string for sending back to the server as JSON.
+ *
+ * @param buffer Value to encode to base64
+ * @param to (optional) The encoding to use, in case it's desirable to encode to base64 instead
+ */
+export function fromBuffer(buffer, to = 'base64url') {
+    /**
+     * Gracefully handle Uint8Array subclass types, like Node's Buffer, that can have a large
+     * ArrayBuffer backing it.
+     */
+    const _normalized = new Uint8Array(buffer);
+    return base64.fromArrayBuffer(_normalized.buffer, to === 'base64url');
+}
+/**
+ * Convert a base64url string into base64
+ */
+export function toBase64(base64urlString) {
+    const fromBase64Url = base64.toArrayBuffer(base64urlString, true);
+    const toBase64 = base64.fromArrayBuffer(fromBase64Url);
+    return toBase64;
+}
+/**
+ * Encode a UTF-8 string to base64url
+ */
+export function fromUTF8String(utf8String) {
+    return base64.fromString(utf8String, true);
+}
+/**
+ * Decode a base64url string into its original UTF-8 string
+ */
+export function toUTF8String(base64urlString) {
+    return base64.toString(base64urlString, true);
+}
+/**
+ * Confirm that the string is encoded into base64
+ */
+export function isBase64(input) {
+    return base64.validate(input, false);
+}
+/**
+ * Confirm that the string is encoded into base64url, with support for optional padding
+ */
+export function isBase64URL(input) {
+    // Trim padding characters from the string if present
+    input = trimPadding(input);
+    return base64.validate(input, true);
+}
+/**
+ * Remove optional padding from a base64url-encoded string
+ */
+export function trimPadding(input) {
+    return input.replace(/=/g, '');
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCBOR.js

@@ -0,0 +1,35 @@
+/**
+ * A runtime-agnostic collection of methods for working with CBOR encoding
+ * @module
+ */
+import * as tinyCbor from '@levischuck/tiny-cbor';
+/**
+ * Whatever CBOR encoder is used should keep CBOR data the same length when data is re-encoded
+ *
+ * MOST CRITICALLY, this means the following needs to be true of whatever CBOR library we use:
+ * - CBOR Map type values MUST decode to JavaScript Maps
+ * - CBOR tag 64 (uint8 Typed Array) MUST NOT be used when encoding Uint8Arrays back to CBOR
+ *
+ * So long as these requirements are maintained, then CBOR sequences can be encoded and decoded
+ * freely while maintaining their lengths for the most accurate pointer movement across them.
+ */
+/**
+ * Decode and return the first item in a sequence of CBOR-encoded values
+ *
+ * @param input The CBOR data to decode
+ * @param asObject (optional) Whether to convert any CBOR Maps into JavaScript Objects. Defaults to
+ * `false`
+ */
+export function decodeFirst(input) {
+    // Make a copy so we don't mutate the original
+    const _input = new Uint8Array(input);
+    const decoded = tinyCbor.decodePartialCBOR(_input, 0);
+    const [first] = decoded;
+    return first;
+}
+/**
+ * Encode data to CBOR
+ */
+export function encode(input) {
+    return tinyCbor.encodeCBOR(input);
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/digest.js

@@ -0,0 +1,14 @@
+import { mapCoseAlgToWebCryptoAlg } from './mapCoseAlgToWebCryptoAlg.js';
+import { getWebCrypto } from './getWebCrypto.js';
+/**
+ * Generate a digest of the provided data.
+ *
+ * @param data The data to generate a digest of
+ * @param algorithm A COSE algorithm ID that maps to a desired SHA algorithm
+ */
+export async function digest(data, algorithm) {
+    const WebCrypto = await getWebCrypto();
+    const subtleAlgorithm = mapCoseAlgToWebCryptoAlg(algorithm);
+    const hashed = await WebCrypto.subtle.digest(subtleAlgorithm, data);
+    return new Uint8Array(hashed);
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/getRandomValues.js

@@ -0,0 +1,11 @@
+import { getWebCrypto } from './getWebCrypto.js';
+/**
+ * Fill up the provided bytes array with random bytes equal to its length.
+ *
+ * @returns the same bytes array passed into the method
+ */
+export async function getRandomValues(array) {
+    const WebCrypto = await getWebCrypto();
+    WebCrypto.getRandomValues(array);
+    return array;
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/getWebCrypto.js

@@ -0,0 +1,49 @@
+let webCrypto = undefined;
+/**
+ * Try to get an instance of the Crypto API from the current runtime. Should support Node,
+ * as well as others, like Deno, that implement Web APIs.
+ */
+export function getWebCrypto() {
+    /**
+     * Hello there! If you came here wondering why this method is asynchronous when use of
+     * `globalThis.crypto` is not, it's to minimize a bunch of refactor related to making this
+     * synchronous. For example, `generateRegistrationOptions()` and `generateAuthenticationOptions()`
+     * become synchronous if we make this synchronous (since nothing else in that method is async)
+     * which represents a breaking API change in this library's core API.
+     *
+     * TODO: If it's after February 2025 when you read this then consider whether it still makes sense
+     * to keep this method asynchronous.
+     */
+    const toResolve = new Promise((resolve, reject) => {
+        if (webCrypto) {
+            return resolve(webCrypto);
+        }
+        /**
+         * Naively attempt to access Crypto as a global object, which popular ESM-centric run-times
+         * support (and Node v20+)
+         */
+        const _globalThisCrypto = _getWebCryptoInternals.stubThisGlobalThisCrypto();
+        if (_globalThisCrypto) {
+            webCrypto = _globalThisCrypto;
+            return resolve(webCrypto);
+        }
+        // We tried to access it both in Node and globally, so bail out
+        return reject(new MissingWebCrypto());
+    });
+    return toResolve;
+}
+export class MissingWebCrypto extends Error {
+    constructor() {
+        const message = 'An instance of the Crypto API could not be located';
+        super(message);
+        this.name = 'MissingWebCrypto';
+    }
+}
+// Make it possible to stub return values during testing
+export const _getWebCryptoInternals = {
+    stubThisGlobalThisCrypto: () => globalThis.crypto,
+    // Make it possible to reset the `webCrypto` at the top of the file
+    setCachedCrypto: (newCrypto) => {
+        webCrypto = newCrypto;
+    },
+};

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/importKey.js

@@ -0,0 +1,8 @@
+import { getWebCrypto } from './getWebCrypto.js';
+export async function importKey(opts) {
+    const WebCrypto = await getWebCrypto();
+    const { keyData, algorithm } = opts;
+    return WebCrypto.subtle.importKey('jwk', keyData, algorithm, false, [
+        'verify',
+    ]);
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/index.js

@@ -0,0 +1,7 @@
+/**
+ * A runtime-agnostic collection of methods for working with the WebCrypto API
+ * @module
+ */
+export { digest } from './digest.js';
+export { getRandomValues } from './getRandomValues.js';
+export { verify } from './verify.js';

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/mapCoseAlgToWebCryptoAlg.js

@@ -0,0 +1,20 @@
+import { COSEALG } from '../../cose.js';
+/**
+ * Convert a COSE alg ID into a corresponding string value that WebCrypto APIs expect
+ */
+export function mapCoseAlgToWebCryptoAlg(alg) {
+    if ([COSEALG.RS1].indexOf(alg) >= 0) {
+        return 'SHA-1';
+    }
+    else if ([COSEALG.ES256, COSEALG.PS256, COSEALG.RS256].indexOf(alg) >= 0) {
+        return 'SHA-256';
+    }
+    else if ([COSEALG.ES384, COSEALG.PS384, COSEALG.RS384].indexOf(alg) >= 0) {
+        return 'SHA-384';
+    }
+    else if ([COSEALG.ES512, COSEALG.PS512, COSEALG.RS512, COSEALG.EdDSA].indexOf(alg) >=
+        0) {
+        return 'SHA-512';
+    }
+    throw new Error(`Could not map COSE alg value of ${alg} to a WebCrypto alg`);
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/mapCoseAlgToWebCryptoKeyAlgName.js

@@ -0,0 +1,19 @@
+import { COSEALG } from '../../cose.js';
+/**
+ * Convert a COSE alg ID into a corresponding key algorithm string value that WebCrypto APIs expect
+ */
+export function mapCoseAlgToWebCryptoKeyAlgName(alg) {
+    if ([COSEALG.EdDSA].indexOf(alg) >= 0) {
+        return 'Ed25519';
+    }
+    else if ([COSEALG.ES256, COSEALG.ES384, COSEALG.ES512, COSEALG.ES256K].indexOf(alg) >= 0) {
+        return 'ECDSA';
+    }
+    else if ([COSEALG.RS256, COSEALG.RS384, COSEALG.RS512, COSEALG.RS1].indexOf(alg) >= 0) {
+        return 'RSASSA-PKCS1-v1_5';
+    }
+    else if ([COSEALG.PS256, COSEALG.PS384, COSEALG.PS512].indexOf(alg) >= 0) {
+        return 'RSA-PSS';
+    }
+    throw new Error(`Could not map COSE alg value of ${alg} to a WebCrypto key alg name`);
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/unwrapEC2Signature.js

@@ -0,0 +1,73 @@
+import { AsnParser } from '@peculiar/asn1-schema';
+import { ECDSASigValue } from '@peculiar/asn1-ecc';
+import { COSECRV } from '../../cose.js';
+import { isoUint8Array } from '../index.js';
+/**
+ * In WebAuthn, EC2 signatures are wrapped in ASN.1 structure so we need to peel r and s apart.
+ *
+ * See https://www.w3.org/TR/webauthn-2/#sctn-signature-attestation-types
+ */
+export function unwrapEC2Signature(signature, crv) {
+    const parsedSignature = AsnParser.parse(signature, ECDSASigValue);
+    const rBytes = new Uint8Array(parsedSignature.r);
+    const sBytes = new Uint8Array(parsedSignature.s);
+    const componentLength = getSignatureComponentLength(crv);
+    const rNormalizedBytes = toNormalizedBytes(rBytes, componentLength);
+    const sNormalizedBytes = toNormalizedBytes(sBytes, componentLength);
+    const finalSignature = isoUint8Array.concat([
+        rNormalizedBytes,
+        sNormalizedBytes,
+    ]);
+    return finalSignature;
+}
+/**
+ * The SubtleCrypto Web Crypto API expects ECDSA signatures with `r` and `s` values to be encoded
+ * to a specific length depending on the order of the curve. This function returns the expected
+ * byte-length for each of the `r` and `s` signature components.
+ *
+ * See <https://www.w3.org/TR/WebCryptoAPI/#ecdsa-operations>
+ */
+function getSignatureComponentLength(crv) {
+    switch (crv) {
+        case COSECRV.P256:
+            return 32;
+        case COSECRV.P384:
+            return 48;
+        case COSECRV.P521:
+            return 66;
+        default:
+            throw new Error(`Unexpected COSE crv value of ${crv} (EC2)`);
+    }
+}
+/**
+ * Converts the ASN.1 integer representation to bytes of a specific length `n`.
+ *
+ * DER encodes integers as big-endian byte arrays, with as small as possible representation and
+ * requires a leading `0` byte to disambiguate between negative and positive numbers. This means
+ * that `r` and `s` can potentially not be the expected byte-length that is needed by the
+ * SubtleCrypto Web Crypto API: if there are leading `0`s it can be shorter than expected, and if
+ * it has a leading `1` bit, it can be one byte longer.
+ *
+ * See <https://www.itu.int/rec/T-REC-X.690-202102-I/en>
+ * See <https://www.w3.org/TR/WebCryptoAPI/#ecdsa-operations>
+ */
+function toNormalizedBytes(bytes, componentLength) {
+    let normalizedBytes;
+    if (bytes.length < componentLength) {
+        // In case the bytes are shorter than expected, we need to pad it with leading `0`s.
+        normalizedBytes = new Uint8Array(componentLength);
+        normalizedBytes.set(bytes, componentLength - bytes.length);
+    }
+    else if (bytes.length === componentLength) {
+        normalizedBytes = bytes;
+    }
+    else if (bytes.length === componentLength + 1 && bytes[0] === 0 && (bytes[1] & 0x80) === 0x80) {
+        // The bytes contain a leading `0` to encode that the integer is positive. This leading `0`
+        // needs to be removed for compatibility with the SubtleCrypto Web Crypto API.
+        normalizedBytes = bytes.subarray(1);
+    }
+    else {
+        throw new Error(`Invalid signature component length ${bytes.length}, expected ${componentLength}`);
+    }
+    return normalizedBytes;
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/verify.js

@@ -0,0 +1,32 @@
+import { COSEKEYS, isCOSECrv, isCOSEPublicKeyEC2, isCOSEPublicKeyOKP, isCOSEPublicKeyRSA, } from '../../cose.js';
+import { verifyEC2 } from './verifyEC2.js';
+import { verifyRSA } from './verifyRSA.js';
+import { verifyOKP } from './verifyOKP.js';
+import { unwrapEC2Signature } from './unwrapEC2Signature.js';
+/**
+ * Verify signatures with their public key. Supports EC2 and RSA public keys.
+ */
+export function verify(opts) {
+    const { cosePublicKey, signature, data, shaHashOverride } = opts;
+    if (isCOSEPublicKeyEC2(cosePublicKey)) {
+        const crv = cosePublicKey.get(COSEKEYS.crv);
+        if (!isCOSECrv(crv)) {
+            throw new Error(`unknown COSE curve ${crv}`);
+        }
+        const unwrappedSignature = unwrapEC2Signature(signature, crv);
+        return verifyEC2({
+            cosePublicKey,
+            signature: unwrappedSignature,
+            data,
+            shaHashOverride,
+        });
+    }
+    else if (isCOSEPublicKeyRSA(cosePublicKey)) {
+        return verifyRSA({ cosePublicKey, signature, data, shaHashOverride });
+    }
+    else if (isCOSEPublicKeyOKP(cosePublicKey)) {
+        return verifyOKP({ cosePublicKey, signature, data });
+    }
+    const kty = cosePublicKey.get(COSEKEYS.kty);
+    throw new Error(`Signature verification with public key of kty ${kty} is not supported by this method`);
+}

package/.output/server/node_modules/@simplewebauthn/server/esm/helpers/iso/isoCrypto/verifyEC2.js

@@ -0,0 +1,73 @@
+import { COSECRV, COSEKEYS } from '../../cose.js';
+import { mapCoseAlgToWebCryptoAlg } from './mapCoseAlgToWebCryptoAlg.js';
+import { importKey } from './importKey.js';
+import { isoBase64URL } from '../index.js';
+import { getWebCrypto } from './getWebCrypto.js';
+/**
+ * Verify a signature using an EC2 public key
+ */
+export async function verifyEC2(opts) {
+    const { cosePublicKey, signature, data, shaHashOverride } = opts;
+    const WebCrypto = await getWebCrypto();
+    // Import the public key
+    const alg = cosePublicKey.get(COSEKEYS.alg);
+    const crv = cosePublicKey.get(COSEKEYS.crv);
+    const x = cosePublicKey.get(COSEKEYS.x);
+    const y = cosePublicKey.get(COSEKEYS.y);
+    if (!alg) {
+        throw new Error('Public key was missing alg (EC2)');
+    }
+    if (!crv) {
+        throw new Error('Public key was missing crv (EC2)');
+    }
+    if (!x) {
+        throw new Error('Public key was missing x (EC2)');
+    }
+    if (!y) {
+        throw new Error('Public key was missing y (EC2)');
+    }
+    let _crv;
+    if (crv === COSECRV.P256) {
+        _crv = 'P-256';
+    }
+    else if (crv === COSECRV.P384) {
+        _crv = 'P-384';
+    }
+    else if (crv === COSECRV.P521) {
+        _crv = 'P-521';
+    }
+    else {
+        throw new Error(`Unexpected COSE crv value of ${crv} (EC2)`);
+    }
+    const keyData = {
+        kty: 'EC',
+        crv: _crv,
+        x: isoBase64URL.fromBuffer(x),
+        y: isoBase64URL.fromBuffer(y),
+        ext: false,
+    };
+    const keyAlgorithm = {
+        /**
+         * Note to future self: you can't use `mapCoseAlgToWebCryptoKeyAlgName()` here because some
+         * leaf certs from actual devices specified an RSA SHA value for `alg` (e.g. `-257`) which
+         * would then map here to `'RSASSA-PKCS1-v1_5'`. We always want `'ECDSA'` here so we'll
+         * hard-code this.
+         */
+        name: 'ECDSA',
+        namedCurve: _crv,
+    };
+    const key = await importKey({
+        keyData,
+        algorithm: keyAlgorithm,
+    });
+    // Determine which SHA algorithm to use for signature verification
+    let subtleAlg = mapCoseAlgToWebCryptoAlg(alg);
+    if (shaHashOverride) {
+        subtleAlg = mapCoseAlgToWebCryptoAlg(shaHashOverride);
+    }
+    const verifyAlgorithm = {
+        name: 'ECDSA',
+        hash: { name: subtleAlg },
+    };
+    return WebCrypto.subtle.verify(verifyAlgorithm, key, signature, data);
+}