@moq-web/cat 0.1.0

package/dist/cwt.d.ts

@@ -0,0 +1,42 @@
+import { type CwtClaims, type MoqtScope, type CborValue } from './types.js';
+/**
+ * Encode CWT claims to a CBOR map (as bytes).
+ */
+export declare function cwtClaimsEncode(claims: CwtClaims): Uint8Array;
+/**
+ * Decode CWT claims from CBOR map bytes.
+ *
+ * @throws {CwtError} If the data is not a valid CWT claims map
+ */
+export declare function cwtClaimsDecode(data: Uint8Array): CwtClaims;
+/**
+ * Convert a decoded CBOR map to CwtClaims.
+ */
+export declare function cwtClaimsFromMap(map: Map<number | string, CborValue>): CwtClaims;
+/**
+ * Encode MoQT scopes to a CBOR array value.
+ * Each scope: [actions_array, namespace_match?, track_match?]
+ */
+export declare function moqtScopesEncode(scopes: MoqtScope[]): CborValue[];
+/**
+ * Decode MoQT scopes from a CBOR array.
+ */
+export declare function moqtScopesDecode(scopesArray: CborValue[]): MoqtScope[];
+/**
+ * Check if CWT claims have expired.
+ */
+export declare function cwtIsExpired(claims: CwtClaims, nowSeconds?: number, clockSkewSeconds?: number): boolean;
+/**
+ * Check if CWT claims are not yet valid (before nbf).
+ */
+export declare function cwtIsNotYetValid(claims: CwtClaims, nowSeconds?: number, clockSkewSeconds?: number): boolean;
+/**
+ * Check if CWT claims match a required audience.
+ */
+export declare function cwtMatchesAudience(claims: CwtClaims, requiredAudience: string): boolean;
+/**
+ * CWT encoding/decoding error.
+ */
+export declare class CwtError extends Error {
+    constructor(message: string);
+}

package/dist/cwt.js

