Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
14.7 KB
Raw Blame
import { type MockInstance, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
  createHash,
  createPrivateKey,
  createPublicKey,
  generateKeyPairSync,
  randomUUID,
} from 'node:crypto'
import type { KeyObject } from 'node:crypto'
import { existsSync, mkdtempSync, readdirSync, rmSync } from 'node:fs'
import { createRequire } from 'node:module'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { BANNED_DEV_JWT_PUBLIC_KEYS as HISTORICAL } from './fixtures/bannedDevJwtPublicKeys.js'
import { applyProdEnv } from './fixtures/productionConfigEnv.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 fixtureApi = createRequire(import.meta.url)(
  '../../packages/jwt-key-policy/test/crypto-fixtures.cjs'
) as {
  encodings: (material: string) => Record<string, string>
  certificate: (material: KeyObject) => string
  fixtures: () => Record<number, any>
}
const rsaPair = generateKeyPairSync('rsa', { modulusLength: 2048 })
const rsa4096Pair = generateKeyPairSync('rsa', { modulusLength: 4096 })
const caseIdentity2048 = createHash('sha256')
  .update(rsaPair.publicKey.export({ type: 'spki', format: 'der' }))
  .digest('hex')
const caseIdentity4096 = createHash('sha256')
  .update(rsa4096Pair.publicKey.export({ type: 'spki', format: 'der' }))
  .digest('hex')
const signingCasePem = rsaPair.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString().trim()
const signingCasePublic = rsaPair.publicKey
  .export({ type: 'spki', format: 'pem' })
  .toString()
  .trim()
const signingCaseCertificate = fixtureApi.certificate(rsaPair.privateKey)
const decoyCasePem = freshSigningMaterial()
const otherCertificate = fixtureApi.certificate(
  generateKeyPairSync('rsa', { modulusLength: 2048 }).privateKey
)
const signingCases = [
  ...Object.entries(fixtureApi.encodings(signingCasePem)).map(([name, material]) => ({
    name,
    material,
    reason: undefined,
  })),
  {
    name: 'pkcs1',
    material: rsaPair.privateKey.export({ type: 'pkcs1', format: 'pem' }).toString(),
    reason: undefined,
  },
  {
    name: 'rsa4096',
    material: rsa4096Pair.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(),
    reason: undefined,
  },
  {
    name: 'rsa1024',
    material: fixtureApi
      .fixtures()[1024]
      .privateKey.export({ type: 'pkcs8', format: 'pem' })
      .toString(),
    reason: 'undersized_rsa_key',
  },
  {
    name: 'encrypted',
    material: rsaPair.privateKey
      .export({ type: 'pkcs8', format: 'pem', cipher: 'aes-256-cbc', passphrase: randomUUID() })
      .toString(),
    reason: 'encrypted_private_key',
  },
  { name: 'malformed', material: 'malformed operator key material', reason: 'invalid_pem' },
  { name: 'public', material: signingCasePublic, reason: 'wrong_key_role' },
  {
    name: 'ec',
    material: generateKeyPairSync('ec', { namedCurve: 'prime256v1' })
      .privateKey.export({ type: 'pkcs8', format: 'pem' })
      .toString(),
    reason: 'non_rsa_key',
  },
  ...Object.entries({
    privateThenPrivate: `${signingCasePem}\n${decoyCasePem}`,
    publicThenPrivate: `${signingCasePublic}\n${signingCasePem}`,
    privateThenPublic: `${signingCasePem}\n${signingCasePublic}`,
    certificateThenPrivate: `${signingCaseCertificate}\n${signingCasePem}`,
    privateThenCertificate: `${signingCasePem}\n${signingCaseCertificate}`,
    certificateThenCertificate: `${signingCaseCertificate}\n${otherCertificate}`,
    escapedCertificateThenPrivate: `${signingCaseCertificate}\n${signingCasePem}`.replace(
      /\n/g,
      '\\n'
    ),
  }).map(([name, material]) => ({ name, material, reason: 'multiple_pem_objects' })),
]

let providerLoad: MockInstance<
  typeof import('../src/devSigningKeys.js').loadOrCreateDevJwtSigningMaterial
