Skip to content

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

TypeScript
7.5 KB
Raw Blame
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import express from 'express'
import { generateKeyPairSync, randomBytes } from 'node:crypto'
import type { Server } from 'node:http'
import { Pool } from 'pg'
import {
  type ExternalRestHttpProcess,
  boundedRequest as request,
  startExternalRestHttpProcess,
} from './helpers/externalRestHttpProcess.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'

const flow = vi.hoisted(() => ({
  validateInvitationFlowToken: vi.fn(),
  storeDesktopAuthorizationToken: vi.fn(),
}))
vi.mock('../src/services/invitationFlowRegistrationService.js', () => flow)

const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
const realPg = adminUrl ? describe : describe.skip

realPg('R2-H1 invitation admission identity on PostgreSQL', () => {
  const database = `r2h1_invite_${randomBytes(6).toString('hex')}`
  const serviceToken = `synthetic-external-rest-${randomBytes(20).toString('hex')}`
  let admin: Pool
  let db: typeof import('../src/db.js')
  let controlApp: express.Express
  let controlServer: Server
  let edge: string
  let publicProcess: ExternalRestHttpProcess
  let completionPosts = 0
  let invitationId: string
  let invitationToken: string
  const email = '[email protected]'
  const completionProof = 'synthetic-owned-completion-proof'

  beforeAll(async () => {
    admin = new Pool({ connectionString: adminUrl })
    await admin.query(`CREATE DATABASE "${database}"`)
    const databaseUrl = new URL(adminUrl!)
    databaseUrl.pathname = `/${database}`
    vi.stubEnv('CONTROL_API_PG_CONNECTION_STRING', databaseUrl.toString())
    vi.stubEnv('CONTROL_API_INTERNAL_SERVICE_TOKENS', `external-rest-api=${serviceToken}`)
    vi.stubEnv('EXTERNAL_REST_API_CONTROL_API_SERVICE_TOKEN', serviceToken)
    vi.stubEnv('EXTERNAL_REST_API_CONTROL_API_SERVICE_NAME', 'external-rest-api')
    const { publicKey } = generateKeyPairSync('rsa', { modulusLength: 2048 })
    vi.stubEnv(
      'EXTERNAL_REST_API_JWT_PUBLIC_KEY',
      publicKey.export({ type: 'spki', format: 'pem' }).toString()
    )
    vi.resetModules()

    db = await import('../src/db.js')
    await db.initDb()
    await db.pool.query('INSERT INTO users(email) VALUES ($1)', [email])
    const { createSilentPasswordResetInvitation } =
      await import('../src/services/directory/passwordResetInvitations.js')
    const invitation = await createSilentPasswordResetInvitation({
      email,
      inviteeName: 'Synthetic admission principal',
    })
    invitationId = invitation.id
    invitationToken = invitation.token
    const { requireInternalService, requireInternalToken } =
      await import('../src/middleware/internalServiceAuth.js')
    const { createExternalInvitationsRouter } =
      await import('../src/routes/external/invitations.js')
    controlApp = express()
    controlApp.use(express.json())
    controlApp.use(requireInternalToken)
    controlApp.use((req, _res, next) => {
      if (req.method === 'POST' && req.path === '/api/v1/external/invitations/password-token')
        completionPosts++
      next()
    })
    const api = express.Router()
    api.use('/external', requireInternalService('external-rest-api'))
    api.use(createExternalInvitationsRouter())
    controlApp.use('/api/v1', api)
    controlServer = controlApp.listen(0, '127.0.0.1')
    await new Promise<void>(resolve => controlServer.once('listening', resolve))

    publicProcess = await startExternalRestHttpProcess({
      controlApiBaseUrl: `http://127.0.0.1:${(controlServer.address() as { port: number }).port}/api/v1`,
      controlApiServiceToken: serviceToken,
      jwtPublicKey: publicKey.export({ type: 'spki', format: 'pem' }).toString(),
    })
    edge = publicProcess.baseUrl
  }, 60_000)

  beforeEach(async () => {
    completionPosts = 0
    flow.validateInvitationFlowToken
      .mockReset()
      .mockImplementation(async (token: string, claimedEmail?: string) => {
        if (token === completionProof && claimedEmail === undefined) {
          return { email, invitationUuid: invitationToken }
        }
        throw new Error('invalid proof')
      })
    await db.pool.query('TRUNCATE rate_limit_buckets')
  })

  afterAll(async () => {
    let childCleanup: PromiseSettledResult<void | undefined> | undefined
    try {
      ;[childCleanup] = await Promise.allSettled([publicProcess?.stop()])
      if (controlServer) {
        await new Promise<void>((resolve, reject) =>
          controlServer.close(error => (error ? reject(error) : resolve()))
        )
      }
      if (db) {
        await endPoolAndWaitForClients(db.pool)
        await endPoolAndWaitForClients(db.rateLimitPool)
      }
      if (admin) await admin.query(`DROP DATABASE IF EXISTS "${database}"`)
    } finally {
      await admin?.end()
      vi.unstubAllEnvs()
    }
    if (childCleanup?.status === 'rejected') throw childCleanup.reason
  })

  async function preview(source: string) {
    return request(edge)
      .get('/api/v1/invitations/token/not-a-signed-flow-token')
      .set('X-Forwarded-For', source)
  }

  async function complete(source: string) {
    return request(edge).post('/api/v1/invitations/password').set('X-Forwarded-For', source).send({
      email,
      token: completionProof,
      invitationId,
      password: 'Synthetic-Password-12',
    })
  }

  it('keeps preview traffic out of the same source completion budget', async () => {
    for (let attempt = 0; attempt < 10; attempt++) {
      const response = await preview('198.51.100.11')
      expect(response.status).toBe(400)
      expect(response.body).toEqual({ error: 'invalid_invitation' })
    }

    const response = await complete('198.51.100.11')
    expect(response.status).toBe(400)
    expect(response.body).toEqual({ error: 'invalid_invitation' })
    expect(completionPosts).toBe(1)
    const buckets = (await db.pool.query('SELECT bucket_key FROM rate_limit_buckets')).rows.map(
      row => row.bucket_key
    )
    expect(buckets).toContain('invite-token:password-token:external-client-ip:198.51.100.11')
    expect(buckets).toContain('invite-token:preview:external-client-ip:198.51.100.11')
    expect(flow.validateInvitationFlowToken).toHaveBeenCalledTimes(12)
  })

  it('isolates completion budgets by the trusted external client identity', async () => {
    for (let attempt = 0; attempt < 10; attempt++) {
      const response = await complete('198.51.100.21')
      expect(response.status).toBe(400)
      expect(response.body).toEqual({ error: 'invalid_invitation' })
    }

    const response = await complete('198.51.100.22')
    expect(response.status).toBe(400)
    expect(response.body).toEqual({ error: 'invalid_invitation' })
    expect(completionPosts).toBe(11)
    const buckets = (await db.pool.query('SELECT bucket_key FROM rate_limit_buckets')).rows.map(
      row => row.bucket_key
    )
    expect(buckets).toContain('invite-token:password-token:external-client-ip:198.51.100.21')
    expect(buckets).toContain('invite-token:password-token:external-client-ip:198.51.100.22')
    expect(flow.validateInvitationFlowToken).toHaveBeenCalledTimes(22)
  })

  it('does not trust an asserted source when the internal service gate rejects the caller', async () => {
    const response = await request(controlApp)
      .post('/api/v1/external/invitations/password-token')
      .set('x-external-client-ip', '198.51.100.99')
      .send({})

    expect(response.status).toBe(401)
    expect(await db.pool.query('SELECT bucket_key FROM rate_limit_buckets')).toMatchObject({
      rows: [],
    })
    expect(flow.validateInvitationFlowToken).not.toHaveBeenCalled()
  })
})