@@ -0,0 +1,261 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+/**
+ * @fileoverview CWT (CBOR Web Token) Claims Implementation (RFC 8392)
+ *
+ * Encodes and decodes CWT claims with integer keys, including
+ * MoQT-specific authorization scopes.
+ */
+import { cborEncode, cborDecode } from './cbor.js';
+import { CwtClaimKey, MoqtAction, } from './types.js';
+/** Standard CWT claim keys that cannot be overridden via additionalClaims */
+const RESERVED_CLAIM_KEYS = new Set([
+    CwtClaimKey.ISS, CwtClaimKey.SUB, CwtClaimKey.AUD,
+    CwtClaimKey.EXP, CwtClaimKey.NBF, CwtClaimKey.IAT,
+    CwtClaimKey.CTI, CwtClaimKey.MOQT, 65000,
+]);
+// ============================================================================
+// CWT Claims Encode / Decode
+// ============================================================================
+/**
+ * Encode CWT claims to a CBOR map (as bytes).
+ */
+export function cwtClaimsEncode(claims) {
+    const map = new Map();
+    if (claims.iss !== undefined)
+        map.set(CwtClaimKey.ISS, claims.iss);
+    if (claims.sub !== undefined)
+        map.set(CwtClaimKey.SUB, claims.sub);
+    if (claims.aud !== undefined) {
+        if (Array.isArray(claims.aud)) {
+            map.set(CwtClaimKey.AUD, claims.aud);
+        }
+        else {
+            map.set(CwtClaimKey.AUD, claims.aud);
+        }
+    }
+    if (claims.exp !== undefined)
+        map.set(CwtClaimKey.EXP, claims.exp);
+    if (claims.nbf !== undefined)
+        map.set(CwtClaimKey.NBF, claims.nbf);
+    if (claims.iat !== undefined)
+        map.set(CwtClaimKey.IAT, claims.iat);
+    if (claims.cti !== undefined)
+        map.set(CwtClaimKey.CTI, claims.cti);
+    if (claims.moqt !== undefined) {
+        map.set(CwtClaimKey.MOQT, moqtScopesEncode(claims.moqt));
+    }
+    // M6: Additional claims — reject collisions with standard claim keys
+    if (claims.additionalClaims) {
+        for (const [key, value] of claims.additionalClaims) {
+            if (RESERVED_CLAIM_KEYS.has(key)) {
+                throw new CwtError(`Additional claim key ${key} conflicts with a reserved CWT claim key`);
+            }
+            map.set(key, value);
+        }
+    }
+    return cborEncode(map);
+}
+/**
+ * Decode CWT claims from CBOR map bytes.
+ *
+ * @throws {CwtError} If the data is not a valid CWT claims map
+ */
+export function cwtClaimsDecode(data) {
+    const decoded = cborDecode(data);
+    if (!(decoded.value instanceof Map)) {
+        throw new CwtError('CWT claims must be a CBOR map');
+    }
+    return cwtClaimsFromMap(decoded.value);
+}
+/**
+ * Convert a decoded CBOR map to CwtClaims.
+ */
+export function cwtClaimsFromMap(map) {
+    const claims = {};
+    const additional = new Map();
+    for (const [key, value] of map) {
+        const numKey = typeof key === 'string' ? parseInt(key, 10) : key;
+        if (isNaN(numKey))
+            continue;
+        switch (numKey) {
+            case CwtClaimKey.ISS:
+                if (typeof value === 'string')
+                    claims.iss = value;
+                break;
+            case CwtClaimKey.SUB:
+                if (typeof value === 'string')
+                    claims.sub = value;
+                break;
+            case CwtClaimKey.AUD:
+                if (typeof value === 'string') {
+                    claims.aud = value;
+                }
+                else if (Array.isArray(value)) {
+                    claims.aud = value.filter((v) => typeof v === 'string');
+                }
+                break;
+            case CwtClaimKey.EXP:
+                // L5: Validate that time claims are integers
+                if (typeof value === 'number') {
+                    if (!Number.isInteger(value)) {
+                        throw new CwtError(`CWT exp claim must be an integer, got ${value}`);
+                    }
+                    claims.exp = value;
+                }
+                break;
+            case CwtClaimKey.NBF:
+                if (typeof value === 'number') {
+                    if (!Number.isInteger(value)) {
+                        throw new CwtError(`CWT nbf claim must be an integer, got ${value}`);
+                    }
+                    claims.nbf = value;
+                }
+                break;
+            case CwtClaimKey.IAT:
+                if (typeof value === 'number') {
+                    if (!Number.isInteger(value)) {
+                        throw new CwtError(`CWT iat claim must be an integer, got ${value}`);
+                    }
+                    claims.iat = value;
+                }
+                break;
+            case CwtClaimKey.CTI:
+                if (value instanceof Uint8Array)
+                    claims.cti = value;
+                break;
+            case CwtClaimKey.MOQT:
+            case 65000: // Legacy MoQT claim key
+                claims.moqt = decodeMoqtScopesValue(value);
+                break;
+            default:
+                additional.set(numKey, value);
+                break;
+        }
+    }
+    if (additional.size > 0) {
+        claims.additionalClaims = additional;
+    }
+    return claims;
+}
+// ============================================================================
+// MoQT Scopes
+// ============================================================================
+/**
+ * Encode MoQT scopes to a CBOR array value.
+ * Each scope: [actions_array, namespace_match?, track_match?]
+ */
+export function moqtScopesEncode(scopes) {
+    return scopes.map((scope) => {
+        const entry = [scope.actions.map((a) => a)];
+        if (scope.namespaceMatch !== undefined) {
+            entry.push(scope.namespaceMatch.map((n) => n instanceof Uint8Array ? n : n));
+        }
+        if (scope.trackMatch !== undefined) {
+            // Ensure namespace is present (even if null) before track
+            if (scope.namespaceMatch === undefined) {
+                entry.push(null);
+            }
+            entry.push(scope.trackMatch instanceof Uint8Array ? scope.trackMatch : scope.trackMatch);
+        }
+        return entry;
+    });
+}
+/**
+ * Decode MoQT scopes from a CBOR value.
+ * Handles both direct CBOR array and bstr-wrapped CBOR.
+ */
+function decodeMoqtScopesValue(value) {
+    let scopesArray;
+    if (value instanceof Uint8Array) {
+        // bstr-wrapped CBOR
+        try {
+            const decoded = cborDecode(value);
+            if (!Array.isArray(decoded.value))
+                return [];
+            scopesArray = decoded.value;
+        }
+        catch {
+            return [];
+        }
+    }
+    else if (Array.isArray(value)) {
+        scopesArray = value;
+    }
+    else {
+        return [];
+    }
+    return moqtScopesDecode(scopesArray);
+}
+/**
+ * Decode MoQT scopes from a CBOR array.
+ */
+export function moqtScopesDecode(scopesArray) {
+    const scopes = [];
+    for (const scopeValue of scopesArray) {
+        if (!Array.isArray(scopeValue) || scopeValue.length === 0)
+            continue;
+        const actionsValue = scopeValue[0];
+        if (!Array.isArray(actionsValue))
+            continue;
+        const actions = actionsValue
+            .filter((a) => typeof a === 'number')
+            .filter((a) => a >= MoqtAction.ClientSetup && a <= MoqtAction.TrackStatus);
+        const scope = { actions };
+        if (scopeValue.length > 1 && scopeValue[1] !== null) {
+            const nsMatch = scopeValue[1];
+            if (Array.isArray(nsMatch)) {
+                // L6: Reject non-string/non-bytes namespace elements instead of coercing
+                scope.namespaceMatch = nsMatch.filter((n) => typeof n === 'string' || n instanceof Uint8Array);
+            }
+        }
+        if (scopeValue.length > 2 && scopeValue[2] !== null) {
+            const trackMatch = scopeValue[2];
+            if (typeof trackMatch === 'string' || trackMatch instanceof Uint8Array) {
+                scope.trackMatch = trackMatch;
+            }
+        }
+        scopes.push(scope);
+    }
+    return scopes;
+}
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+/**
+ * Check if CWT claims have expired.
+ */
+export function cwtIsExpired(claims, nowSeconds, clockSkewSeconds = 60) {
+    if (claims.exp === undefined)
+        return false;
+    const now = nowSeconds ?? Math.floor(Date.now() / 1000);
+    return now > claims.exp + clockSkewSeconds;
+}
+/**
+ * Check if CWT claims are not yet valid (before nbf).
+ */
+export function cwtIsNotYetValid(claims, nowSeconds, clockSkewSeconds = 60) {
+    if (claims.nbf === undefined)
+        return false;
+    const now = nowSeconds ?? Math.floor(Date.now() / 1000);
+    return now < claims.nbf - clockSkewSeconds;
+}
+/**
+ * Check if CWT claims match a required audience.
+ */
+export function cwtMatchesAudience(claims, requiredAudience) {
+    if (claims.aud === undefined)
+        return false;
+    if (typeof claims.aud === 'string')
+        return claims.aud === requiredAudience;
+    return claims.aud.includes(requiredAudience);
+}
+/**
+ * CWT encoding/decoding error.
+ */
+export class CwtError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CwtError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview CAT/C4M Token Library for MoQ Transport
+ *
+ * Common Access Token (CAT) implementation using CBOR, COSE_Sign1, and CWT.
+ * Provides standards-compliant token creation, decoding, and validation
+ * for MoQ Transport authorization.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   CatTokenBuilder,
+ *   CatTokenDecoder,
+ *   CoseAlgorithm,
+ *   MoqtAction,
+ * } from '@moq-web/cat';
+ *
+ * // Create a token
+ * const token = await new CatTokenBuilder()
+ *   .issuer('https://auth.example.com')
+ *   .subject('user-123')
+ *   .audience('moq-relay')
+ *   .expiration(Date.now() / 1000 + 3600)
+ *   .issuedAt()
+ *   .moqtScopes([{
+ *     actions: [MoqtAction.Subscribe],
+ *     namespaceMatch: ['room', 'abc'],
+ *   }])
+ *   .sign(privateKey);
+ *
+ * // Validate a token
+ * const result = await CatTokenDecoder.validate(token, publicKey);
+ * ```
+ */
+export { C4M_TOKEN_TYPE, CoseAlgorithm, CoseHeaderParam, COSE_ALG_PARAMS, CwtClaimKey, MoqtAction, type CborValue, type CborTagged, type CoseSign1, type CwtClaims, type MoqtScope, type CatToken, type CatValidationResult, type CatValidationOptions, type CoseAlgParams, } from './types.js';
+export { cborEncode, cborDecode, cborDecodeTagged, cborEncodeTagged, CborError, } from './cbor.js';
+export { coseSign1Encode, coseSign1Decode, coseSign1Sign, coseSign1Verify, coseSign1SigStructure, coseMac0MacStructure, coseSign1GetAlgorithm, coseSign1DecodeProtectedHeader, CoseError, } from './cose.js';
+export { cwtClaimsEncode, cwtClaimsDecode, cwtClaimsFromMap, moqtScopesEncode, moqtScopesDecode, cwtIsExpired, cwtIsNotYetValid, cwtMatchesAudience, CwtError, } from './cwt.js';
+export { CatTokenBuilder, CatTokenDecoder, base64urlDecode, base64urlEncode, CatError, } from './cat.js';
+export { generateTestKeyPair, generateTestCatToken, catTokenToBase64url, generateWrongScopeToken, generateExpiredToken, generateBadSignatureToken, generateWrongKeyToken, type TestCatTokenOptions, } from './test-utils.js';

package/dist/index.js

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+/**
+ * @fileoverview CAT/C4M Token Library for MoQ Transport
+ *
+ * Common Access Token (CAT) implementation using CBOR, COSE_Sign1, and CWT.
+ * Provides standards-compliant token creation, decoding, and validation
+ * for MoQ Transport authorization.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   CatTokenBuilder,
+ *   CatTokenDecoder,
+ *   CoseAlgorithm,
+ *   MoqtAction,
+ * } from '@moq-web/cat';
+ *
+ * // Create a token
+ * const token = await new CatTokenBuilder()
+ *   .issuer('https://auth.example.com')
+ *   .subject('user-123')
+ *   .audience('moq-relay')
+ *   .expiration(Date.now() / 1000 + 3600)
+ *   .issuedAt()
+ *   .moqtScopes([{
+ *     actions: [MoqtAction.Subscribe],
+ *     namespaceMatch: ['room', 'abc'],
+ *   }])
+ *   .sign(privateKey);
+ *
+ * // Validate a token
+ * const result = await CatTokenDecoder.validate(token, publicKey);
+ * ```
+ */
+// Types
+export { C4M_TOKEN_TYPE, CoseAlgorithm, CoseHeaderParam, COSE_ALG_PARAMS, CwtClaimKey, MoqtAction, } from './types.js';
+// CBOR
+export { cborEncode, cborDecode, cborDecodeTagged, cborEncodeTagged, CborError, } from './cbor.js';
+// COSE
+export { coseSign1Encode, coseSign1Decode, coseSign1Sign, coseSign1Verify, coseSign1SigStructure, coseMac0MacStructure, coseSign1GetAlgorithm, coseSign1DecodeProtectedHeader, CoseError, } from './cose.js';
+// CWT
+export { cwtClaimsEncode, cwtClaimsDecode, cwtClaimsFromMap, moqtScopesEncode, moqtScopesDecode, cwtIsExpired, cwtIsNotYetValid, cwtMatchesAudience, CwtError, } from './cwt.js';
+// CAT
+export { CatTokenBuilder, CatTokenDecoder, base64urlDecode, base64urlEncode, CatError, } from './cat.js';
+// Test utilities
+export { generateTestKeyPair, generateTestCatToken, catTokenToBase64url, generateWrongScopeToken, generateExpiredToken, generateBadSignatureToken, generateWrongKeyToken, } from './test-utils.js';

