Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
fix(control-api): remove committed dev JWT keys and ban them by fingerprint
Alfredo Lopez5faad2316bd9
diff --git a/.dockerignore b/.dockerignoreindex 6b8f22d12..c44497a69 100644--- a/.dockerignore+++ b/.dockerignore@@ -24,6 +24,8 @@**/*.pem**/*.keykubeconfig*+# Local-only JWT signing keys generated in dev mode; never enter the image.+control-api/.dev-keys/**/node_modules**/dist**/.nextdiff --git a/.gitignore b/.gitignoreindex 28c2911e7..d76880fa0 100644--- a/.gitignore+++ b/.gitignore@@ -145,3 +145,7 @@ dist-public/# Rendered from patches/k8s-api-ip.yaml.template at setup time — the IP is# machine-specific, so the rendered file must never be tracked.deploy/overlays/minikube/patches/k8s-api-ip.yaml++# Local-only JWT signing keys generated by control-api in CLERUM_DEV_MODE.+# Never tracked; deleting the directory only invalidates local dev tokens.+control-api/.dev-keys/diff --git a/.gitleaks.toml b/.gitleaks.tomlindex 61cc7a6f5..9406cbf65 100644--- a/.gitleaks.toml+++ b/.gitleaks.toml@@ -30,10 +30,6 @@ paths = ['''(^|/)e2e/''','''(^|/)fixtures?/''','''(^|/)examples?/''',- # Documented CLERUM_DEV_MODE fallback JWT keys (DEV_*_JWT_PRIVATE_KEY) and the- # production boot-guard that fingerprints them to REFUSE dev keys in prod.- # Throwaway keys, not real secrets. See the file for the guard.- '''^control-api/src/config\.ts$''',# `export const deriveOAuthEncryptionKey = deriveAes256GcmKey` — a function# alias the generic-api-key entropy heuristic mis-reads as a secret.'''^control-api/src/oauth/encryption\.ts$''',diff --git a/control-api/README.md b/control-api/README.mdindex 5ee08826f..875559430 100644--- a/control-api/README.md+++ b/control-api/README.md@@ -169,6 +169,14 @@ Resource/namespace controls:Auth settings:- `CONTROL_API_SESSION_JWT_PRIVATE_KEY`: RSA private key used to sign external REST API session JWTs (`/external/auth/*`) with RS256.++Local development: run with `CLERUM_DEV_MODE=true` and no signing-key env vars.+Control API generates one RSA-2048 key per slot under the gitignored+`control-api/.dev-keys/` directory (`0700` directory, `0600` files) on first+use and reuses it across restarts. Outside dev mode the three env vars above+are always required, and keys whose public halves were ever committed to this+repository are rejected in every slot, including the RPC verifier public key.+- `CONTROL_API_RPC_JWT_PRIVATE_KEY`: RSA private key used to sign RPC access JWTs for `rpc-proxy` (RS256).- `CONTROL_API_JWT_ISSUER`: expected `iss` for session token signing and verification.- `CONTROL_API_JWT_AUDIENCE`: expected `aud` for session token signing and verification.diff --git a/control-api/src/bannedDevSigningKeys.ts b/control-api/src/bannedDevSigningKeys.tsnew file mode 100644index 000000000..7e5cc27f5--- /dev/null+++ b/control-api/src/bannedDevSigningKeys.ts@@ -0,0 +1,135 @@+import { type KeyObject, createHash, createPrivateKey, createPublicKey } from 'node:crypto'++/**+ * SHA-256 fingerprints over the public SPKI DER halves of the three RSA keys+ * that were once committed to this repository as dev JWT signing defaults.+ * The private keys were removed; these fingerprints permanently ban them from+ * every signing and verifying slot. Fingerprints of public keys are not+ * secrets and carry no signing material.+ */+export const BANNED_DEV_JWT_PUBLIC_KEY_FINGERPRINTS: ReadonlySet<string> = new Set([+ // Committed dev RPC JWT key (removed from src/config.ts).+ '4292d721765a93b0275f9f4ceb0a4667517fae00b5face8faa270513d610bb27',+ // Committed dev session JWT key (removed from src/config.ts).+ 'f7dc08c248bf2b7724dead80dd96f9a5eeb49cf9920ba6fb46cf457a788d503e',+ // Committed dev admin JWT key (removed from src/config.ts).+ '2d05f607d125e4bd3c157d5c6115bf63cb454c1e45cc5bcc8eed950771dcfd31',+])++function spkiDerFingerprint(key: KeyObject | string): string {+ const keyObject = typeof key === 'string' ? createPublicKey(key) : key+ const der = keyObject.export({ type: 'spki', format: 'der' })+ return createHash('sha256').update(der).digest('hex')+}++export function publicKeyPemFingerprint(publicKeyPem: string): string {+ return spkiDerFingerprint(publicKeyPem)+}++export function isBannedPublicKeyPem(+ publicKeyPem: string,+ fingerprints: ReadonlySet<string> = BANNED_DEV_JWT_PUBLIC_KEY_FINGERPRINTS+): boolean {+ try {+ return fingerprints.has(publicKeyPemFingerprint(publicKeyPem))+ } catch {+ return false+ }+}++export function isBannedSigningKeyPem(+ privateKeyPem: string,+ fingerprints: ReadonlySet<string> = BANNED_DEV_JWT_PUBLIC_KEY_FINGERPRINTS+): boolean {+ try {+ return fingerprints.has(spkiDerFingerprint(createPublicKey(privateKeyPem)))+ } catch {+ return false+ }+}++/**+ * Strict validation for configured signing keys: must parse as a PEM private+ * key, be RSA, and have at least a 2048-bit modulus so RS256 is safe to use.+ * Parse failures produce an error naming the environment variable; the PEM+ * itself is never included in the message.+ */+export function validateRsaPrivateKeyPem(privateKeyPem: string, envName: string): string {+ let key: KeyObject+ try {+ key = createPrivateKey(privateKeyPem)+ } catch {+ throw new Error(+ `${envName} must be a PEM-encoded RSA private key (PKCS#8 or PKCS#1); parsing failed. ` ++ 'Public-key PEMs, truncated bodies, and escaped line breaks are rejected.'+ )+ }+ if (key.asymmetricKeyType !== 'rsa') {+ throw new Error(+ `${envName} must be an RSA key for RS256 signing (got '${key.asymmetricKeyType}')`+ )+ }+ const jwk = key.export({ format: 'jwk' }) as { n?: string }+ if (typeof jwk.n !== 'string') {+ throw new Error(`${envName} could not be inspected as a JWK; refusing to use it for RS256`)+ }+ const modulusBytes = Buffer.from(jwk.n, 'base64url')+ let firstNonZero = 0+ while (firstNonZero < modulusBytes.length && modulusBytes[firstNonZero] === 0) firstNonZero+++ const modulusBits =+ modulusBytes.length === firstNonZero+ ? 0+ : (modulusBytes.length - firstNonZero - 1) * 8 ++ Math.ceil(Math.log2(modulusBytes[firstNonZero] + 1))+ if (modulusBits < 2048) {+ throw new Error(`${envName} RSA modulus must be at least 2048 bits (got ${modulusBits})`)+ }+ return privateKeyPem+}++export function assertNoBannedJwtKeys(+ input: {+ rpcPrivateKey: string+ sessionPrivateKey: string+ adminPrivateKey: string+ voucherPrivateKey?: string+ rpcPublicKey: string+ rpcPublicKeyEnvSet: boolean+ },+ fingerprints: ReadonlySet<string> = BANNED_DEV_JWT_PUBLIC_KEY_FINGERPRINTS+): void {+ const slots: Array<[envName: string, pem: string]> = [+ ['CONTROL_API_RPC_JWT_PRIVATE_KEY', input.rpcPrivateKey],+ ['CONTROL_API_SESSION_JWT_PRIVATE_KEY', input.sessionPrivateKey],+ ['CONTROL_API_ADMIN_JWT_PRIVATE_KEY', input.adminPrivateKey],+ ]+ if (input.voucherPrivateKey) {+ slots.push(['CONTROL_API_REGISTRY_VOUCHER_PRIVATE_KEY', input.voucherPrivateKey])+ }+ for (const [envName, pem] of slots) {+ if (isBannedSigningKeyPem(pem, fingerprints)) {+ throw new Error(+ `[SECURITY] Startup rejected: ${envName} resolves to a historically committed dev JWT key. ` ++ 'Replace it with a deployment-specific RSA key.'+ )+ }+ }+ if (isBannedPublicKeyPem(input.rpcPublicKey, fingerprints)) {+ throw new Error(+ '[SECURITY] Startup rejected: the effective RPC JWT verifier public key is a historically ' ++ 'committed dev JWT key. Set CONTROL_API_RPC_JWT_PUBLIC_KEY to the public half of the ' ++ 'configured private key.'+ )+ }+ if (input.rpcPublicKeyEnvSet) {+ const derived = createPublicKey(input.rpcPrivateKey)+ .export({ type: 'spki', format: 'pem' })+ .toString()+ .trim()+ if (derived !== input.rpcPublicKey.trim()) {+ throw new Error(+ 'CONTROL_API_RPC_JWT_PUBLIC_KEY must correspond to CONTROL_API_RPC_JWT_PRIVATE_KEY'+ )+ }+ }+}diff --git a/control-api/src/config.ts b/control-api/src/config.tsindex 1c713947d..96745fcd1 100644--- a/control-api/src/config.ts+++ b/control-api/src/config.ts@@ -1,5 +1,7 @@import { createPublicKey } from 'node:crypto'import { DEFAULT_ALLOWED_PLUGIN_IMAGE_PREFIXES } from '@clerum/image-policy'+import { assertNoBannedJwtKeys, validateRsaPrivateKeyPem } from './bannedDevSigningKeys.js'+import { type DevJwtSlot, loadOrGenerateDevJwtPrivateKey } from './devSigningKeys.js'import { REACTIVE_REFRESH_BUFFER_MS } from './oauth/tokenHelper.js'type Config = {@@ -561,103 +563,35 @@ function failClosedBooleanFromEnv(name: string): boolean {throw new Error(`${name} must be 'true' or 'false' (got '${raw}')`)}-function publicKeyFromPrivateKey(privateKey: string): string {- return createPublicKey(privateKey).export({ type: 'spki', format: 'pem' }).toString()+const CLERUM_DEV_MODE_ENABLED = process.env.CLERUM_DEV_MODE === 'true'+if (process.env.NODE_ENV === 'production' && CLERUM_DEV_MODE_ENABLED) {+ throw new Error(+ '[SECURITY] Startup rejected: CLERUM_DEV_MODE=true is not allowed with NODE_ENV=production. ' ++ 'Provide deployment-specific JWT signing keys and unset CLERUM_DEV_MODE.'+ )}-const DEV_RPC_JWT_PRIVATE_KEY = normalizePem(`-----BEGIN PRIVATE KEY------MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCsIhgYd6Ew+kYp-4/FopBqsNfnKvOJ9TmLh/OkjcS2QpJTqzm6DsSQrFzYN0x6Sipd72+vuorJXCKKV-Qi6xcteJbso8wmUP8V3kGjtDG3r3BiIvkjgrft4OAI3oPct24fJISeSF0jQYOkHg-szYBI7FCQRpt6l6RlMxDITGYIif90cnXkH7gD22KJ6mFg5A2vcZydb14OiYy3o0k-vKmKRuvEk7o7sCvQb6tpNt+W2HwRDNacYX5aBBbiKIzfCwWGloTSZSURswYMZMwB-nLUp/EBFG75Bmbcuj7kCIJoeSKMMKCUexcuGqxiLYB1GJq8PUaT0so//O0rDur8P-p9gXOY5DAgMBAAECggEAVAGPoOFBWZXLCEamWls8aS8uaTMlleHbgE7duN5TTnQD-+VQluz+IVz9MshKGqR3aMCh0TFI6lx8vuYhDIXbamcfoCx8UE2PIXroukeGncUcd-B/pkT1XrKQo8N0txMOO0SnNFg8nCgtBrti2//W5d4+fB7kKjRIlJ5rkcaxLAUa5z-fpvaz+DhwBvvIi5zakhUBGVinVnQV6cKS5c52ccYikSNG9ysGBParCbVsQCwgLan-JhWCmRYuPj5MoaELcZ7lBO2ow+SO/VSTW03fnC/cIYCxZqAEEnq3fg5/FFsy6xsB-CbwQQaGnUrrw/LyGX3vyW7eXDL4hOYLp+l+tZklqAQKBgQDe8I4RegQ7lGvVnEoo-xTBdZg6kgjSRRBMs67/E+HrnnHC8gMjT2MlJguYQEonFP8teDoj0l7+1Bj/LRyHv-CyZr03EpevMQut27VdEO/qWYaGpOsXC2xkuiJWeKYvp3//lcIofXy9VhStlsisk6-yx1LAY6iiZvptaCzJmYTU677swKBgQDFqMaLyLAAIpMcBrLDlGt8qyB6ZVaJZTHP-vs13Md6RJPVXXyGtWRtpMwOSwHJNyy3xN23rWtlj32UE9KW/47oxjbkXfpExG/fi-UBeA80AtjM57q66+LZ9Rs5EAFcOsNrd11XY4Y/37/MMbWQgjfW44uEeB2drx9mB0-LU9H+1KbMQKBgFKij8Zil9cNuLrA56wdC0RTY/IOYTXHKeRorfhwsf3PuunkQoxj-upiI8IXcmTyH3PXMJW+kH+cVnefXQfi9BUzKXxOlAxucaDvcH1WThgXsDhuFIeZd-sgM0IiDldzmro95G3ltarokVmWnmN5iXWRBIT3pnz2bdb+d3wDZBuoaJAoGABCl9-pMvhCN+xgVGSyhOB/+oKkQk5PUNoPRujb/MY4K2KjQBv0RqjPR/Z32k1/vVcTkwA-gIg1M6ksk2Ija1r8PLbjQt9jZ0lTeux80jZND6h7YJdI4rBLPoktcHcE28d7LXwF-NULFwlycLyM8zKKDg6Y9uzo/JgEuHsQlezqLjsECgYAboHrpwXg/SBatigtBvj0E-1ccXGGLgN2dhDbAlZoSKDITOxGiOw48bOX1lT25c06muru+2mCNrsN2lMs07VGk8-PSRsIuFZis/4vrRtjoxUB4OQ29+mfVgqGsABPugCmi/r22gWrvl1aqEEqstg3m7x-sKRpFxViv5P5TmnxLggnhw==------END PRIVATE KEY-----`)+const JWT_SIGNING_KEY_ENV_NAMES: Record<DevJwtSlot, string> = {+ rpc: 'CONTROL_API_RPC_JWT_PRIVATE_KEY',+ session: 'CONTROL_API_SESSION_JWT_PRIVATE_KEY',+ admin: 'CONTROL_API_ADMIN_JWT_PRIVATE_KEY',+}-const DEV_SESSION_JWT_PRIVATE_KEY = normalizePem(`-----BEGIN PRIVATE KEY------MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDCtmNr2NL+v57Z-gXUWoRA0wuyd995tjNetk5vu48wqFcGgqMmH+1pH2/eRfayt9W2iKRwoqvRJ9rsw-xIudlZ0ROaLsy9t5UPcemxelV6ObD0PTN5hhIZmmUsX9vodjQvPZdUzxZ0mXcOJz-K75JltnF4dm0wIxNOO+agj8hiaY7g3c+DP9IaLtXcSLCgAs4M/g5YO93/XEVSIw+-yUs+BlQRzNDm0ikBoPh7SibeBQ2zI4phzmKCiObqihWoj1PdNQYFUnS5JkHue1bE-pDf1bIhof6iqfAMZsNwMtD/BO4G1yfhutZMOBbXEDvcdUFIiYYW+8cJYGJAGIjWe-+i9Q/S5ZAgMBAAECggEABTd9g63SHl7sLrvqEw6C6IT58bQKxrDdtPH13TFHfq+p-SciH6L+mYDM/p2tgcWM4Wh5Dmb/VzncAtipn6rOP2x6qE7HVCiOuEUj6udR2ptCC-gtHUIHMV4qfIU/dzOWi5b4+13Whk53yv5oHLJf3XjRaTXoVDpQyD1+YKMrf1RxYf-QIiI6ChaDmPmZ8mJF56vZLz1S98HBvtMlTtI+IYhhkxScSq77enb44NLZ0FInXtr-UJ0WiJ1JYUZdESauiXFH/fTKyXF7vp5ZAIThG+hGaJ987HV8DXL0S0gmFRkw2Wj2-44IKEC+VH60GTIysQ2HmbKExAYwngZBBCNTgoawWgQKBgQDwLLqmCVPgxZ2dkxi3-5RlLZfhPRANQzj4GyE2oQtRwthGn30QJ3tc26WIjDt7a2vRUGiHOEONeDcJQg726-JeBgUMDCuwA9QkdyDZhupF9Erl9f6C515k7Y2il7JX0sA1MmV5Phgh2XH+rUq6Li-A7EFS5P1mT/J7XU842NdD+xUgQKBgQDPis0QJ/1eHY9j6pQC6d8riLEG3lRHiCVt-94gp8YoNI6iJRl4fVUO1A4JxjNIz04g7ZXLusuFUgznXnxGv2+pju//vvVbQeyD6-HKDvfd1Xt0xTe5Y/X5g2l7b7dvHc9o9YAhxqkMmxuusdF+z++VLWbf3T7XXAiufS-k4thtd8N2QKBgQCnCMSqsvQF8AolS+c2BfxohruCDTAtI7LZrrbrncb3uHhhAxLj-tnqA8yFQdoghN4QTdbUrBm3KvND2hBkQfEUnVyIojDunXxAnTzNDR8gGESu9nNGr-J4iQonGU9sauNIXAtcngXUjNEOKWE+SNQbn8j8qQVYuamS4fMZmqYGehgQKBgHng-kufH9BxO06PjX6QOX0YbcYoNCgUvyHs5f7bR5zYsGI70ydUwpyAnvXSdM9vHfxsS-SloupfCRV2huO17AkHadMoFA+ThY9laqdT/u9ArM03+69dKleqeklIo7oXEXQbp3-EuTpvegnUma1ZDGfjKvrz8GikyHM8LJSfumUejaRAoGBALaksx+nAwBqSehPEsU3-84xsDCj0jiJy5SVlKAnyVKM4bjI8pgCHY2dD9jqCYEfRKIMB6jKZDS7ZE1n1IeIC-aI29j2LQbxz6hwRqZisBaGgOg5GaL74Hjodh2OwWl5fGFdKXFFPSsJAYeK6sOxgB-VUxHFu+yhYVbZ5uhL8whXgrI------END PRIVATE KEY-----`)+function resolveControlApiJwtPrivateKey(slot: DevJwtSlot): string {+ const envName = JWT_SIGNING_KEY_ENV_NAMES[slot]+ const fromEnv = process.env[envName]+ if (fromEnv) return validateRsaPrivateKeyPem(normalizePem(fromEnv), envName)+ if (CLERUM_DEV_MODE_ENABLED) return loadOrGenerateDevJwtPrivateKey(slot)+ return required(envName)+}-// Use a different dev key for admin JWT to prevent token confusion-const DEV_ADMIN_JWT_PRIVATE_KEY = normalizePem(`-----BEGIN PRIVATE KEY------MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCysO8JjPH3o4s7-aq/fuxtlm8K6C7NH5xbHA5inHrUA/4Yv2XFXrQUkkkqO1GE78i+bqSg7OBXKWfXY-GmGKkHScmz190vMCunF6K4pqWKCuQv1z/ZPCWOZGllqBnNkooBBHzbtvRZHP2oHr-eeluMy//svUY3Fwy0ud7atMBhTeB7PQjumHAoBgf/Nj5PmIfaXSqm3/gjLq3ulY5-DSqCsp4k8V7mphYrdzwFYadYmSGgsI1QJOdRrXIZoge5HArPA8f1vjvqtLvY0aoY-LjFFlcB6Kc50jPc/Kaks3QfIiNKw8FSWF7AgvAPmNAELoPFh5ctAljRQdZEus6pB-GQmx6nrJAgMBAAECggEAC+MGgbqDKaOy2kTgdngATG/yQhVPa63xF1PTSrG5nXuC-CgqTVj9jn1FOfaYd4kKb/WVBMIBMfcmid6nYmYK+ySCwFF/NK94qeJOvKWAkLzd0-XAwPMV9f0SwFEQh1rzTHpHkoefBVMPAikp8pYrvrul0lng3hob1jKfP7Haemn8E+-mlOLlGkW3mbyAi65bOPTdaqx+uGj5q8ZY1Bz84e23xIWV0bTTsqWJ7/JBc9wG5/9-JA2tWs4QuYhs+14n+TLpnniYUolMUyxPeoaJV81cU1UTNSUbBTZ5ndXAWoenv9Gv-PaR7awUwTPq/qV2+ZgEoPwa9omQQNmk0ACdTNDfSsQKBgQDmtAuBJTrhoXpcPOQV-Qz7rr1fWFvFS729AuWDNhPWaC6/Q2mkwEVB2jMCn7tZhx0M8HEO2xduDlThi0pbu-35shxeYTwQno+SFeCG8l/AmmKp/nJpO8d7PKEwLB8IBm8WYCqIQ4gPWc958enR4Y-2Nve0HtVlnvSSAqeZ58f8gNiEQKBgQDGSOHQ0jN/LRjchCw6QOifZgYm7nCafZuj-G9BBXTVZBXZZlODfDH9tkZaywywuBw/cw7Rcn9k2GWoxm3WjYgQjMB45BcZIpaZo-kLmr6ZQUzxm3JAdT2U3v0XNTD8A8oFsvlEr6/Uno/uNqQq6EufMls6gPzUaVO56Q-AFwKO/pVOQKBgQCw96tbhZOFQLj7yDmtlcfOQtK+BxtW4xQUMh9vh25enFhhfSjz-FlUCmzWtnCgXGSMaGRRYP64DYZO/OotM8Xmujn/O52USsQhHeXDJUmyUal3+kjkB-eVEQ0URsQHA+hy4ZG+tQ7Jt7rPcCJMPRi4gdgw8YuDaDN3/tws7tUlgGAQKBgBY+-Zta+PfiuXnOegDeowG/hSh9j8E3keWk63Yn3otxxuG0kPnXHOSRZiMZVDse7ExR4-/+rEI+Hlx/v4rKG/hSdNZpaPB0dvDdP9KFcYxPvwn7nj2M6XOh8FKCLRSYeDlbco-s6CkeX4h2fE5uco58gTwupHLPXfQUGFnKOwc/mBBAoGAZOC3cOzdROA6t12hlXBG-nFoBPwztGGlol4VRjNHOUv21999k1s9vujmfdoEbtCT8UWR735Cmahv6Dlqhgmfz-udFCb0WGbuF+RYuIoF3rm2aQMZoCCl5E4QlgJroKBTkfFugxZJ+1SLZJ4KKRcMrB-gg1uS2CBS2kyMhFQcB5FLFw=------END PRIVATE KEY-----`)+function publicKeyFromPrivateKey(privateKey: string): string {+ return createPublicKey(privateKey).export({ type: 'spki', format: 'pem' }).toString()+}const DEV_ADMIN_PASSWORD_HASH = '$2b$12$9QdfGGp5KYg8osGa1n0.DuwQiB1RopCWIDJhmsuK4ygjTmIT8pvgy'-const RPC_JWT_PRIVATE_KEY = normalizePem(- requiredOrDevDefault('CONTROL_API_RPC_JWT_PRIVATE_KEY', DEV_RPC_JWT_PRIVATE_KEY)-)+const RPC_JWT_PRIVATE_KEY = resolveControlApiJwtPrivateKey('rpc')const RPC_JWT_PUBLIC_KEY = normalizePem(process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY || publicKeyFromPrivateKey(RPC_JWT_PRIVATE_KEY))@@ -821,9 +755,7 @@ export const config: Config = {),controlUiBaseUrl: process.env.CONTROL_API_CONTROL_UI_BASE_URL || 'http://127.0.0.1:3000',controlUiAppName: process.env.CONTROL_API_CONTROL_UI_APP_NAME || 'Evenfire',- sessionJwtPrivateKey: normalizePem(- requiredOrDevDefault('CONTROL_API_SESSION_JWT_PRIVATE_KEY', DEV_SESSION_JWT_PRIVATE_KEY)- ),+ sessionJwtPrivateKey: resolveControlApiJwtPrivateKey('session'),jwtIssuer: requiredOrDevDefault('CONTROL_API_JWT_ISSUER', 'control-api'),jwtAudience: requiredOrDevDefault('CONTROL_API_JWT_AUDIENCE', 'profile-ui'),rpcJwtPrivateKey: RPC_JWT_PRIVATE_KEY,@@ -835,9 +767,7 @@ export const config: Config = {hostSecretLabelValue: process.env.CONTROL_API_HOST_SECRET_LABEL_VALUE || 'true',policyAuthAudience: process.env.CONTROL_API_POLICY_AUTH_AUDIENCE || 'control-api',googleClientId: requiredOrDevDefault('CONTROL_API_GOOGLE_CLIENT_ID', 'dev-google-client-id'),- adminJwtPrivateKey: normalizePem(- requiredOrDevDefault('CONTROL_API_ADMIN_JWT_PRIVATE_KEY', DEV_ADMIN_JWT_PRIVATE_KEY)- ),+ adminJwtPrivateKey: resolveControlApiJwtPrivateKey('admin'),adminJwtIssuer: requiredOrDevDefault('CONTROL_API_ADMIN_JWT_ISSUER', 'control-api'),adminJwtAudience: requiredOrDevDefault('CONTROL_API_ADMIN_JWT_AUDIENCE', 'control-ui'),adminJwtTtlSeconds: Number(process.env.CONTROL_API_ADMIN_JWT_TTL_SECONDS || 60 * 60),@@ -1503,29 +1433,26 @@ if (config.registryAuthEnabled) {// AFTER initDb (config.ts is sync and cannot query Postgres). See Task 8.}-// Production safety check: reject known dev keys at startup+// Security check: reject historically committed dev JWT keys in any signing or+// verifying slot. Runs on every non-dev startup, not only production, because+// from-source deployments may leave NODE_ENV unset.+if (!CLERUM_DEV_MODE_ENABLED) {+ assertNoBannedJwtKeys({+ rpcPrivateKey: config.rpcJwtPrivateKey,+ sessionPrivateKey: config.sessionJwtPrivateKey,+ adminPrivateKey: config.adminJwtPrivateKey,+ voucherPrivateKey: config.registryVoucherPrivateKey || undefined,+ rpcPublicKey: config.rpcJwtPublicKey,+ rpcPublicKeyEnvSet: Boolean(process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY),+ })+}+if (process.env.NODE_ENV === 'production') {// NOTE: the old voucher-key fallback WARN (dedicated key unset → sign with the// admin JWT key) is gone. Under voucher v2 a managed prod boot without the// dedicated key/kid FAILS FAST in the registryAuthEnabled guard above (unless// break-glass), so there is no silent fallback left to warn about.- const devKeyFingerprint = 'MIIEvAIBADANBgkqhkiG9w0BAQEFAASC' // start of DEV_RPC_JWT_PRIVATE_KEY- const devSessionFingerprint = 'MIIEvgIBADANBgkqhkiG9w0BAQEFAASC' // start of DEV_SESSION_JWT_PRIVATE_KEY- const devAdminFingerprint = 'MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCysO8J' // start of DEV_ADMIN_JWT_PRIVATE_KEY- if (- config.rpcJwtPrivateKey.includes(devKeyFingerprint) ||- config.sessionJwtPrivateKey.includes(devSessionFingerprint) ||- config.adminJwtPrivateKey.includes(devKeyFingerprint) ||- config.adminJwtPrivateKey.includes(devAdminFingerprint)- ) {- throw new Error(- '[SECURITY] Production startup rejected: hardcoded dev JWT signing keys detected. ' +- 'Set CONTROL_API_RPC_JWT_PRIVATE_KEY, CONTROL_API_SESSION_JWT_PRIVATE_KEY, and ' +- 'CONTROL_API_ADMIN_JWT_PRIVATE_KEY to real secrets.'- )- }-for (const [serviceName, token] of Object.entries(config.internalServiceTokens)) {if (/^dev-/.test(token)) {throw new Error(diff --git a/control-api/src/devSigningKeys.ts b/control-api/src/devSigningKeys.tsnew file mode 100644index 000000000..a8b234c67--- /dev/null+++ b/control-api/src/devSigningKeys.ts@@ -0,0 +1,150 @@+import { createPrivateKey, generateKeyPairSync } from 'node:crypto'+import { type Stats, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'+import { dirname, join } from 'node:path'+import { validateRsaPrivateKeyPem } from './bannedDevSigningKeys.js'++export type DevJwtSlot = 'rpc' | 'session' | 'admin'++/**+ * Local-only dev key store at <service>/.dev-keys, gitignored and never+ * touched when operators supply the three JWT key env vars or outside+ * CLERUM_DEV_MODE. Works in every supported runtime: CommonJS (dist and+ * ts-node) resolves __dirname to <service>/dist or <service>/src, so its+ * parent is the service root; Vitest's ESM transform has no __dirname and+ * falls back to the service working directory used by every test/npm script.+ */+const SERVICE_ROOT = typeof __dirname === 'string' && __dirname ? dirname(__dirname) : process.cwd()+const DEFAULT_STORE_DIR = join(SERVICE_ROOT, '.dev-keys')++export function defaultDevSigningKeyStoreDir(): string {+ return DEFAULT_STORE_DIR+}++function assertOwnedRegularFile(filePath: string): void {+ const stats = lstatSync(filePath, { throwIfNoEntry: false })+ if (!stats) throw new Error(`Dev JWT key store file is missing after creation: ${filePath}`)+ if (stats.isSymbolicLink() || !stats.isFile()) {+ throw new Error(`Dev JWT key store path is not a regular file: ${filePath}`)+ }+ if (process.geteuid && stats.uid !== process.geteuid()) {+ throw new Error(`Dev JWT key store file is not owned by the current user: ${filePath}`)+ }+ if ((stats.mode & 0o077) !== 0) {+ throw new Error(+ `Dev JWT key store file has group/other permissions; expected 0600: ${filePath}`+ )+ }+}++function assertOwnedPrivateDirectory(dirPath: string, stats: Stats): void {+ if (stats.isSymbolicLink() || !stats.isDirectory()) {+ throw new Error(`Dev JWT key store path is not a directory: ${dirPath}`)+ }+ if (process.geteuid && stats.uid !== process.geteuid()) {+ throw new Error(`Dev JWT key store directory is not owned by the current user: ${dirPath}`)+ }+ if ((stats.mode & 0o077) !== 0) {+ throw new Error(+ `Dev JWT key store directory has group/other permissions; expected 0700: ${dirPath}`+ )+ }+}++function ensureStoreDir(storeDir: string): void {+ const stats = lstatSync(storeDir, { throwIfNoEntry: false })+ if (stats) {+ assertOwnedPrivateDirectory(storeDir, stats)+ return+ }+ try {+ mkdirSync(storeDir, { mode: 0o700 })+ } catch (err) {+ if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err+ // Lost a creation race with another local process; revalidate the winner.+ }+ const dirStats = lstatSync(storeDir, { throwIfNoEntry: false })+ if (!dirStats) throw new Error(`Dev JWT key store directory disappeared: ${storeDir}`)+ assertOwnedPrivateDirectory(storeDir, dirStats)+}++function readPersistedKey(filePath: string, slot: DevJwtSlot): string | undefined {+ const stats = lstatSync(filePath, { throwIfNoEntry: false })+ if (!stats) return undefined+ if (stats.isSymbolicLink() || !stats.isFile()) {+ throw new Error(`Dev JWT key store path is not a regular file: ${filePath}`)+ }+ if (process.geteuid && stats.uid !== process.geteuid()) {+ throw new Error(`Dev JWT key store file is not owned by the current user: ${filePath}`)+ }+ if ((stats.mode & 0o077) !== 0) {+ throw new Error(+ `Dev JWT key store file has group/other permissions; expected 0600: ${filePath}`+ )+ }+ let raw: string+ try {+ raw = readFileSync(filePath, 'utf8')+ } catch (err) {+ if ((err as NodeJS.ErrnoException).code === 'ENOENT') return undefined+ throw err+ }+ try {+ return validateRsaPrivateKeyPem(raw.trim(), `${slot} dev signing key`)+ } catch (err) {+ throw new Error(+ `Dev JWT key store file is corrupt or not an RSA private key (delete it only if you accept losing dev tokens): ${filePath}: ${(err as Error).message}`+ )+ }+}++let warnedOnce = false++/**+ * Returns the dev private key for a slot, generating and persisting it with+ * exclusive creation on first use. Concurrent first starts converge on one+ * key per slot; existing files are never overwritten. The store directory is+ * only touched when a key is actually needed.+ */+export function loadOrGenerateDevJwtPrivateKey(+ slot: DevJwtSlot,+ storeDir: string = DEFAULT_STORE_DIR+): string {+ const filePath = join(storeDir, `${slot}.pem`)+ const existing = readPersistedKey(filePath, slot)+ if (existing) {+ warnOnce()+ return existing+ }+ ensureStoreDir(storeDir)+ const { privateKey } = generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ })+ try {+ writeFileSync(filePath, privateKey, { flag: 'wx', mode: 0o600 })+ } catch (err) {+ if ((err as NodeJS.ErrnoException).code === 'EEXIST') {+ // Another local process created the key first; adopt it.+ const winner = readPersistedKey(filePath, slot)+ if (winner) {+ warnOnce()+ return winner+ }+ }+ throw err+ }+ assertOwnedRegularFile(filePath)+ createPrivateKey(privateKey) // sanity: the generated key must re-parse+ warnOnce()+ return privateKey.trim()+}++function warnOnce(): void {+ if (warnedOnce) return+ warnedOnce = true+ console.warn(+ '[ControlAPI] Dev JWT signing keys are active (CLERUM_DEV_MODE). Keys are generated locally ' ++ 'and stored under control-api/.dev-keys; they are never valid for production deployments.'+ )+}diff --git a/control-api/src/services/registryConnectionDb.ts b/control-api/src/services/registryConnectionDb.tsindex 842387b76..a1eabf20e 100644--- a/control-api/src/services/registryConnectionDb.ts+++ b/control-api/src/services/registryConnectionDb.ts@@ -1,3 +1,4 @@+import { isBannedSigningKeyPem } from '../bannedDevSigningKeys.js'import { config } from '../config.js'import { pool, withTransaction } from '../db.js'import type { DbClient } from '../db.js'@@ -209,6 +210,12 @@ export async function resolveVoucherSigningMaterial(): Promise<{if (config.registryConnectionMode === 'self-hosted') {const row = await getRegistryConnection()if (!row || !row.privateKeyPem || !row.keyId) throw new VoucherUnavailableError()+ if (isBannedSigningKeyPem(row.privateKeyPem)) {+ throw new Error(+ '[SECURITY] registry_connection voucher signing key is a historically committed dev ' ++ 'JWT key; replace it through registry enrollment.'+ )+ }return { signingKey: row.privateKeyPem, kid: row.keyId }}// manageddiff --git a/control-api/test/bannedDevSigningKeys.test.ts b/control-api/test/bannedDevSigningKeys.test.tsnew file mode 100644index 000000000..e4460ff2b--- /dev/null+++ b/control-api/test/bannedDevSigningKeys.test.ts@@ -0,0 +1,131 @@+import { describe, expect, it } from 'vitest'+import { generateKeyPairSync } from 'node:crypto'+import {+ BANNED_DEV_JWT_PUBLIC_KEY_FINGERPRINTS as DEFAULT_BANNED_FINGERPRINTS,+ assertNoBannedJwtKeys as assertGuard,+ isBannedPublicKeyPem,+ publicKeyPemFingerprint as publicKeyFingerprint,+ validateRsaPrivateKeyPem as validateSigningPem,+} from '../src/bannedDevSigningKeys.js'+import { BANNED_DEV_JWT_PUBLIC_KEYS as HISTORICAL_PUBLIC_KEYS } from './fixtures/bannedDevJwtPublicKeys.js'++function rsaPublicKey(modulusLength = 2048): string {+ return generateKeyPairSync('rsa', {+ modulusLength,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ }).publicKey+}++function makeFresh(): { signing: string; public: string } {+ const pair = generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ })+ return { signing: pair.privateKey, public: pair.publicKey }+}++function makeOffender() {+ const fresh = makeFresh()+ return { signing: fresh.signing, fingerprints: new Set([publicKeyFingerprint(fresh.public)]) }+}++describe('bannedDevSigningKeys', () => {+ it('does not ban freshly generated keys of operator-typical sizes', () => {+ for (const bits of [2048, 3072, 4096] as const) {+ expect(isBannedPublicKeyPem(rsaPublicKey(bits))).toBe(false)+ }+ })++ it('pins each historical public fixture to the default ban list', () => {+ for (const [slot, publicPem] of Object.entries(HISTORICAL_PUBLIC_KEYS)) {+ const fingerprint = publicKeyFingerprint(publicPem)+ expect(DEFAULT_BANNED_FINGERPRINTS.has(fingerprint), slot).toBe(true)+ expect(isBannedPublicKeyPem(publicPem)).toBe(true)+ }+ expect(DEFAULT_BANNED_FINGERPRINTS.size).toBe(3)+ })++ it('validates fresh RSA-2048 signing material', () => {+ expect(() => validateSigningPem(makeFresh().signing, 'TEST_ENV')).not.toThrow()+ })++ it('rejects public PEMs, weak moduli, and non-RSA algorithms', () => {+ expect(() => validateSigningPem(rsaPublicKey(1024), 'TEST_ENV')).toThrow(/TEST_ENV/)+ const ec = generateKeyPairSync('ec', {+ namedCurve: 'P-256',+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ })+ expect(() => validateSigningPem(ec.publicKey, 'TEST_ENV')).toThrow(/must be a PEM-encoded/)+ expect(() => validateSigningPem(ec.privateKey, 'TEST_ENV')).toThrow(/must be an RSA key/)+ })++ it('rejects a banned fingerprint in every signing slot', () => {+ for (const slot of ['rpc', 'session', 'admin', 'voucher'] as const) {+ const offender = makeOffender()+ const freshRpc = makeFresh()+ const freshSession = makeFresh()+ const freshAdmin = makeFresh()+ const freshVerifier = makeFresh()+ const input = {+ rpcPrivateKey: slot === 'rpc' ? offender.signing : freshRpc.signing,+ sessionPrivateKey: slot === 'session' ? offender.signing : freshSession.signing,+ adminPrivateKey: slot === 'admin' ? offender.signing : freshAdmin.signing,+ voucherPrivateKey: slot === 'voucher' ? offender.signing : undefined,+ rpcPublicKey: freshVerifier.public,+ rpcPublicKeyEnvSet: false,+ }+ expect(() => assertGuard(input, offender.fingerprints), slot).toThrow(+ /historically committed dev JWT key/+ )+ }+ })++ it('rejects a banned verifier public key and mismatched overrides', () => {+ const fresh = makeFresh()+ const offender = makeOffender()+ expect(() =>+ assertGuard(+ {+ rpcPrivateKey: fresh.signing,+ sessionPrivateKey: makeFresh().signing,+ adminPrivateKey: makeFresh().signing,+ rpcPublicKey: HISTORICAL_PUBLIC_KEYS.rpc,+ rpcPublicKeyEnvSet: true,+ },+ new Set([publicKeyFingerprint(HISTORICAL_PUBLIC_KEYS.rpc)])+ )+ ).toThrow(/effective RPC JWT verifier public key/)++ expect(() =>+ assertGuard(+ {+ rpcPrivateKey: fresh.signing,+ sessionPrivateKey: makeFresh().signing,+ adminPrivateKey: makeFresh().signing,+ rpcPublicKey: makeFresh().public,+ rpcPublicKeyEnvSet: true,+ },+ new Set(['0'.repeat(64)])+ )+ ).toThrow(/must correspond to/)+ })++ it('accepts fresh keys with a matching explicit verifier override', () => {+ const fresh = makeFresh()+ expect(() =>+ assertGuard(+ {+ rpcPrivateKey: fresh.signing,+ sessionPrivateKey: makeFresh().signing,+ adminPrivateKey: makeFresh().signing,+ rpcPublicKey: fresh.public.trim(),+ rpcPublicKeyEnvSet: true,+ },+ new Set(['0'.repeat(64)])+ )+ ).not.toThrow()+ })+})diff --git a/control-api/test/config.jwtHardening.test.ts b/control-api/test/config.jwtHardening.test.tsnew file mode 100644index 000000000..123db20f1--- /dev/null+++ b/control-api/test/config.jwtHardening.test.ts@@ -0,0 +1,150 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'+import { createPublicKey, generateKeyPairSync } from 'node:crypto'+import { existsSync } from 'node:fs'+import { BANNED_DEV_JWT_PUBLIC_KEYS as HISTORICAL } from './fixtures/bannedDevJwtPublicKeys.js'++const ORIGINAL_ENV = { ...process.env }+const SLOT_ENV_NAMES = [+ 'CONTROL_API_RPC_JWT_PRIVATE_KEY',+ 'CONTROL_API_SESSION_JWT_PRIVATE_KEY',+ 'CONTROL_API_ADMIN_JWT_PRIVATE_KEY',+] as const++const devProviderMocks = vi.hoisted(() => ({+ load: vi.fn(+ (slot: 'rpc' | 'session' | 'admin') =>+ generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ }).privateKey+ ),+}))++vi.mock('../src/devSigningKeys.js', () => ({+ loadOrGenerateDevJwtPrivateKey: devProviderMocks.load,+ defaultDevSigningKeyStoreDir: () => '/nonexistent-dev-key-store',+}))++function freshSigningMaterial(): string {+ return generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ }).privateKey+}++function freshVerifyingMaterial(): string {+ return generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ }).publicKey+}++/** First RSA-2048 signing PEM whose base64 body starts with the given prefix. */+function signingMaterialWithBodyPrefix(prefix: string): string {+ for (let attempt = 0; attempt < 300; attempt++) {+ const candidate = freshSigningMaterial()+ const body = candidate.split('\n')[1] ?? ''+ if (body.startsWith(prefix)) return candidate+ }+ throw new Error(`no RSA-2048 candidate produced body prefix ${prefix}`)+}++function resetEnv(): void {+ process.env = { ...ORIGINAL_ENV }+ delete process.env.NODE_ENV+ delete process.env.CLERUM_DEV_MODE+ delete process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY+}++beforeEach(() => {+ vi.resetModules()+ devProviderMocks.load.mockClear()+ resetEnv()+})++afterEach(() => {+ resetEnv()+ vi.restoreAllMocks()+ vi.resetModules()+})++describe('config JWT hardening', () => {+ it('fails outside dev mode when any signing env var is missing', async () => {+ for (const name of SLOT_ENV_NAMES) {+ vi.resetModules()+ resetEnv()+ delete process.env[name]+ await expect(() => import('../src/config.js'), name).rejects.toThrow(+ new RegExp(`Missing required environment variable: ${name}`)+ )+ }+ })++ it('rejects CLERUM_DEV_MODE=true together with NODE_ENV=production before generation', async () => {+ process.env.NODE_ENV = 'production'+ process.env.CLERUM_DEV_MODE = 'true'+ await expect(() => import('../src/config.js')).rejects.toThrow(+ /CLERUM_DEV_MODE=true is not allowed with NODE_ENV=production/+ )+ expect(devProviderMocks.load).not.toHaveBeenCalled()+ })++ it('uses the dev provider for unset slots in dev mode', async () => {+ for (const name of SLOT_ENV_NAMES) delete process.env[name]+ process.env.CLERUM_DEV_MODE = 'true'+ const { config } = await import('../src/config.js')+ expect(devProviderMocks.load).toHaveBeenCalledTimes(3)+ expect(config.rpcJwtPrivateKey).toBeTruthy()+ expect(config.sessionJwtPrivateKey).toBeTruthy()+ expect(config.adminJwtPrivateKey).toBeTruthy()+ })++ it('rejects a historical verifier public key even with a fresh signing key', async () => {+ process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY = HISTORICAL.rpc+ await expect(() => import('../src/config.js')).rejects.toThrow(+ /effective RPC JWT verifier public key/+ )+ })++ it('rejects an explicit verifier override that does not match the signing key', async () => {+ process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY = freshVerifyingMaterial()+ await expect(() => import('../src/config.js')).rejects.toThrow(/must correspond to/)+ })++ it('accepts an explicit verifier override derived from the signing key', async () => {+ const signing = process.env.CONTROL_API_RPC_JWT_PRIVATE_KEY ?? freshSigningMaterial()+ process.env.CONTROL_API_RPC_JWT_PRIVATE_KEY = signing+ process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY = createPublicKey(signing)+ .export({ type: 'spki', format: 'pem' })+ .toString()+ await expect(import('../src/config.js')).resolves.toBeDefined()+ })++ it('accepts fresh RSA-2048 keys whose bodies start with the historical prefixes', async () => {+ process.env.CONTROL_API_RPC_JWT_PRIVATE_KEY = signingMaterialWithBodyPrefix('MIIEvA')+ process.env.CONTROL_API_SESSION_JWT_PRIVATE_KEY = signingMaterialWithBodyPrefix('MIIEvg')+ process.env.CONTROL_API_ADMIN_JWT_PRIVATE_KEY = signingMaterialWithBodyPrefix('MIIEvQ')+ const { config } = await import('../src/config.js')+ expect(config.rpcJwtPrivateKey).toContain('BEGIN')+ expect(config.sessionJwtPrivateKey).toContain('BEGIN')+ expect(config.adminJwtPrivateKey).toContain('BEGIN')+ })++ it('resolves with fully configured keys for non-production NODE_ENV values', async () => {+ for (const nodeEnv of ['test', 'development', undefined]) {+ vi.resetModules()+ resetEnv()+ if (nodeEnv) process.env.NODE_ENV = nodeEnv+ await expect(import('../src/config.js')).resolves.toBeDefined()+ }+ })++ it('performs no dev-key store I/O when every slot is configured', async () => {+ const { defaultDevSigningKeyStoreDir } = await import('../src/devSigningKeys.js')+ await import('../src/config.js')+ expect(existsSync(defaultDevSigningKeyStoreDir())).toBe(false)+ })+})diff --git a/control-api/test/config.memberRegistrationMode.test.ts b/control-api/test/config.memberRegistrationMode.test.tsindex eb8250fe2..f894d2414 100644--- a/control-api/test/config.memberRegistrationMode.test.ts+++ b/control-api/test/config.memberRegistrationMode.test.ts@@ -2,9 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'import { generateKeyPairSync, randomBytes } from 'node:crypto'function generateNonDevPem(): string {- // 3072-bit RSA — 2048 collides with the dev-key fingerprint check in src/config.ts.return generateKeyPairSync('rsa', {- modulusLength: 3072,+ modulusLength: 2048,privateKeyEncoding: { type: 'pkcs8', format: 'pem' },publicKeyEncoding: { type: 'spki', format: 'pem' },}).privateKeydiff --git a/control-api/test/config.prod.test.ts b/control-api/test/config.prod.test.tsindex c1cf6f0a3..45dc0e991 100644--- a/control-api/test/config.prod.test.ts+++ b/control-api/test/config.prod.test.ts@@ -2,12 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'import { generateKeyPairSync, randomBytes } from 'node:crypto'function generateNonDevPem(): string {- // 3072-bit RSA. 2048-bit keys produce a PKCS8 header that collides with the- // dev-key fingerprint check in src/config.ts (`MIIEvAIBADANBgkqhkiG9w0BAQEFAASC`- // / `MIIEvgIBADANBgkqhkiG9w0BAQEFAASC`). 3072 yields a `MIIG/Q…` prefix that- // doesn't match either fingerprint and is still RS256-compatible.return generateKeyPairSync('rsa', {- modulusLength: 3072,+ modulusLength: 2048,privateKeyEncoding: { type: 'pkcs8', format: 'pem' },publicKeyEncoding: { type: 'spki', format: 'pem' },}).privateKey@@ -15,8 +11,8 @@ function generateNonDevPem(): string {/*** Populate every CONTROL_API env var that the prod path requires so that- * config evaluation reaches the voucher-key guard rather than throwing earlier- * on a missing required env. Mirrors `requiredOrDevDefault` callsites in+ // Non-dev RPC/session/admin JWT keys; the banned-key guard fingerprints the+ // full public key, so ordinary RSA-2048 material is fine.* `src/config.ts`.*/function applyProdEnv(env: Record<string, string | undefined>): void {diff --git a/control-api/test/devSigningKeys.test.ts b/control-api/test/devSigningKeys.test.tsnew file mode 100644index 000000000..4f990236c--- /dev/null+++ b/control-api/test/devSigningKeys.test.ts@@ -0,0 +1,182 @@+import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest'+import { spawn, spawnSync } from 'node:child_process'+import {+ chmodSync,+ mkdirSync,+ mkdtempSync,+ readFileSync,+ rmSync,+ statSync,+ symlinkSync,+ writeFileSync,+} from 'node:fs'+import { createRequire } from 'node:module'+import { tmpdir } from 'node:os'+import { join } from 'node:path'+import {+ defaultDevSigningKeyStoreDir,+ loadOrGenerateDevJwtPrivateKey,+} from '../src/devSigningKeys.js'++const require = createRequire(import.meta.url)++let compiledModulePath = ''+const tempDirs: string[] = []++function tempStore(): string {+ const dir = mkdtempSync(join(tmpdir(), 'evenfire-dev-keys-'))+ tempDirs.push(dir)+ return dir+}++beforeAll(() => {+ const compileDir = mkdtempSync(join(tmpdir(), 'evenfire-dev-key-provider-'))+ tempDirs.push(compileDir)+ const tsc = require.resolve('typescript/lib/tsc.js')+ const result = spawnSync(+ process.execPath,+ [+ tsc,+ 'src/devSigningKeys.ts',+ 'src/bannedDevSigningKeys.ts',+ '--outDir',+ compileDir,+ '--module',+ 'commonjs',+ '--target',+ 'es2022',+ '--moduleResolution',+ 'node',+ '--skipLibCheck',+ ],+ { cwd: process.cwd(), encoding: 'utf8' }+ )+ if (result.status !== 0) {+ throw new Error(result.stderr || result.stdout || 'provider compilation failed')+ }+ compiledModulePath = join(compileDir, 'devSigningKeys.js')+})++afterAll(() => {+ for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true })+})++afterEach(() => {+ // Stores created inside tests are also in tempDirs; nothing persistent remains.+})++function runChild(slot: 'rpc' | 'session' | 'admin', storeDir: string): Promise<string> {+ return new Promise((resolve, reject) => {+ const child = spawn(+ process.execPath,+ [+ '-e',+ `const provider = require(process.env.DEVKEY_MODULE)+ const { createHash } = require('node:crypto')+ const resolved = provider.loadOrGenerateDevJwtPrivateKey(+ process.env.DEVKEY_SLOT,+ process.env.DEVKEY_STORE+ )+ console.log(JSON.stringify({ fingerprint: createHash('sha256').update(resolved).digest('hex') }))`,+ ],+ {+ env: {+ ...process.env,+ DEVKEY_MODULE: compiledModulePath,+ DEVKEY_SLOT: slot,+ DEVKEY_STORE: storeDir,+ },+ }+ )+ let stdout = ''+ let stderr = ''+ child.stdout.on('data', chunk => (stdout += chunk))+ child.stderr.on('data', chunk => (stderr += chunk))+ child.on('close', code =>+ code === 0+ ? resolve((JSON.parse(stdout.trim()) as { fingerprint: string }).fingerprint)+ : reject(new Error(stderr || `child exited with ${code}`))+ )+ })+}++describe('devSigningKeys persistence contract', () => {+ it('generates a 0600 file in a 0700 store and reuses it across calls', () => {+ const store = tempStore()+ const first = loadOrGenerateDevJwtPrivateKey('rpc', store)+ const second = loadOrGenerateDevJwtPrivateKey('rpc', store)+ expect(second).toBe(first)+ expect(statSync(join(store, 'rpc.pem')).mode & 0o777).toBe(0o600)+ expect(statSync(store).mode & 0o777).toBe(0o700)+ })++ it('keeps slots independent', () => {+ const store = tempStore()+ expect(loadOrGenerateDevJwtPrivateKey('rpc', store)).not.toBe(+ loadOrGenerateDevJwtPrivateKey('session', store)+ )+ })++ it('fails loudly on corruption instead of regenerating', () => {+ const store = tempStore()+ const file = join(store, 'rpc.pem')+ loadOrGenerateDevJwtPrivateKey('rpc', store)+ writeFileSync(file, 'corrupted store entry')+ expect(() => loadOrGenerateDevJwtPrivateKey('rpc', store)).toThrow(/corrupt or not an RSA/)+ expect(readFileSync(file, 'utf8')).toBe('corrupted store entry')+ })++ it('rejects an existing file with loose permissions', () => {+ const store = tempStore()+ const file = join(store, 'session.pem')+ loadOrGenerateDevJwtPrivateKey('session', store)+ chmodSync(file, 0o644)+ expect(() => loadOrGenerateDevJwtPrivateKey('session', store)).toThrow(+ /group\/other permissions/+ )+ })++ it('rejects symlink substitution', () => {+ const realStore = tempStore()+ const linkStore = `${tempStore()}-link`+ tempDirs.push(linkStore)+ loadOrGenerateDevJwtPrivateKey('admin', realStore)+ mkdirSync(linkStore, { mode: 0o700 })+ symlinkSync(join(realStore, 'admin.pem'), join(linkStore, 'admin.pem'))+ expect(() => loadOrGenerateDevJwtPrivateKey('admin', linkStore)).toThrow(/not a regular file/)+ })++ it('reuses the same identity across real separate processes', async () => {+ const store = tempStore()+ const first = await runChild('admin', store)+ const second = await runChild('admin', store)+ expect(second).toBe(first)+ })++ it('converges when two processes create the same slot concurrently', async () => {+ const store = tempStore()+ const [a, b] = await Promise.all([runChild('rpc', store), runChild('rpc', store)])+ expect(b).toBe(a)+ expect(statSync(join(store, 'rpc.pem')).mode & 0o777).toBe(0o600)+ })++ it('uses a store rooted at the service checkout, independent of cwd', () => {+ expect(defaultDevSigningKeyStoreDir().endsWith(join('control-api', '.dev-keys'))).toBe(true)+ })++ it('warns once without emitting key material when dev keys activate', async () => {+ const { vi } = await import('vitest')+ vi.resetModules()+ const provider = await import('../src/devSigningKeys.js')+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})+ try {+ const store = tempStore()+ provider.loadOrGenerateDevJwtPrivateKey('rpc', store)+ provider.loadOrGenerateDevJwtPrivateKey('session', store)+ expect(warn).toHaveBeenCalledTimes(1)+ expect(String(warn.mock.calls.flat())).not.toContain('BEGIN')+ } finally {+ warn.mockRestore()+ }+ })+})diff --git a/control-api/test/fixtures/bannedDevJwtPublicKeys.ts b/control-api/test/fixtures/bannedDevJwtPublicKeys.tsnew file mode 100644index 000000000..38f6ab520--- /dev/null+++ b/control-api/test/fixtures/bannedDevJwtPublicKeys.ts@@ -0,0 +1,36 @@+/**+ * Public halves of the three RSA keys that were once committed as dev JWT+ * defaults. These are verification material only — they cannot sign — and pin+ * the banned fingerprint list to the exact historical keys.+ */+export const BANNED_DEV_JWT_PUBLIC_KEYS = {+ rpc: `-----BEGIN PUBLIC KEY-----+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArCIYGHehMPpGKePxaKQa+rDX5yrzifU5i4fzpI3EtkKSU6s5ug7EkKxc2DdMekoqXe9vr7qKyVwiilUIusXLX+iW7KPMJlD/Fd5Bo7Qxt69wYiL5I4K37eDgCN6D3LduHySEnkhdI0GDpB4LM2ASOx+QkEabepekZTMQyExmCIn/dHJ15B+4A9tiiephYOQNr3GcnW9eDomMt6NJLypikbr+xJO6O7Ar0G+raTbflth8EQzWnGF+WgQW4iiM3wsFhpaE0mUlEbMGDGTMAZy1KfxA+RRu+QZm3Lo+5AiCaHkijDCglHsXLhqsYi2AdRiavD1Gk9LKP/ztKw7q/D6fYFzmO+QwIDAQAB+-----END PUBLIC KEY-----`,++ session: `-----BEGIN PUBLIC KEY-----+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwrZja9jS/r+e2YF1FqEQ+NMLsnffebYzXrZOb7uPMKhXBoKjJh/taR9v3kX2srfVtoikcKKr0Sfa7MMSLnZWd+ETmi7MvbeVD3HpsXpVejmw9D0zeYYSGZplLF/b6HY0Lz2XVM8WdJl3Dicyu+SZbZ+xeHZtMCMTTjvmoI/IYmmO4N3Pgz/SGi7V3EiwoALODP4OWDvd/1xFUiMPslLPgZU+EczQ5tIpAaD4e0om3gUNsyOKYc5igojm6ooVqI9T3TUGBVJ0uSZB7ntWxKQ39WyI+aH+oqnwDGbDcDLQ/wTuBtcn4brWTDgW1xA73HVBSImGFvvHCWBiQBiI1nvovUP0u+WQIDAQAB+-----END PUBLIC KEY-----`,++ admin: `-----BEGIN PUBLIC KEY-----+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsrDvCYzx96OLO2qv37sb+ZZvCuguzR+cWxwOYpx61AP+GL9lxV60FJJJKjtRhO/Ivm6koOzgVyln12BphipB0+nJs9fdLzArpxeiuKaligrkL9c/2TwljmRpZagZzZKKAQR827b0WRz9qB63npbjMv+/7L1GNxcMtLne2rTAYU3gez0I7phwKAYH/zY+T5iH2l0qpt/4Iy6t7pWOQ0qgrKe+JPFe5qYWK3c8BWGnWJkhoLCNUCTnUa1yGaIHuRwKzwPH9b476rS72NGqGC4xRZXA+einOdIz3PympLN0HyIjSsPBUlhewILwD5jQBC6DxYeXLQJY0UHWRLrOqQRkJsep6+yQIDAQAB+-----END PUBLIC KEY-----`,+} as constdiff --git a/control-api/test/jwtKeys.setup.ts b/control-api/test/jwtKeys.setup.tsnew file mode 100644index 000000000..4dfe32278--- /dev/null+++ b/control-api/test/jwtKeys.setup.ts@@ -0,0 +1,29 @@+import { generateKeyPairSync } from 'node:crypto'++/**+ * Shared test fixture: real, randomly generated RSA keys for the three JWT+ * slots so config-dependent suites exercise the non-dev path without implicit+ * dev defaults and without writing to the local dev-key store. Tests that+ * verify missing-key failures delete these variables explicitly.+ */+function testKey(): string {+ return generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ }).privateKey+}++const testKeys: Record<string, string> = {+ CONTROL_API_RPC_JWT_PRIVATE_KEY: testKey(),+ CONTROL_API_SESSION_JWT_PRIVATE_KEY: testKey(),+ CONTROL_API_ADMIN_JWT_PRIVATE_KEY: testKey(),+}++export const JWT_TEST_KEY_ENV_NAMES = Object.keys(testKeys) as readonly string[]++for (const [name, value] of Object.entries(testKeys)) {+ if (!process.env[name]) {+ process.env[name] = value+ }+}diff --git a/control-api/test/services.registryVoucher.test.ts b/control-api/test/services.registryVoucher.test.tsindex 7219a5cc3..391e0446d 100644--- a/control-api/test/services.registryVoucher.test.ts+++ b/control-api/test/services.registryVoucher.test.ts@@ -16,6 +16,14 @@ const { cfg } = vi.hoisted(() => ({} as Record<string, unknown>,}))vi.mock('../src/config.js', () => ({ config: cfg }))+const bannedCheck = vi.hoisted(() => ({ value: false }))+vi.mock('../src/bannedDevSigningKeys.js', async importOriginal => {+ const original = await importOriginal<typeof import('../src/bannedDevSigningKeys.js')>()+ return {+ ...original,+ isBannedSigningKeyPem: vi.fn(() => bannedCheck.value),+ }+})// self-hosted branch queries the DB — not exercised in the managed tests below.vi.mock('../src/db.js', () => ({pool: { query: vi.fn().mockResolvedValue({ rows: [], rowCount: 0 }) },@@ -83,3 +91,38 @@ describe('mintIdentityVoucher — voucher v2 (managed)', () => {await expect(mintIdentityVoucher(admin)).rejects.toBeInstanceOf(VoucherUnavailableError)})})++describe('voucher v2 (self-hosted) persisted-key guard', () => {+ it('rejects a persisted signing key flagged as historically committed', async () => {+ const { deriveOAuthEncryptionKey, encryptOAuthSecret } =+ await import('../src/oauth/encryption.js')+ const { pool } = await import('../src/db.js')+ const { isBannedSigningKeyPem } = await import('../src/bannedDevSigningKeys.js')+ const encryptionKeyHex = 'ab'.repeat(32)+ const persisted = keypair().privateKey+ cfg.registryConnectionMode = 'self-hosted'+ ;(cfg as Record<string, unknown>).oauthEncryptionKey = encryptionKeyHex+ vi.mocked(isBannedSigningKeyPem).mockReturnValueOnce(true)+ vi.mocked(pool.query).mockResolvedValueOnce({+ rows: [+ {+ deployment_id: 'deployment-1',+ key_id: 'key-uuid-42',+ public_key_pem: '',+ private_key_encrypted: encryptOAuthSecret(+ deriveOAuthEncryptionKey(encryptionKeyHex),+ persisted+ ),+ client_id: '',+ client_secret_encrypted: null,+ org_name: null,+ requested_org_name: null,+ contact_email: null,+ status: 'connected',+ registry_url: '',+ },+ ],+ })+ await expect(mintIdentityVoucher(admin)).rejects.toThrow(/historically committed dev/)+ })+})diff --git a/control-api/vitest.config.ts b/control-api/vitest.config.tsindex 85c16c4d6..9d7852c47 100644--- a/control-api/vitest.config.ts+++ b/control-api/vitest.config.ts@@ -22,6 +22,7 @@ export default defineConfig({environment: 'node',setupFiles: ['../scripts/testing/bind-loopback-in-tests.mjs',+ 'test/jwtKeys.setup.ts','test/realPostgres.requirement.ts',],// Control API route suites mock shared modules, env-backed config, anddiff --git a/tests/e2e/package-lock.json b/tests/e2e/package-lock.jsonindex 3e074b47d..c4e9efb72 100644--- a/tests/e2e/package-lock.json+++ b/tests/e2e/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-e2e-tests",- "version": "0.1.96",+ "version": "0.1.97","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-e2e-tests",- "version": "0.1.96",+ "version": "0.1.97","devDependencies": {"@clerum/llm-provider-attempt-contract": "file:../../packages/llm-provider-attempt-contract","@types/jsonwebtoken": "^9.0.10",diff --git a/tests/e2e/package.json b/tests/e2e/package.jsonindex 125b1df5d..e3c2c5a98 100644--- a/tests/e2e/package.json+++ b/tests/e2e/package.json@@ -1,6 +1,6 @@{"name": "clerum-e2e-tests",- "version": "0.1.96",+ "version": "0.1.97","private": true,"type": "module","scripts": {diff --git a/tests/e2e/rpc-proxy/helpers/jwt.ts b/tests/e2e/rpc-proxy/helpers/jwt.tsindex 9fdb3cf60..792536d5b 100644--- a/tests/e2e/rpc-proxy/helpers/jwt.ts+++ b/tests/e2e/rpc-proxy/helpers/jwt.ts@@ -1,87 +1,59 @@-import { generateKeyPairSync } from "node:crypto";-import jwt from "jsonwebtoken";+import jwt from 'jsonwebtoken'+import { generateKeyPairSync } from 'node:crypto'-export const TEST_JWT_PRIVATE_KEY = `-----BEGIN PRIVATE KEY------MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCsIhgYd6Ew+kYp-4/FopBqsNfnKvOJ9TmLh/OkjcS2QpJTqzm6DsSQrFzYN0x6Sipd72+vuorJXCKKV-Qi6xcteJbso8wmUP8V3kGjtDG3r3BiIvkjgrft4OAI3oPct24fJISeSF0jQYOkHg-szYBI7FCQRpt6l6RlMxDITGYIif90cnXkH7gD22KJ6mFg5A2vcZydb14OiYy3o0k-vKmKRuvEk7o7sCvQb6tpNt+W2HwRDNacYX5aBBbiKIzfCwWGloTSZSURswYMZMwB-nLUp/EBFG75Bmbcuj7kCIJoeSKMMKCUexcuGqxiLYB1GJq8PUaT0so//O0rDur8P-p9gXOY5DAgMBAAECggEAVAGPoOFBWZXLCEamWls8aS8uaTMlleHbgE7duN5TTnQD-+VQluz+IVz9MshKGqR3aMCh0TFI6lx8vuYhDIXbamcfoCx8UE2PIXroukeGncUcd-B/pkT1XrKQo8N0txMOO0SnNFg8nCgtBrti2//W5d4+fB7kKjRIlJ5rkcaxLAUa5z-fpvaz+DhwBvvIi5zakhUBGVinVnQV6cKS5c52ccYikSNG9ysGBParCbVsQCwgLan-JhWCmRYuPj5MoaELcZ7lBO2ow+SO/VSTW03fnC/cIYCxZqAEEnq3fg5/FFsy6xsB-CbwQQaGnUrrw/LyGX3vyW7eXDL4hOYLp+l+tZklqAQKBgQDe8I4RegQ7lGvVnEoo-xTBdZg6kgjSRRBMs67/E+HrnnHC8gMjT2MlJguYQEonFP8teDoj0l7+1Bj/LRyHv-CyZr03EpevMQut27VdEO/qWYaGpOsXC2xkuiJWeKYvp3//lcIofXy9VhStlsisk6-yx1LAY6iiZvptaCzJmYTU677swKBgQDFqMaLyLAAIpMcBrLDlGt8qyB6ZVaJZTHP-vs13Md6RJPVXXyGtWRtpMwOSwHJNyy3xN23rWtlj32UE9KW/47oxjbkXfpExG/fi-UBeA80AtjM57q66+LZ9Rs5EAFcOsNrd11XY4Y/37/MMbWQgjfW44uEeB2drx9mB0-LU9H+1KbMQKBgFKij8Zil9cNuLrA56wdC0RTY/IOYTXHKeRorfhwsf3PuunkQoxj-upiI8IXcmTyH3PXMJW+kH+cVnefXQfi9BUzKXxOlAxucaDvcH1WThgXsDhuFIeZd-sgM0IiDldzmro95G3ltarokVmWnmN5iXWRBIT3pnz2bdb+d3wDZBuoaJAoGABCl9-pMvhCN+xgVGSyhOB/+oKkQk5PUNoPRujb/MY4K2KjQBv0RqjPR/Z32k1/vVcTkwA-gIg1M6ksk2Ija1r8PLbjQt9jZ0lTeux80jZND6h7YJdI4rBLPoktcHcE28d7LXwF-NULFwlycLyM8zKKDg6Y9uzo/JgEuHsQlezqLjsECgYAboHrpwXg/SBatigtBvj0E-1ccXGGLgN2dhDbAlZoSKDITOxGiOw48bOX1lT25c06muru+2mCNrsN2lMs07VGk8-PSRsIuFZis/4vrRtjoxUB4OQ29+mfVgqGsABPugCmi/r22gWrvl1aqEEqstg3m7x-sKRpFxViv5P5TmnxLggnhw==------END PRIVATE KEY-----`;+// Generated once per test process so no signing material is committed. The+// matching public half is exported for the spawned rpc-proxy verifier env.+const testKeyPair = generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { format: 'pem', type: 'pkcs8' },+ publicKeyEncoding: { format: 'pem', type: 'spki' },+})-export const TEST_JWT_PUBLIC_KEY = `-----BEGIN PUBLIC KEY------MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArCIYGHehMPpGKePxaKQa-rDX5yrzifU5i4fzpI3EtkKSU6s5ug7EkKxc2DdMekoqXe9vr7qKyVwiilUIusXLX-iW7KPMJlD/Fd5Bo7Qxt69wYiL5I4K37eDgCN6D3LduHySEnkhdI0GDpB4LM2ASOx-QkEabepekZTMQyExmCIn/dHJ15B+4A9tiiephYOQNr3GcnW9eDomMt6NJLypikbr-xJO6O7Ar0G+raTbflth8EQzWnGF+WgQW4iiM3wsFhpaE0mUlEbMGDGTMAZy1KfxA-RRu+QZm3Lo+5AiCaHkijDCglHsXLhqsYi2AdRiavD1Gk9LKP/ztKw7q/D6fYFzmO-QwIDAQAB------END PUBLIC KEY-----`;+export const TEST_JWT_PRIVATE_KEY = testKeyPair.privateKey+export const TEST_JWT_PUBLIC_KEY = testKeyPair.publicKeytype RpcJwtOptions = {- sub?: string;- typ?: "user" | "service";- teamId?: string;- scopes?: string[];- hostRefs?: string[];- iss?: string;- aud?: string;- expiresInSeconds?: number;- now?: number;- privateKey?: string;- jti?: string;-};+ sub?: string+ typ?: 'user' | 'service'+ teamId?: string+ scopes?: string[]+ hostRefs?: string[]+ iss?: string+ aud?: string+ expiresInSeconds?: number+ now?: number+ privateKey?: string+ jti?: string+}export function signRpcJwt(opts: RpcJwtOptions = {}): string {- const now = opts.now ?? Math.floor(Date.now() / 1000);- const exp = now + (opts.expiresInSeconds ?? 300);+ const now = opts.now ?? Math.floor(Date.now() / 1000)+ const exp = now + (opts.expiresInSeconds ?? 300)return jwt.sign({- sub: opts.sub ?? "e2e-user",- typ: opts.typ ?? "user",- teamId: opts.teamId ?? "e2e-team",- scopes: opts.scopes ?? ["mcp:servers:list", "mcp:server:invoke"],- hostRefs: opts.hostRefs ?? ["agent2"],+ sub: opts.sub ?? 'e2e-user',+ typ: opts.typ ?? 'user',+ teamId: opts.teamId ?? 'e2e-team',+ scopes: opts.scopes ?? ['mcp:servers:list', 'mcp:server:invoke'],+ hostRefs: opts.hostRefs ?? ['agent2'],jti: opts.jti ?? `e2e-${now}`,iat: now,- exp+ exp,},opts.privateKey ?? TEST_JWT_PRIVATE_KEY,{- algorithm: "RS256",- issuer: opts.iss ?? "control-api",- audience: opts.aud ?? "rpc-proxy"+ algorithm: 'RS256',+ issuer: opts.iss ?? 'control-api',+ audience: opts.aud ?? 'rpc-proxy',}- );+ )}-export function signWithWrongKey(opts: Omit<RpcJwtOptions, "privateKey"> = {}): string {- const { privateKey } = generateKeyPairSync("rsa", {+export function signWithWrongKey(opts: Omit<RpcJwtOptions, 'privateKey'> = {}): string {+ const { privateKey } = generateKeyPairSync('rsa', {modulusLength: 2048,- privateKeyEncoding: { format: "pem", type: "pkcs8" },- publicKeyEncoding: { format: "pem", type: "spki" }- });- return signRpcJwt({ ...opts, privateKey });+ privateKeyEncoding: { format: 'pem', type: 'pkcs8' },+ publicKeyEncoding: { format: 'pem', type: 'spki' },+ })+ return signRpcJwt({ ...opts, privateKey })}