Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
fix(auth): retain in-flight password evaluations (RP-002)
Josué0bad679f02d1
diff --git a/control-api/package-lock.json b/control-api/package-lock.jsonindex 758392154..5607f2eb2 100644--- a/control-api/package-lock.json+++ b/control-api/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-control-api",- "version": "0.1.730",+ "version": "0.1.731","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-control-api",- "version": "0.1.730",+ "version": "0.1.731","dependencies": {"@clerum/display-field": "file:../packages/display-field","@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract",diff --git a/control-api/package.json b/control-api/package.jsonindex 36fddb2cd..c518dfd37 100644--- a/control-api/package.json+++ b/control-api/package.json@@ -1,6 +1,6 @@{"name": "clerum-control-api",- "version": "0.1.730",+ "version": "0.1.731","description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets","main": "dist/main.js","engines": {diff --git a/control-api/src/db.ts b/control-api/src/db.tsindex b90487b9a..60dfa542e 100644--- a/control-api/src/db.ts+++ b/control-api/src/db.ts@@ -7,7 +7,10 @@ import {import { config } from './config.js'import { rootLogger } from './observability/logger.js'import { applyAdminSubscriptionRateLimitNamespace } from './services/adminSubscriptionRateLimitMigration.js'-import { applyPasswordAdmissionSchema } from './services/auth/passwordAdmissionSchema.js'+import {+ applyPasswordAdmissionSchema,+ applyPasswordEvaluationRetentionSchema,+} from './services/auth/passwordAdmissionSchema.js'import { applyCodexCatalogModelsSchema } from './services/codexSubscriptionCatalog.js'import {applyCodexChatgptAccountIdSchema,@@ -6337,6 +6340,10 @@ export const CONTROL_API_MIGRATIONS: DbMigration[] = [legacyVersions: ['0125_bug192_password_admission'],apply: applyPasswordAdmissionSchema,},+ {+ version: '0127_password_evaluation_retention',+ apply: applyPasswordEvaluationRetentionSchema,+ },]async function consolidateWorkflowAllowedUsersToTriggers(db: DbClient): Promise<void> {diff --git a/control-api/src/services/auth/passwordAdmissionSchema.ts b/control-api/src/services/auth/passwordAdmissionSchema.tsindex 0a78ffc8a..67670ec28 100644--- a/control-api/src/services/auth/passwordAdmissionSchema.ts+++ b/control-api/src/services/auth/passwordAdmissionSchema.ts@@ -1,4 +1,5 @@import type { DbClient } from '../../db.js'+import { PASSWORD_ADMISSION_POLICY } from './passwordAdmissionState.js'/** New forward migration; database triggers cover all credential/lifecycle producers. */export async function applyPasswordAdmissionSchema(db: Pick<DbClient, 'query'>): Promise<void> {@@ -52,3 +53,41 @@ export async function applyPasswordAdmissionSchema(db: Pick<DbClient, 'query'>):TO control_api_runtime;`)}++/** Forward capture retention, including deletion protection for older cleanup owners. */+export async function applyPasswordEvaluationRetentionSchema(+ db: Pick<DbClient, 'query'>+): Promise<void> {+ const lifetime = PASSWORD_ADMISSION_POLICY.evaluationMs+ await db.query(`+ ALTER TABLE password_identifier_state+ ADD COLUMN IF NOT EXISTS retained_until_ms BIGINT NOT NULL DEFAULT 0;+ UPDATE password_identifier_state+ SET retained_until_ms = greatest(retained_until_ms,+ floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint + ${lifetime});+ CREATE OR REPLACE FUNCTION password_evaluation_retention() RETURNS trigger+ LANGUAGE plpgsql SET search_path = pg_catalog, public AS $$+ DECLARE deadline bigint := floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint + ${lifetime};+ BEGIN+ IF TG_OP = 'DELETE' THEN+ IF OLD.retained_until_ms > deadline - ${lifetime} THEN RETURN NULL; END IF;+ RETURN OLD;+ END IF;+ IF TG_OP = 'INSERT' THEN+ NEW.retained_until_ms := greatest(NEW.retained_until_ms, deadline);+ ELSIF NEW.retained_until_ms = OLD.retained_until_ms+ AND NEW.revision = OLD.revision+ AND NEW.user_id IS NOT DISTINCT FROM OLD.user_id+ AND cardinality(NEW.failures) <= cardinality(OLD.failures)+ AND NEW.locked_until_ms <= OLD.locked_until_ms THEN+ -- Older capture producers write settled history without retention metadata.+ -- Retain those captures too; denials do not write and cannot extend retention.+ NEW.retained_until_ms := greatest(OLD.retained_until_ms, deadline);+ END IF;+ RETURN NEW;+ END $$;+ DROP TRIGGER IF EXISTS password_evaluation_retention ON password_identifier_state;+ CREATE TRIGGER password_evaluation_retention BEFORE INSERT OR UPDATE OR DELETE+ ON password_identifier_state FOR EACH ROW EXECUTE FUNCTION password_evaluation_retention();+ `)+}diff --git a/control-api/src/services/auth/passwordAdmissionState.ts b/control-api/src/services/auth/passwordAdmissionState.tsindex 1cb9460c8..4969846e2 100644--- a/control-api/src/services/auth/passwordAdmissionState.ts+++ b/control-api/src/services/auth/passwordAdmissionState.ts@@ -9,6 +9,7 @@ export const PASSWORD_ADMISSION_POLICY = Object.freeze({cooldownMs: 15 * 60_000,paceMs: 7_500,concurrency: 1,+ evaluationMs: 15 * 60_000,bcryptCost: 12,})diff --git a/control-api/src/services/auth/passwordCredentialVerification.ts b/control-api/src/services/auth/passwordCredentialVerification.tsindex f0715905d..c859025bb 100644--- a/control-api/src/services/auth/passwordCredentialVerification.ts+++ b/control-api/src/services/auth/passwordCredentialVerification.ts@@ -40,6 +40,7 @@ export type PasswordCapture = {key: stringinstance: stringrevision: string+ expiresAt: numberuser: PasswordUser | null}type StateRow = {@@ -79,14 +80,16 @@ export async function capturePasswordEvaluation([key])const row = result.rows[0] as StateRow- const decision = admitPasswordIdentifier(stateOf(row), await databaseNow(db), chargeAttempt)+ const now = await databaseNow(db)+ const decision = admitPasswordIdentifier(stateOf(row), now, chargeAttempt)// A denied request never writes: it cannot move the rolling denial horizon.if (decision.retryMs) return { retryMs: decision.retryMs, row }+ const expiresAt = now + policy.evaluationMsawait db.query(- 'UPDATE password_identifier_state SET attempts = $2, failures = $3, locked_until_ms = $4 WHERE identifier_key = $1',- [key, decision.state.attempts, decision.state.failures, decision.state.lockedUntil]+ 'UPDATE password_identifier_state SET attempts = $2, failures = $3, locked_until_ms = $4, retained_until_ms = greatest(retained_until_ms, $5) WHERE identifier_key = $1',+ [key, decision.state.attempts, decision.state.failures, decision.state.lockedUntil, expiresAt])- return { retryMs: 0, row }+ return { retryMs: 0, row, expiresAt }})if (snapshot.retryMs) denied(snapshot.retryMs)// No transaction or row lock survives into bcrypt.@@ -100,6 +103,7 @@ export async function capturePasswordEvaluation(key,instance: snapshot.row.instance,revision: String(snapshot.row.revision),+ expiresAt: snapshot.expiresAt!,user: (users.rows[0] as PasswordUser) ?? null,}}@@ -149,7 +153,9 @@ export async function completePasswordEvaluation(// Instance makes cleanup/recreation ABA-safe; revision fences stale results after success.if (!row || row.instance !== capture.instance || String(row.revision) !== capture.revision)return false- const state = finishPasswordState(stateOf(row), await databaseNow(db), success)+ const now = await databaseNow(db)+ if (now >= capture.expiresAt) return false+ const state = finishPasswordState(stateOf(row), now, success)await db.query(`UPDATE password_identifier_state SET failures = $2, locked_until_ms = $3,revision = revision + $4, user_id = $5 WHERE identifier_key = $1`,@@ -226,7 +232,8 @@ export async function verifyMemberPassword(export async function cleanupPasswordIdentifierState(): Promise<number> {const result = await pool.query(`DELETE FROM password_identifier_state- WHERE locked_until_ms <= floor(extract(epoch FROM clock_timestamp()) * 1000)+ WHERE retained_until_ms <= floor(extract(epoch FROM clock_timestamp()) * 1000)+ AND locked_until_ms <= floor(extract(epoch FROM clock_timestamp()) * 1000)AND NOT EXISTS (SELECT 1 FROM unnest(attempts || failures) tWHERE t > floor(extract(epoch FROM clock_timestamp()) * 1000) - $1)`,[policy.windowMs]diff --git a/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts b/control-api/test/bug192.passwordLogin.realPostgres.integration.test.tsindex af0f397c5..f5243eb3f 100644--- a/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts+++ b/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts@@ -96,6 +96,7 @@ realPg('BUG-192 observable password-login regressions on real PostgreSQL', () =>await holder.pool.query('DELETE FROM users')await holder.pool.query('DELETE FROM rate_limit_buckets')if (await newStateExists()) {+ await holder.pool.query('UPDATE password_identifier_state SET retained_until_ms=0')await holder.pool.query('DELETE FROM password_identifier_state')await holder.pool.query('DELETE FROM password_verification_pace')}diff --git a/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts b/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.tsindex 1da1783b4..688c22ef0 100644--- a/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts+++ b/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts@@ -70,6 +70,7 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptancebeforeEach(async () => {vi.restoreAllMocks()await holder.pool.query('DELETE FROM users')+ await holder.pool.query('UPDATE password_identifier_state SET retained_until_ms=0')await holder.pool.query('DELETE FROM password_identifier_state')await holder.pool.query('DELETE FROM password_verification_pace')userId = (@@ -348,6 +349,10 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance)}const old = await capturePasswordEvaluation('[email protected]', false)+ await holder.pool.query(+ 'UPDATE password_identifier_state SET retained_until_ms=0 WHERE identifier_key=$1',+ [passwordIdentifierKey('[email protected]')]+ )expect(await cleanupPasswordIdentifierState()).toBe(1)expect((await holder.pool.query('SELECT * FROM password_identifier_state')).rows).toHaveLength(3diff --git a/control-api/test/rp002.passwordCapture.realPostgres.integration.test.ts b/control-api/test/rp002.passwordCapture.realPostgres.integration.test.tsnew file mode 100644index 000000000..bd4480e67--- /dev/null+++ b/control-api/test/rp002.passwordCapture.realPostgres.integration.test.ts@@ -0,0 +1,214 @@+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'+import bcrypt from 'bcryptjs'+import { randomBytes } from 'node:crypto'+import { Pool } from 'pg'+import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'++const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL+const realPg = adminUrl ? describe : describe.skip+const password = 'Synthetic-RP002-correct-password'+const email = '[email protected]'+const realCompare = bcrypt.compare.bind(bcrypt)+realPg('RP-002 durable credential evaluation lifetime', () => {+ const database = `rp002_${randomBytes(6).toString('hex')}`+ let admin: Pool+ let db: typeof import('../src/db.js')+ let engine: typeof import('../src/services/auth/passwordCredentialVerification.js')+ let login: typeof import('../src/services/directory/login.js')+ let userId: string+ let hash: string+ beforeAll(async () => {+ admin = new Pool({ connectionString: adminUrl })+ await admin.query(`CREATE DATABASE "${database}"`)+ const url = new URL(adminUrl!)+ url.pathname = `/${database}`+ vi.stubEnv('CONTROL_API_PG_CONNECTION_STRING', url.toString())+ vi.stubEnv('CORE_POOL_MAX', '2')+ vi.resetModules()+ db = await import('../src/db.js')+ await db.initDb()+ engine = await import('../src/services/auth/passwordCredentialVerification.js')+ login = await import('../src/services/directory/login.js')+ hash = await bcrypt.hash(password, 12)+ }, 60_000)+ beforeEach(async () => {+ vi.restoreAllMocks()+ await db.pool.query('TRUNCATE password_identifier_state, password_verification_pace')+ await db.pool.query('DELETE FROM users')+ userId = String(+ (+ await db.pool.query('INSERT INTO users(email,password_hash) VALUES ($1,$2) RETURNING id', [+ email,+ hash,+ ])+ ).rows[0].id+ )+ })+ afterAll(async () => {+ try {+ vi.restoreAllMocks()+ if (db) {+ await endPoolAndWaitForClients(db.pool)+ await endPoolAndWaitForClients(db.rateLimitPool)+ }+ if (admin) await admin.query(`DROP DATABASE "${database}"`)+ } finally {+ await admin?.end()+ vi.unstubAllEnvs()+ }+ })+ async function withHeldComparison(work: () => Promise<void>) {+ let entered!: () => void, release!: () => void+ const started = new Promise<void>(resolve => {+ entered = resolve+ })+ const held = new Promise<void>(resolve => {+ release = resolve+ })+ vi.spyOn(bcrypt, 'compare').mockImplementation(async (submitted: string, stored: string) => {+ entered()+ await held+ return realCompare(submitted, stored)+ })+ const verification = login.verifyUserPassword({ userId, email, password })+ try {+ await started+ await work()+ } finally {+ release()+ }+ return verification+ }+ it('completes correct Desktop verification when real cleanup runs during bcrypt', async () => {+ const result = await withHeldComparison(async () => {+ await engine.cleanupPasswordIdentifierState()+ })+ expect(result).toBe(true)+ })+ it('protects an admitted capture from an older cleanup SQL owner', async () => {+ const result = await withHeldComparison(async () => {+ await db.pool.query(`DELETE FROM password_identifier_state+ WHERE locked_until_ms <= floor(extract(epoch FROM clock_timestamp()) * 1000)+ AND NOT EXISTS (SELECT 1 FROM unnest(attempts || failures) t+ WHERE t > floor(extract(epoch FROM clock_timestamp()) * 1000) - 900000)`)+ })+ expect(result).toBe(true)+ })+ it('rejects an expired producer capture without adding a failure', async () => {+ const transaction = db.withTransaction+ vi.spyOn(db, 'withTransaction').mockImplementation(work =>+ transaction(async client => {+ const query = client.query.bind(client)+ return work({+ ...client,+ query: (sql: string, values?: unknown[]) =>+ sql.includes('AS now_ms')+ ? query(+ sql.replace('clock_timestamp()', "clock_timestamp() - interval '16 minutes'"),+ values+ )+ : query(sql, values),+ })+ })+ )+ const capture = await engine.capturePasswordEvaluation(email, false)+ vi.restoreAllMocks()+ expect(await engine.completePasswordEvaluation(capture, false)).toBe(false)+ expect(+ (await db.pool.query('SELECT failures FROM password_identifier_state')).rows[0].failures+ ).toEqual([])+ })+ it('still rejects credential changes during a retained verification', async () => {+ const result = await withHeldComparison(async () => {+ await db.pool.query('UPDATE users SET password_hash=$2 WHERE id=$1', [+ userId,+ await bcrypt.hash('Synthetic-replacement', 12),+ ])+ await engine.cleanupPasswordIdentifierState()+ })+ expect(result).toBe(false)+ expect(+ (await db.pool.query('SELECT failures,locked_until_ms FROM password_identifier_state'))+ .rows[0]+ ).toMatchObject({ failures: [], locked_until_ms: '0' })+ })+ it('keeps later captures retained when an earlier one completes', async () => {+ const first = await engine.capturePasswordEvaluation(email, false)+ const second = await engine.capturePasswordEvaluation(email, false)+ expect(await engine.completePasswordEvaluation(first, false)).toBe(true)+ await engine.cleanupPasswordIdentifierState()+ expect(await engine.completePasswordEvaluation(second, false)).toBe(true)+ expect(+ (await db.pool.query('SELECT failures FROM password_identifier_state')).rows[0].failures+ ).toHaveLength(2)+ })+ it('preserves success revision fencing against an older failed result', async () => {+ const failure = await engine.capturePasswordEvaluation(email, false)+ const success = await engine.capturePasswordEvaluation(email, false)+ expect(await engine.completePasswordEvaluation(success, true)).toBe(true)+ expect(await engine.completePasswordEvaluation(failure, false)).toBe(false)+ expect(+ (await db.pool.query('SELECT failures FROM password_identifier_state')).rows[0].failures+ ).toEqual([])+ })+ it('expires retention naturally without deleting active history or cooldown', async () => {+ for (const identity of ['empty', 'attempt', 'failure', 'cooldown']) {+ const capture = await engine.capturePasswordEvaluation(`${identity}@example.invalid`, false)+ if (identity === 'failure' || identity === 'cooldown')+ await engine.completePasswordEvaluation(capture, false)+ if (identity === 'attempt')+ await engine.capturePasswordEvaluation(`${identity}@example.invalid`, true)+ if (identity === 'cooldown') {+ for (let i = 1; i < 5; i++) {+ const next = await engine.capturePasswordEvaluation(`${identity}@example.invalid`, false)+ await engine.completePasswordEvaluation(next, false)+ }+ }+ }+ await db.pool.query('UPDATE password_identifier_state SET retained_until_ms=0')+ expect(await engine.cleanupPasswordIdentifierState()).toBe(1)+ expect(+ (await db.pool.query('SELECT identifier_key FROM password_identifier_state')).rows+ ).toHaveLength(3)+ })+ it('rejects old instance completion after expired retention cleanup and recreation', async () => {+ const old = await engine.capturePasswordEvaluation(email, false)+ await db.pool.query('UPDATE password_identifier_state SET retained_until_ms=0')+ expect(await engine.cleanupPasswordIdentifierState()).toBe(1)+ await engine.capturePasswordEvaluation(email, false)+ expect(await engine.completePasswordEvaluation(old, false)).toBe(false)+ expect(+ (await db.pool.query('SELECT failures FROM password_identifier_state')).rows[0].failures+ ).toEqual([])+ })+ it('pins a legacy capture update and permits cleanup after its deadline', async () => {+ await engine.capturePasswordEvaluation(email, false)+ await db.pool.query('UPDATE password_identifier_state SET retained_until_ms=0')+ // This is the exact legacy producer shape: settled histories but no retention field.+ await db.pool.query(+ 'UPDATE password_identifier_state SET attempts=$1,failures=$2,locked_until_ms=$3',+ [[], [], 0]+ )+ await db.pool.query('DELETE FROM password_identifier_state')+ expect((await db.pool.query('SELECT * FROM password_identifier_state')).rows).toHaveLength(1)+ await db.pool.query('UPDATE password_identifier_state SET retained_until_ms=0')+ await db.pool.query('DELETE FROM password_identifier_state')+ expect((await db.pool.query('SELECT * FROM password_identifier_state')).rows).toHaveLength(0)+ })+ it('backfills existing captures and applies the forward migration idempotently', async () => {+ await engine.capturePasswordEvaluation(email, false)+ const schema = await import('../src/services/auth/passwordAdmissionSchema.js')+ await db.pool.query('DROP TRIGGER password_evaluation_retention ON password_identifier_state')+ await db.pool.query('ALTER TABLE password_identifier_state DROP COLUMN retained_until_ms')+ await schema.applyPasswordEvaluationRetentionSchema(db.pool)+ await schema.applyPasswordEvaluationRetentionSchema(db.pool)+ await db.pool.query('DELETE FROM password_identifier_state')+ expect((await db.pool.query('SELECT * FROM password_identifier_state')).rows).toHaveLength(1)+ expect(+ await engine.completePasswordEvaluation(+ await engine.capturePasswordEvaluation(email, false),+ true+ )+ ).toBe(true)+ })+})