package/dist/test-utils.d.ts

@@ -0,0 +1,71 @@
+import { CoseAlgorithm, type CwtClaims, type MoqtScope } from './types.js';
+/**
+ * Generate a test ECDSA key pair for CAT token signing/verification.
+ *
+ * WARNING: Keys are extractable by default for testing convenience.
+ * Do NOT use this function for production key generation — use
+ * crypto.subtle.generateKey directly with extractable=false.
+ *
+ * @param algorithm - COSE algorithm (default: ES256)
+ * @param extractable - Whether the private key is extractable (default: true for testing)
+ * @returns WebCrypto key pair
+ */
+export declare function generateTestKeyPair(algorithm?: CoseAlgorithm, extractable?: boolean): Promise<CryptoKeyPair>;
+export interface TestCatTokenOptions {
+    /** Signing key pair (will generate if not provided) */
+    keyPair?: CryptoKeyPair;
+    /** Partial claims to set */
+    claims?: Partial<CwtClaims>;
+    /** MoQT scopes */
+    scopes?: MoqtScope[];
+    /** Signing algorithm (default: ES256) */
+    algorithm?: CoseAlgorithm;
+    /** Generate an expired token */
+    expired?: boolean;
+    /** Token lifetime in seconds (default: 3600) */
+    lifetimeSeconds?: number;
+}
+/**
+ * Generate a properly-formatted test CAT token (CWT/COSE_Sign1).
+ * Unlike JWT fake tokens, these use proper CBOR encoding and ECDSA signatures.
+ *
+ * @returns COSE_Sign1 CBOR bytes
+ */
+export declare function generateTestCatToken(options?: TestCatTokenOptions): Promise<{
+    tokenBytes: Uint8Array;
+    keyPair: CryptoKeyPair;
+}>;
+/**
+ * Encode CAT token bytes to base64url string for session.setAuthToken().
+ */
+export declare function catTokenToBase64url(tokenBytes: Uint8Array): string;
+/**
+ * Generate an invalid CAT token with a wrong namespace scope.
+ */
+export declare function generateWrongScopeToken(_roomId: string, keyPair?: CryptoKeyPair): Promise<{
+    tokenBytes: Uint8Array;
+    keyPair: CryptoKeyPair;
+}>;
+/**
+ * Generate an expired CAT token.
+ */
+export declare function generateExpiredToken(keyPair?: CryptoKeyPair): Promise<{
+    tokenBytes: Uint8Array;
+    keyPair: CryptoKeyPair;
+}>;
+/**
+ * Generate a CAT token with a corrupted signature.
+ */
+export declare function generateBadSignatureToken(keyPair?: CryptoKeyPair): Promise<{
+    tokenBytes: Uint8Array;
+    keyPair: CryptoKeyPair;
+}>;
+/**
+ * Generate a CAT token signed with a different key (signature won't verify
+ * against the original key pair).
+ */
+export declare function generateWrongKeyToken(algorithm?: CoseAlgorithm): Promise<{
+    tokenBytes: Uint8Array;
+    signingKeyPair: CryptoKeyPair;
+    verifyKeyPair: CryptoKeyPair;
+}>;

