Skip to content

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/.dockerignore
index 6b8f22d12..c44497a69 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -24,6 +24,8 @@
**/*.pem
**/*.key
kubeconfig*
+# Local-only JWT signing keys generated in dev mode; never enter the image.
+control-api/.dev-keys/
**/node_modules
**/dist
**/.next
diff --git a/.gitignore b/.gitignore
index 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.toml
index 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.md
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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 }
}
// managed
diff --git a/control-api/test/bannedDevSigningKeys.test.ts b/control-api/test/bannedDevSigningKeys.test.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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' },
}).privateKey
diff --git a/control-api/test/config.prod.test.ts b/control-api/test/config.prod.test.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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 const
diff --git a/control-api/test/jwtKeys.setup.ts b/control-api/test/jwtKeys.setup.ts
new file mode 100644
index 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.ts
index 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.ts
index 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, and
diff --git a/tests/e2e/package-lock.json b/tests/e2e/package-lock.json
index 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.json
index 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.ts
index 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.publicKey
type 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 })
}