Skip to content

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

TypeScript
8.7 KB
Raw Blame
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import express from 'express'
import bcrypt from 'bcryptjs'
import { randomBytes, randomUUID } from 'node:crypto'
import { Pool } from 'pg'
import request from 'supertest'
import { initDb } from '../src/db.js'
import { createExternalAuthRouter } from '../src/routes/external/auth.js'
import { createExternalInvitationsRouter } from '../src/routes/external/invitations.js'
import { passwordIdentifierKey } from '../src/services/auth/passwordAdmissionState.js'
import { createPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'

const holder = vi.hoisted(() => ({
  pool: null as unknown as Pool,
  leaseClient: null as unknown as import('pg').PoolClient,
}))

vi.mock('../src/db.js', async importOriginal => {
  const real = await importOriginal<typeof import('../src/db.js')>()
  const proxy = {
    query: (...args: unknown[]) => (holder.pool.query as Function)(...args),
    connect: () => holder.pool.connect(),
  }
  return {
    ...real,
    pool: proxy,
    rateLimitPool: proxy,
    withTransaction: (
      fn: Parameters<typeof real.withTransaction>[0],
      _txPool?: Parameters<typeof real.withTransaction>[1],
      options?: Parameters<typeof real.withTransaction>[2]
    ) => real.withTransaction(fn, holder.pool, options),
  }
})

vi.mock('../src/services/rateLimiterService.js', async importOriginal => {
  const real = await importOriginal<typeof import('../src/services/rateLimiterService.js')>()
  return {
    ...real,
    acquireRateLimitConcurrencyLease: (
      requirements: Parameters<typeof real.acquireRateLimitConcurrencyLease>[0]
    ) => real.acquireRateLimitConcurrencyLease(requirements, { client: holder.leaseClient }),
  }
})

const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
const memberRegistrationDbUrl = process.env.CONTROL_API_REAL_MEMBER_REGISTRATION_PG_URL
const realCrossService =
  adminUrl &&
  memberRegistrationDbUrl &&
  process.env.CONTROL_API_MEMBER_REGISTRATION_SERVICE_BASE_URL &&
  process.env.CONTROL_API_MEMBER_REGISTRATION_HMAC_SECRET
    ? describe
    : describe.skip
const password = 'Synthetic-Issue1055-previous-password'

realCrossService(
  'BUG-192 recovery through the real Member Registration producer on PostgreSQL',
  () => {
    const database = `bug192_flow_${randomBytes(6).toString('hex')}`
    const email = `issue1055-${randomUUID()}@example.invalid`
    let admin: Pool
    let memberRegistrationDb: Pool
    let app: express.Express
    let userId: string
    let realHash: string

    beforeAll(async () => {
      admin = new Pool({ connectionString: adminUrl })
      await admin.query(`CREATE DATABASE "${database}"`)
      const url = new URL(adminUrl!)
      url.pathname = `/${database}`
      holder.pool = new Pool({ connectionString: url.toString() })
      await initDb(holder.pool)
      holder.leaseClient = await holder.pool.connect()
      memberRegistrationDb = new Pool({ connectionString: memberRegistrationDbUrl })
      realHash = await bcrypt.hash(password, 12)
      app = express()
      app.use(express.json())
      app.use((req, _res, next) => {
        req.internalService = { name: 'external-rest-api' }
        next()
      })
      app.use(createExternalInvitationsRouter())
      app.use(createExternalAuthRouter({} as Parameters<typeof createExternalAuthRouter>[0]))
      app.use(
        (err: unknown, _req: express.Request, res: express.Response, _next: express.NextFunction) =>
          res.status(500).json({ error: 'unexpected_test_failure' })
      )
    }, 60_000)

    beforeEach(async () => {
      await holder.pool.query('DELETE FROM team_members')
      await holder.pool.query('DELETE FROM invitations')
      await holder.pool.query('DELETE FROM teams')
      await holder.pool.query('DELETE FROM users')
      await holder.pool.query('DELETE FROM rate_limit_buckets')
      await holder.pool.query('DELETE FROM password_identifier_state')
      await holder.pool.query('DELETE FROM password_verification_pace')
      userId = (
        await holder.pool.query(
          'INSERT INTO users(email, password_hash) VALUES ($1, $2) RETURNING id',
          [email, realHash]
        )
      ).rows[0].id
      await holder.pool.query(
        `INSERT INTO password_verification_pace(singleton, next_permit)
       VALUES (TRUE, clock_timestamp() + interval '1 minute')`
      )
    })

    afterAll(async () => {
      try {
        try {
          await memberRegistrationDb?.query(
            'DELETE FROM invitation_flow_registrations WHERE email = $1',
            [email]
          )
          holder.leaseClient?.release()
          await endPoolAndWaitForClients(holder.pool)
          if (admin) await admin.query(`DROP DATABASE IF EXISTS "${database}"`)
        } finally {
          await memberRegistrationDb?.end()
        }
      } finally {
        await admin?.end()
      }
    })

    it('recovers with the trusted signed proof while anonymous login pace is saturated', async () => {
      const deniedLogin = await request(app)
        .post('/external/auth/password-login')
        .set('x-external-client-ip', '192.0.2.155')
        .send({ email, password })
        .expect(429)
      expect(deniedLogin.body.error).toBe('rate_limited')

      const invitation = await createPasswordResetInvitation({
        inviteeName: 'Synthetic issue 1055 member',
        email,
      })
      const flowRows = await memberRegistrationDb.query(
        `SELECT invitation_jwt
         FROM invitation_flow_registrations
        WHERE email = $1 AND invitation_uuid = $2::uuid
        ORDER BY created_at DESC, id DESC
        LIMIT 1`,
        [email, invitation.token]
      )
      const proof = flowRows.rows[0]?.invitation_jwt
      expect(proof).toEqual(expect.any(String))

      const preview = await request(app)
        .get(`/external/invitations/token/${encodeURIComponent(proof)}`)
        .expect(200)
      expect(preview.body).toMatchObject({
        id: invitation.id,
        purpose: 'password_reset',
        status: 'pending',
      })
      expect(preview.body).not.toHaveProperty('token')

      const wrongEmail = await request(app)
        .post('/external/invitations/password-token')
        .send({
          email: '[email protected]',
          token: proof,
          invitationId: invitation.id,
          password: 'Synthetic-Issue1055-new-password',
        })
        .expect(400)
      expect(wrongEmail.body.error).toBe('invalid_invitation')

      const originalHash = (
        await holder.pool.query('SELECT password_hash FROM users WHERE id = $1', [userId])
      ).rows[0].password_hash
      const wrongRow = await request(app)
        .post('/external/invitations/password-token')
        .send({
          email,
          token: proof,
          invitationId: randomUUID(),
          password: 'Synthetic-Issue1055-new-password',
        })
        .expect(403)
      expect(wrongRow.body.error).toBe('forbidden')
      expect(
        (await holder.pool.query('SELECT password_hash FROM users WHERE id = $1', [userId])).rows[0]
          .password_hash
      ).toBe(originalHash)

      const attemptsBeforeRecovery = (
        await holder.pool.query(
          'SELECT attempts FROM password_identifier_state WHERE identifier_key = $1',
          [passwordIdentifierKey(email)]
        )
      ).rows[0].attempts
      const reset = await request(app)
        .post('/external/invitations/password-token')
        .send({
          email,
          token: proof,
          invitationId: invitation.id,
          password: 'Synthetic-Issue1055-new-password',
        })
        .expect(200)
      expect(reset.body.token).toEqual(expect.any(String))
      expect(reset.body).not.toHaveProperty('sessionContext')
      expect(
        (
          await holder.pool.query(
            'SELECT attempts FROM password_identifier_state WHERE identifier_key = $1',
            [passwordIdentifierKey(email)]
          )
        ).rows[0].attempts
      ).toEqual(attemptsBeforeRecovery)

      const authenticated = await request(app)
        .post('/external/auth/verify')
        .send({ token: reset.body.token })
        .expect(200)
      expect(authenticated.body.claims).toMatchObject({ userId, email })

      await holder.pool.query(
        "UPDATE password_verification_pace SET next_permit = clock_timestamp() - interval '1 second'"
      )
      const newPasswordLogin = await request(app)
        .post('/external/auth/password-login')
        .set('x-external-client-ip', '192.0.2.156')
        .send({ email, password: 'Synthetic-Issue1055-new-password' })
        .expect(200)
      expect(newPasswordLogin.body).toHaveProperty('token')
    }, 30_000)
  }
)