Skip to content

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.json
index 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.json
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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: string
instance: string
revision: string
+ expiresAt: number
user: 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.evaluationMs
await 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) t
WHERE 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.ts
index 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.ts
index 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 acceptance
beforeEach(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(
3
diff --git a/control-api/test/rp002.passwordCapture.realPostgres.integration.test.ts b/control-api/test/rp002.passwordCapture.realPostgres.integration.test.ts
new file mode 100644
index 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)
+ })
+})