Skip to content

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

TypeScript

fix(control-api): audit MCP Secret creation without logging values

Jose Ramirez6a2e1f647feb
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index be373522a..d55acd55d 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.522",
+ "version": "0.1.523",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.522",
+ "version": "0.1.523",
"dependencies": {
"@clerum/display-field": "file:../packages/display-field",
"@clerum/image-policy": "file:../packages/image-policy",
diff --git a/control-api/package.json b/control-api/package.json
index f1c4b8132..738922c09 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.522",
+ "version": "0.1.523",
"description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets",
"main": "dist/main.js",
"engines": {
diff --git a/control-api/src/routes/admin/secrets.ts b/control-api/src/routes/admin/secrets.ts
index 3224fa2f2..0169b7062 100644
--- a/control-api/src/routes/admin/secrets.ts
+++ b/control-api/src/routes/admin/secrets.ts
@@ -3,6 +3,7 @@ import { PROVIDER_CREDENTIAL_SLOTS } from '@clerum/llm-providers'
import { EVENFIRE_REGISTRY_PULL_SECRET_NAME } from '@clerum/workflow-runtime-core'
import { config } from '../../config.js'
import { asyncHandler } from '../../http/asyncHandler.js'
+import { extractK8sError } from '../../http/k8sError.js'
import { enforceNamespace } from '../../http/namespaceAudit.js'
import { isValidDNSSubdomain } from '../../http/rfc1123.js'
import { K8sGateway, extractHttpStatus } from '../../k8s.js'
@@ -138,6 +139,14 @@ async function findFallbackCredentialReferences(
return listFallbackCredentialReferences(hosts, secretName)
}
+function auditErrorFields(err: unknown): { name: string; message: string } {
+ const k8sErr = extractK8sError(err)
+ return {
+ name: err instanceof Error ? err.name : typeof err,
+ message: k8sErr?.message ?? (err instanceof Error ? err.message : String(err)),
+ }
+}
+
function secretWriteKeys(body: unknown): Set<string> {
const keys = new Set<string>()
const record = asRecord(body)
@@ -513,7 +522,37 @@ export function createAdminSecretsRouter(gateway: K8sGateway): Router {
stringData: data,
}
- await gateway.createSecret(secretReq)
+ // Key NAMES are safe to log; values never are. Emit after the write
+ // succeeds (a create that happened must never go unlogged) and on the
+ // failed write path so operators can still reconstruct the attempt.
+ const createdKeys = Object.keys(data).sort((a, b) => a.localeCompare(b))
+ try {
+ await gateway.createSecret(secretReq)
+ } catch (err) {
+ logger.warn(
+ {
+ module: 'admin-secrets',
+ event: 'mcp-secret-create-failed',
+ name: name.trim(),
+ namespace: targetNs,
+ createdKeys,
+ err: auditErrorFields(err),
+ },
+ 'MCP Secret create failed'
+ )
+ throw err
+ }
+
+ logger.info(
+ {
+ module: 'admin-secrets',
+ event: 'mcp-secret-created',
+ name: name.trim(),
+ namespace: targetNs,
+ createdKeys,
+ },
+ 'MCP Secret created'
+ )
res.status(201).json({ name: name.trim(), namespace: targetNs, created: true })
})
)
diff --git a/control-api/test/routes.mcpSecrets.test.ts b/control-api/test/routes.mcpSecrets.test.ts
index 8304d7308..ba0720c15 100644
--- a/control-api/test/routes.mcpSecrets.test.ts
+++ b/control-api/test/routes.mcpSecrets.test.ts
@@ -1,5 +1,6 @@
import { describe, expect, it, vi } from 'vitest'
import express from 'express'
+import { ApiException } from '@kubernetes/client-node'
import request from 'supertest'
import { rootLogger } from '../src/observability/logger.js'
import { createAdminSecretsRouter } from '../src/routes/admin/secrets.js'
@@ -360,6 +361,160 @@ describe('POST /admin/mcp-secrets', () => {
expect(res.body.error).toContain('K8s API timeout')
})
+
+ // ── Audit: create must be logged like rotate (R3-M2) ────────────────────
+ // A rotation that actually happened must never go unlogged; the same is
+ // now true of create, because the connector screen is a primary credential-
+ // creation path. Key NAMES are safe to log; values never are.
+
+ it('emits mcp-secret-created with name, namespace, and sorted key names only', async () => {
+ const gateway = createGateway()
+ const infoSpy = vi.spyOn(rootLogger, 'info').mockImplementation(() => {})
+ const app = makeApp(gateway)
+ const credentialValue = 'never-log-this-secret-value'
+
+ try {
+ await request(app)
+ .post('/admin/mcp-secrets')
+ .send({
+ name: 'web-research-credentials',
+ data: { SEARCH_API_KEY: credentialValue, GITHUB_TOKEN: credentialValue },
+ })
+ .expect(201)
+
+ expect(infoSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ module: 'admin-secrets',
+ event: 'mcp-secret-created',
+ name: 'web-research-credentials',
+ namespace: 'mcp-server',
+ createdKeys: ['GITHUB_TOKEN', 'SEARCH_API_KEY'],
+ }),
+ 'MCP Secret created'
+ )
+ const serialized = JSON.stringify(infoSpy.mock.calls)
+ expect(serialized).not.toContain(credentialValue)
+ expect(serialized).not.toContain(Buffer.from(credentialValue, 'utf8').toString('base64'))
+ } finally {
+ infoSpy.mockRestore()
+ }
+ })
+
+ it('emits mcp-secret-create-failed with the same names-only fields when createSecret throws', async () => {
+ const gateway = createGateway()
+ gateway.createSecret.mockRejectedValueOnce(new Error('K8s API timeout'))
+ const infoSpy = vi.spyOn(rootLogger, 'info').mockImplementation(() => {})
+ const warnSpy = vi.spyOn(rootLogger, 'warn').mockImplementation(() => {})
+ const app = makeApp(gateway)
+ const credentialValue = 'never-log-this-failed-secret'
+
+ try {
+ await request(app)
+ .post('/admin/mcp-secrets')
+ .send({ name: 'fail-secret', data: { SEARCH_API_KEY: credentialValue } })
+ .expect(500)
+
+ expect(infoSpy).not.toHaveBeenCalledWith(
+ expect.objectContaining({ event: 'mcp-secret-created' }),
+ expect.anything()
+ )
+ expect(warnSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ module: 'admin-secrets',
+ event: 'mcp-secret-create-failed',
+ name: 'fail-secret',
+ namespace: 'mcp-server',
+ createdKeys: ['SEARCH_API_KEY'],
+ err: { name: 'Error', message: 'K8s API timeout' },
+ }),
+ 'MCP Secret create failed'
+ )
+ const serialized = JSON.stringify([...infoSpy.mock.calls, ...warnSpy.mock.calls])
+ expect(serialized).not.toContain(credentialValue)
+ expect(serialized).not.toContain(Buffer.from(credentialValue, 'utf8').toString('base64'))
+ } finally {
+ infoSpy.mockRestore()
+ warnSpy.mockRestore()
+ }
+ })
+
+ it('does not log ApiException headers when createSecret hits AlreadyExists', async () => {
+ const gateway = createGateway()
+ const body = {
+ kind: 'Status',
+ apiVersion: 'v1',
+ status: 'Failure',
+ message: 'secrets "fail-secret" already exists',
+ reason: 'AlreadyExists',
+ code: 409,
+ }
+ const headers = {
+ 'audit-id': 'a1b2c3-secret-audit-uuid',
+ 'x-kubernetes-pf-flowschema-uid': 'internal-flowschema-uid',
+ 'content-type': 'application/json',
+ }
+ const err = new ApiException(409, 'Conflict', body, headers)
+ expect(err.message).toContain('Headers:')
+ expect(err.message).toContain('audit-id')
+ gateway.createSecret.mockRejectedValueOnce(err)
+ const warnSpy = vi.spyOn(rootLogger, 'warn').mockImplementation(() => {})
+ const app = makeApp(gateway)
+
+ try {
+ await request(app)
+ .post('/admin/mcp-secrets')
+ .send({ name: 'fail-secret', data: { SEARCH_API_KEY: 'never-log-this-secret-value' } })
+ .expect(500)
+
+ expect(warnSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ event: 'mcp-secret-create-failed',
+ name: 'fail-secret',
+ createdKeys: ['SEARCH_API_KEY'],
+ }),
+ 'MCP Secret create failed'
+ )
+ const serialized = JSON.stringify(warnSpy.mock.calls)
+ expect(serialized).not.toContain('Headers:')
+ expect(serialized).not.toContain('audit-id')
+ expect(serialized).not.toContain('x-kubernetes-pf')
+ expect(serialized).not.toContain('never-log-this-secret-value')
+ expect(warnSpy.mock.calls[0][0]).toEqual(
+ expect.objectContaining({
+ err: { name: 'Error', message: 'secrets "fail-secret" already exists' },
+ })
+ )
+ } finally {
+ warnSpy.mockRestore()
+ }
+ })
+
+ it('does not emit a create audit when validation rejects the request', async () => {
+ const gateway = createGateway()
+ const infoSpy = vi.spyOn(rootLogger, 'info').mockImplementation(() => {})
+ const warnSpy = vi.spyOn(rootLogger, 'warn').mockImplementation(() => {})
+ const app = makeApp(gateway)
+
+ try {
+ await request(app)
+ .post('/admin/mcp-secrets')
+ .send({ name: 'my-secret', data: {} })
+ .expect(400)
+
+ expect(gateway.createSecret).not.toHaveBeenCalled()
+ expect(infoSpy).not.toHaveBeenCalledWith(
+ expect.objectContaining({ event: 'mcp-secret-created' }),
+ expect.anything()
+ )
+ expect(warnSpy).not.toHaveBeenCalledWith(
+ expect.objectContaining({ event: 'mcp-secret-create-failed' }),
+ expect.anything()
+ )
+ } finally {
+ infoSpy.mockRestore()
+ warnSpy.mockRestore()
+ }
+ })
})
describe('DELETE /admin/mcp-secrets/:name', () => {