>
let fixtureRoot: string
let fixtureStore: string

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
  delete process.env.CONTROL_API_REGISTRY_VOUCHER_PRIVATE_KEY
}

beforeEach(async () => {
  vi.resetModules()
  resetEnv()
  fixtureRoot = mkdtempSync(join(tmpdir(), 'evenfire-config-jwt-'))
  fixtureStore = join(fixtureRoot, '.dev-keys')
  process.env.EVENFIRE_DEV_KEY_STORE = fixtureStore
  const provider = await import('../src/devSigningKeys.js')
  providerLoad = vi.spyOn(provider, 'loadOrCreateDevJwtSigningMaterial')
})

afterEach(() => {
  resetEnv()
  vi.restoreAllMocks()
  vi.resetModules()
  rmSync(fixtureRoot, { recursive: true, force: true })
})

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 () => {
    for (const name of SLOT_ENV_NAMES) delete process.env[name]
    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(providerLoad).not.toHaveBeenCalled()
    expect(existsSync(fixtureStore)).toBe(false)
  })

  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(providerLoad).toHaveBeenCalledTimes(3)
    expect(readdirSync(fixtureStore).sort()).toEqual([
      'admin.pem',
      'admin.public.pem',
      'rpc.pem',
      'rpc.public.pem',
      'session.pem',
      'session.public.pem',
    ])
    expect(
      createPublicKey(config.rpcJwtPrivateKey)
        .export({ type: 'spki', format: 'pem' })
        .toString()
        .trim() === config.rpcJwtPublicKey
    ).toBe(true)
  })

  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 () => {
    applyProdEnv(process.env)
    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.includes('BEGIN')).toBe(true)
    expect(config.sessionJwtPrivateKey.includes('BEGIN')).toBe(true)
    expect(config.adminJwtPrivateKey.includes('BEGIN')).toBe(true)
  })

  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 () => {
    for (const devMode of [undefined, 'true']) {
      vi.resetModules()
      if (devMode) process.env.CLERUM_DEV_MODE = devMode
      else delete process.env.CLERUM_DEV_MODE
      await import('../src/config.js')
      expect(providerLoad).not.toHaveBeenCalled()
      expect(existsSync(fixtureStore)).toBe(false)
    }
  })

  it('rejects a historical verifier key even in explicit dev mode', async () => {
    process.env.CLERUM_DEV_MODE = 'true'
    process.env.CONTROL_API_RPC_JWT_PUBLIC_KEY = HISTORICAL.rpc
    await expect(() => import('../src/config.js')).rejects.toThrow(
      /effective RPC JWT verifier public key/
    )
  })

  for (const name of [
    ...SLOT_ENV_NAMES,
    'CONTROL_API_RPC_JWT_PUBLIC_KEY',
    'CONTROL_API_REGISTRY_VOUCHER_PRIVATE_KEY',
  ]) {
    it(`validates explicit ${name} before generating any missing dev slot`, async () => {
      for (const slot of SLOT_ENV_NAMES) delete process.env[slot]
      process.env.CLERUM_DEV_MODE = 'true'
      process.env[name] = 'malformed operator material'
      await expect(import('../src/config.js')).rejects.toMatchObject({
        code: 'ERR_JWT_KEY_INVALID',
      })
      expect(providerLoad).not.toHaveBeenCalled()
      expect(existsSync(fixtureStore)).toBe(false)
    })
  }

  it('keeps fully configured identity independent of an unused relative store override', async () => {
    process.env.CLERUM_DEV_MODE = 'true'
    process.env.EVENFIRE_DEV_KEY_STORE = 'unused-relative-store'
    const { config } = await import('../src/config.js')
    expect(config.rpcJwtPublicKey.includes('PUBLIC KEY')).toBe(true)
    expect(providerLoad).not.toHaveBeenCalled()
    expect(existsSync(fixtureStore)).toBe(false)
  })

  for (const [slot, envName] of [
    ['rpc', SLOT_ENV_NAMES[0]],
    ['session', SLOT_ENV_NAMES[1]],
    ['admin', SLOT_ENV_NAMES[2]],
  ] as const) {
    it(`rejects a generated denied ${slot} identity before its actual consumer signs`, async () => {
      const policy = await import('@clerum/jwt-key-policy')
      const offender = freshSigningMaterial()
      const denied = policy.publicKeyPemFingerprint(
        createPublicKey(offender).export({ type: 'spki', format: 'pem' }).toString()
      )
      const parse = policy.parseSigningMaterial
      vi.spyOn(policy, 'parseSigningMaterial').mockImplementation((raw, source, options) =>
        parse(raw, source, { ...options, fingerprints: [denied] })
      )
      process.env[envName] = offender
      const loadConsumer =
        slot === 'rpc'
          ? () => import('../src/utils/auth/rpcAuthToken.js')
          : slot === 'session'
            ? () => import('../src/utils/auth/externalSessionAuthToken.js')
            : () => import('../src/utils/auth/adminAuthToken.js')
      await expect(loadConsumer()).rejects.toMatchObject({
        code: 'ERR_JWT_KEY_BANNED',
        reason: 'banned_identity',
      })
      expect(providerLoad).not.toHaveBeenCalled()
      expect(existsSync(fixtureStore)).toBe(false)
    })
  }

  it('signs and verifies through actual admin, session, and RPC consumers after canonicalization', async () => {
    const material = freshSigningMaterial()
    const escapedCr = material.replace(/\n/g, '\\r')
    for (const name of SLOT_ENV_NAMES) process.env[name] = escapedCr
    const admin = await import('../src/utils/auth/adminAuthToken.js')
    const session = await import('../src/utils/auth/externalSessionAuthToken.js')
    const rpc = await import('../src/utils/auth/rpcAuthToken.js')
    expect(admin.verifyAdminToken(admin.signAdminToken('contract-admin'))?.sub).toBe(
      'contract-admin'
    )
    const sessionResult = session.verifyExternalSessionToken(
      session.signExternalSessionToken({
        userId: 'contract-user',
        email: '[email protected]',
        teamId: null,
        role: 'member',
        authGeneration: 1,
      })
    )
    expect(sessionResult?.userId).toBe('contract-user')
    expect(
      rpc.verifyRpcAccessToken(
        rpc.signRpcAccessToken({
          sub: 'contract-rpc',
          typ: 'user',
          teamId: null,
          accessScope: 'user',
          scopes: ['host:health:read'],
          hostRefs: ['contract-host'],
          jti: 'contract-jti',
        })
      )?.sub
    ).toBe('contract-rpc')
  })

  for (const [slot, envName, field] of [
    ['rpc', SLOT_ENV_NAMES[0], 'rpcJwtPrivateKey'],
    ['session', SLOT_ENV_NAMES[1], 'sessionJwtPrivateKey'],
    ['admin', SLOT_ENV_NAMES[2], 'adminJwtPrivateKey'],
    ['voucher', 'CONTROL_API_REGISTRY_VOUCHER_PRIVATE_KEY', 'registryVoucherPrivateKey'],
  ] as const) {
    for (const testCase of signingCases) {
      it(`${slot} applies the canonical signing policy to ${testCase.name}`, async () => {
        process.env[envName] = testCase.material
        if (testCase.reason) {
          await expect(import('../src/config.js')).rejects.toMatchObject({
            code: 'ERR_JWT_KEY_INVALID',
            reason: testCase.reason,
            source: envName,
          })
        } else {
          const { config } = await import('../src/config.js')
          const policy = await import('@clerum/jwt-key-policy')
          const expected = testCase.name === 'rsa4096' ? caseIdentity4096 : caseIdentity2048
          const actual = policy.publicKeyPemFingerprint(
            createPublicKey(config[field]).export({ type: 'spki', format: 'pem' }).toString()
          )
          expect(actual).toBe(expected)
          const accepted = createPrivateKey(config[field])
          expect(accepted.type).toBe('private')
          expect(
            accepted.export({ type: 'pkcs8', format: 'pem' }).toString().trim() === config[field]
          ).toBe(true)
        }
        expect(providerLoad).not.toHaveBeenCalled()
        expect(existsSync(fixtureStore)).toBe(false)
      })
    }
  }
})