package/dist/test-utils.js

@@ -0,0 +1,136 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+/**
+ * @fileoverview CAT Token Test Utilities
+ *
+ * Helpers for generating test key pairs and properly-formatted
+ * CAT (CWT/COSE) tokens for testing and demos.
+ */
+import { CatTokenBuilder, base64urlEncode } from './cat.js';
+import { coseSign1Encode, coseSign1Decode } from './cose.js';
+import { CoseAlgorithm, COSE_ALG_PARAMS, MoqtAction, } from './types.js';
+// ============================================================================
+// Key Generation
+// ============================================================================
+/**
+ * Generate a test ECDSA key pair for CAT token signing/verification.
+ *
+ * WARNING: Keys are extractable by default for testing convenience.
+ * Do NOT use this function for production key generation — use
+ * crypto.subtle.generateKey directly with extractable=false.
+ *
+ * @param algorithm - COSE algorithm (default: ES256)
+ * @param extractable - Whether the private key is extractable (default: true for testing)
+ * @returns WebCrypto key pair
+ */
+export async function generateTestKeyPair(algorithm = CoseAlgorithm.ES256, extractable = true) {
+    const params = COSE_ALG_PARAMS[algorithm];
+    if (params.isMac) {
+        // HMAC key generation
+        const key = await crypto.subtle.generateKey({ name: 'HMAC', hash: params.hash }, extractable, ['sign', 'verify']);
+        // Return same key for both sign and verify (symmetric)
+        return { privateKey: key, publicKey: key };
+    }
+    return crypto.subtle.generateKey({ name: params.name, namedCurve: params.namedCurve }, extractable, ['sign', 'verify']);
+}
+/**
+ * Generate a properly-formatted test CAT token (CWT/COSE_Sign1).
+ * Unlike JWT fake tokens, these use proper CBOR encoding and ECDSA signatures.
+ *
+ * @returns COSE_Sign1 CBOR bytes
+ */
+export async function generateTestCatToken(options = {}) {
+    const algorithm = options.algorithm ?? CoseAlgorithm.ES256;
+    const keyPair = options.keyPair ?? await generateTestKeyPair(algorithm);
+    const now = Math.floor(Date.now() / 1000);
+    const lifetime = options.lifetimeSeconds ?? 3600;
+    const builder = new CatTokenBuilder().withAlgorithm(algorithm);
+    // Set default claims
+    builder
+        .issuer(options.claims?.iss ?? 'https://test.moq.example')
+        .subject(options.claims?.sub ?? 'test-user')
+        .audience(options.claims?.aud ?? 'moq-relay');
+    if (options.expired) {
+        builder.issuedAt(now - lifetime * 2);
+        builder.expiration(now - lifetime);
+    }
+    else {
+        builder.issuedAt(options.claims?.iat ?? now);
+        builder.expiration(options.claims?.exp ?? now + lifetime);
+    }
+    if (options.claims?.nbf !== undefined) {
+        builder.notBefore(options.claims.nbf);
+    }
+    if (options.claims?.cti) {
+        builder.cwtId(options.claims.cti);
+    }
+    // Set scopes
+    const scopes = options.scopes ?? [{
+            actions: [MoqtAction.Subscribe, MoqtAction.Publish, MoqtAction.SubscribeNamespace, MoqtAction.PublishNamespace],
+        }];
+    builder.moqtScopes(scopes);
+    const tokenBytes = await builder.sign(keyPair.privateKey);
+    return { tokenBytes, keyPair };
+}
+/**
+ * Encode CAT token bytes to base64url string for session.setAuthToken().
+ */
+export function catTokenToBase64url(tokenBytes) {
+    return base64urlEncode(tokenBytes);
+}
+// ============================================================================
+// Invalid Token Generators (for denial testing)
+// ============================================================================
+/**
+ * Generate an invalid CAT token with a wrong namespace scope.
+ */
+export async function generateWrongScopeToken(_roomId, keyPair) {
+    const kp = keyPair ?? await generateTestKeyPair();
+    return generateTestCatToken({
+        keyPair: kp,
+        scopes: [{
+                actions: [MoqtAction.Subscribe],
+                namespaceMatch: ['mocha', `WRONG-ROOM-${Date.now().toString(36)}`],
+            }],
+        claims: { sub: 'wrong-scope-user' },
+    });
+}
+/**
+ * Generate an expired CAT token.
+ */
+export async function generateExpiredToken(keyPair) {
+    const kp = keyPair ?? await generateTestKeyPair();
+    return generateTestCatToken({
+        keyPair: kp,
+        expired: true,
+        claims: { sub: 'expired-user' },
+    });
+}
+/**
+ * Generate a CAT token with a corrupted signature.
+ */
+export async function generateBadSignatureToken(keyPair) {
+    const kp = keyPair ?? await generateTestKeyPair();
+    const { tokenBytes } = await generateTestCatToken({ keyPair: kp });
+    // Decode, corrupt signature, re-encode
+    const sign1 = coseSign1Decode(tokenBytes);
+    const corrupted = {
+        ...sign1,
+        signature: new Uint8Array(sign1.signature.length),
+    };
+    crypto.getRandomValues(corrupted.signature);
+    return { tokenBytes: coseSign1Encode(corrupted), keyPair: kp };
+}
+/**
+ * Generate a CAT token signed with a different key (signature won't verify
+ * against the original key pair).
+ */
+export async function generateWrongKeyToken(algorithm = CoseAlgorithm.ES256) {
+    const signingKeyPair = await generateTestKeyPair(algorithm);
+    const verifyKeyPair = await generateTestKeyPair(algorithm);
+    const { tokenBytes } = await generateTestCatToken({
+        keyPair: signingKeyPair,
+        claims: { sub: 'wrong-key-user' },
+    });
+    return { tokenBytes, signingKeyPair, verifyKeyPair };
+}