Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
feat: implemented oauth dynamic secret backend
=3fddda9ac6fd
diff --git a/backend/CLAUDE.md b/backend/CLAUDE.mdindex da8c0f6107..356dba3d88 100644--- a/backend/CLAUDE.md+++ b/backend/CLAUDE.md@@ -884,6 +884,8 @@ EE routes register before community routes so they can override/extend endpoints**Agent Vault**: the same applies to the `agent-vault-*` services and routers; the concept map is [`src/ee/services/agent-vault/CLAUDE.md`](src/ee/services/agent-vault/CLAUDE.md). PAM and Agent Vault are the two **org-scoped products**: one implicit project per org, resolved lazily, whose roles collapse to admin or member. Anything that branches on `ProjectType.PAM` (metering emits, predefined roles, the billable-project count, invite grants) almost always needs an Agent Vault arm too.+**Dynamic secret lease secrets needed at revoke time go in `dynamic_secret_leases.encryptedLeaseData`**, never in `externalEntityId` or `config` (both plaintext, and `externalEntityId` is returned by every lease route and logged in audit events). A provider opts in by listing the `create()` `data` keys in `persistedLeaseFields`; the lease service encrypts them with the project's SecretManager key and every revoke path passes them back as `metadata.leaseData`. Lease routes return `SanitizedDynamicSecretLeaseSchema` so the column never reaches a response. Secret *config* fields are listed separately in `DYNAMIC_SECRET_SECRET_FIELDS` (`providers/redact.ts`), as dotted paths so nested secrets work (`clientAuth.clientSecret`): reads strip them via `redactStoredInputs`, and an update that omits one keeps the stored value via `restoreOmittedSecretFields`, because the update merge is shallow.+**Gateways: there is only one generation.** Gateway v1 (`ee/services/gateway`, `lib/gateway`, the QUICtransport over `@infisical/quic`, and `/api/v1/gateways`) is gone; `gateway-v2` and `gateway-pool` are thewhole story, and `lib/gateway-v2/types.ts` owns `GatewayProxyProtocol` / `GatewayHttpProxyActions`. Whatdiff --git a/backend/src/db/migrations/20260925120000_add-dynamic-secret-lease-encrypted-data.ts b/backend/src/db/migrations/20260925120000_add-dynamic-secret-lease-encrypted-data.tsnew file mode 100644index 0000000000..5e192f87a7--- /dev/null+++ b/backend/src/db/migrations/20260925120000_add-dynamic-secret-lease-encrypted-data.ts@@ -0,0 +1,23 @@+import { Knex } from "knex";++import { TableName } from "../schemas";++export async function up(knex: Knex): Promise<void> {+ const hasEncryptedLeaseData = await knex.schema.hasColumn(TableName.DynamicSecretLease, "encryptedLeaseData");++ if (!hasEncryptedLeaseData) {+ await knex.schema.alterTable(TableName.DynamicSecretLease, (t) => {+ t.binary("encryptedLeaseData").nullable();+ });+ }+}++export async function down(knex: Knex): Promise<void> {+ const hasEncryptedLeaseData = await knex.schema.hasColumn(TableName.DynamicSecretLease, "encryptedLeaseData");++ if (hasEncryptedLeaseData) {+ await knex.schema.alterTable(TableName.DynamicSecretLease, (t) => {+ t.dropColumn("encryptedLeaseData");+ });+ }+}diff --git a/backend/src/db/schemas/dynamic-secret-leases.ts b/backend/src/db/schemas/dynamic-secret-leases.tsindex ef16b1a301..3c3f7deb2b 100644--- a/backend/src/db/schemas/dynamic-secret-leases.ts+++ b/backend/src/db/schemas/dynamic-secret-leases.ts@@ -5,6 +5,8 @@import { z } from "zod";+import { zodBuffer } from "@app/lib/zod";+import { TImmutableDBKeys } from "./models";export const DynamicSecretLeasesSchema = z.object({@@ -17,7 +19,8 @@ export const DynamicSecretLeasesSchema = z.object({dynamicSecretId: z.string().uuid(),createdAt: z.date(),updatedAt: z.date(),- config: z.unknown().nullable().optional()+ config: z.unknown().nullable().optional(),+ encryptedLeaseData: zodBuffer.nullable().optional()});export type TDynamicSecretLeases = z.infer<typeof DynamicSecretLeasesSchema>;diff --git a/backend/src/ee/routes/v1/dynamic-secret-lease-router.ts b/backend/src/ee/routes/v1/dynamic-secret-lease-router.tsindex eafe1ede78..942635642e 100644--- a/backend/src/ee/routes/v1/dynamic-secret-lease-router.ts+++ b/backend/src/ee/routes/v1/dynamic-secret-lease-router.ts@@ -1,6 +1,5 @@import { z } from "zod";-import { DynamicSecretLeasesSchema } from "@app/db/schemas";import { EventType } from "@app/ee/services/audit-log/audit-log-types";import { ApiDocsTags, DYNAMIC_SECRET_LEASES } from "@app/lib/api-docs";import { removeTrailingSlash } from "@app/lib/fn";@@ -8,7 +7,7 @@ import { ms } from "@app/lib/ms";import { readLimit, writeLimit } from "@app/server/config/rateLimiter";import { getTelemetryDistinctId } from "@app/server/lib/telemetry";import { verifyAuth } from "@app/server/plugins/auth/verify-auth";-import { SanitizedDynamicSecretSchema } from "@app/server/routes/sanitizedSchemas";+import { SanitizedDynamicSecretLeaseSchema, SanitizedDynamicSecretSchema } from "@app/server/routes/sanitizedSchemas";import { AuthMode } from "@app/services/auth/auth-type";import { PostHogEventTypes } from "@app/services/telemetry/telemetry-types";@@ -43,7 +42,7 @@ export const registerDynamicSecretLeaseRouter = async (server: FastifyZodProvide}),response: {200: z.object({- lease: DynamicSecretLeasesSchema,+ lease: SanitizedDynamicSecretLeaseSchema,dynamicSecret: SanitizedDynamicSecretSchema,data: z.unknown()})@@ -126,7 +125,7 @@ export const registerDynamicSecretLeaseRouter = async (server: FastifyZodProvide}),response: {200: z.object({- lease: DynamicSecretLeasesSchema+ lease: SanitizedDynamicSecretLeaseSchema})}},@@ -218,7 +217,7 @@ export const registerDynamicSecretLeaseRouter = async (server: FastifyZodProvide}),response: {200: z.object({- lease: DynamicSecretLeasesSchema+ lease: SanitizedDynamicSecretLeaseSchema})}},@@ -297,7 +296,7 @@ export const registerDynamicSecretLeaseRouter = async (server: FastifyZodProvide}),response: {200: z.object({- lease: DynamicSecretLeasesSchema.extend({+ lease: SanitizedDynamicSecretLeaseSchema.extend({dynamicSecret: SanitizedDynamicSecretSchema})})diff --git a/backend/src/ee/routes/v1/dynamic-secret-lease-routers/kubernetes-lease-router.ts b/backend/src/ee/routes/v1/dynamic-secret-lease-routers/kubernetes-lease-router.tsindex 30de7f08a3..d0170b1980 100644--- a/backend/src/ee/routes/v1/dynamic-secret-lease-routers/kubernetes-lease-router.ts+++ b/backend/src/ee/routes/v1/dynamic-secret-lease-routers/kubernetes-lease-router.ts@@ -1,12 +1,11 @@import { z } from "zod";-import { DynamicSecretLeasesSchema } from "@app/db/schemas";import { ApiDocsTags, DYNAMIC_SECRET_LEASES } from "@app/lib/api-docs";import { removeTrailingSlash } from "@app/lib/fn";import { ms } from "@app/lib/ms";import { writeLimit } from "@app/server/config/rateLimiter";import { verifyAuth } from "@app/server/plugins/auth/verify-auth";-import { SanitizedDynamicSecretSchema } from "@app/server/routes/sanitizedSchemas";+import { SanitizedDynamicSecretLeaseSchema, SanitizedDynamicSecretSchema } from "@app/server/routes/sanitizedSchemas";import { AuthMode } from "@app/services/auth/auth-type";export const registerKubernetesDynamicSecretLeaseRouter = async (server: FastifyZodProvider) => {@@ -44,7 +43,7 @@ export const registerKubernetesDynamicSecretLeaseRouter = async (server: Fastify}),response: {200: z.object({- lease: DynamicSecretLeasesSchema,+ lease: SanitizedDynamicSecretLeaseSchema,dynamicSecret: SanitizedDynamicSecretSchema,data: z.unknown()})diff --git a/backend/src/ee/routes/v1/dynamic-secret-router.ts b/backend/src/ee/routes/v1/dynamic-secret-router.tsindex 2f619c3dbb..b927370b61 100644--- a/backend/src/ee/routes/v1/dynamic-secret-router.ts+++ b/backend/src/ee/routes/v1/dynamic-secret-router.ts@@ -1,6 +1,5 @@import { z } from "zod";-import { DynamicSecretLeasesSchema } from "@app/db/schemas";import { EventType } from "@app/ee/services/audit-log/audit-log-types";import { DynamicSecretProviderSchema } from "@app/ee/services/dynamic-secret/providers/models";import { ApiDocsTags, DYNAMIC_SECRETS } from "@app/lib/api-docs";@@ -12,7 +11,7 @@ import { readLimit, writeLimit } from "@app/server/config/rateLimiter";import { slugSchema } from "@app/server/lib/schemas";import { getTelemetryDistinctId } from "@app/server/lib/telemetry";import { verifyAuth } from "@app/server/plugins/auth/verify-auth";-import { SanitizedDynamicSecretSchema } from "@app/server/routes/sanitizedSchemas";+import { SanitizedDynamicSecretLeaseSchema, SanitizedDynamicSecretSchema } from "@app/server/routes/sanitizedSchemas";import { AuthMode } from "@app/services/auth/auth-type";import { ResourceMetadataNonEncryptionSchema } from "@app/services/resource-metadata/resource-metadata-schema";import { PostHogEventTypes } from "@app/services/telemetry/telemetry-types";@@ -446,7 +445,7 @@ export const registerDynamicSecretRouter = async (server: FastifyZodProvider) =>}),response: {200: z.object({- leases: DynamicSecretLeasesSchema.array()+ leases: SanitizedDynamicSecretLeaseSchema.array()})}},diff --git a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-dal.ts b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-dal.tsindex bf2e8169a3..7694a8f457 100644--- a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-dal.ts+++ b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-dal.ts@@ -37,6 +37,7 @@ export interface TDynamicSecretLeaseDALFactory extends Omit<TOrmify<TableName.Dystatus?: string | null | undefined;config?: unknown;statusDetails?: string | null | undefined;+ encryptedLeaseData?: Buffer | null | undefined;}| undefined>;diff --git a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-fns.ts b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-fns.tsnew file mode 100644index 0000000000..855910b6ba--- /dev/null+++ b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-fns.ts@@ -0,0 +1,23 @@+import { z } from "zod";++const LeaseDataSchema = z.record(z.string());++export const pickPersistedLeaseData = (data: unknown, fields: string[]): Record<string, string> => {+ const source = data && typeof data === "object" ? (data as Record<string, unknown>) : {};+ return Object.fromEntries(+ fields.flatMap((field) => {+ const value = source[field];+ return typeof value === "string" ? [[field, value]] : [];+ })+ );+};++export const decryptLeaseData = (+ decryptor: (dto: { cipherTextBlob: Buffer }) => Buffer,+ encryptedLeaseData?: Buffer | null+): Record<string, string> | undefined => {+ if (!encryptedLeaseData) return undefined;+ return LeaseDataSchema.parse(+ JSON.parse(decryptor({ cipherTextBlob: Buffer.from(encryptedLeaseData) }).toString()) as unknown+ );+};diff --git a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-queue.ts b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-queue.tsindex dd20c9c7ff..b86519d27c 100644--- a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-queue.ts+++ b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-queue.ts@@ -18,6 +18,7 @@ import { TDynamicSecretDALFactory } from "../dynamic-secret/dynamic-secret-dal";import { DynamicSecretStatus } from "../dynamic-secret/dynamic-secret-types";import { DynamicSecretProviders, TDynamicProviderFns } from "../dynamic-secret/providers/models";import { TDynamicSecretLeaseDALFactory } from "./dynamic-secret-lease-dal";+import { decryptLeaseData } from "./dynamic-secret-lease-fns";import { TDynamicSecretLeaseConfig } from "./dynamic-secret-lease-types";type TDynamicSecretLeaseQueueServiceFactoryDep = {@@ -171,9 +172,15 @@ export const dynamicSecretLeaseQueueServiceFactory = ({secretManagerDecryptor({ cipherTextBlob: dynamicSecretCfg.encryptedInput }).toString()) as object;- await selectedProvider.revoke(decryptedStoredInput, dynamicSecretLease.externalEntityId, {- projectId: folder.projectId- });+ await selectedProvider.revoke(+ decryptedStoredInput,+ dynamicSecretLease.externalEntityId,+ {+ projectId: folder.projectId,+ leaseData: decryptLeaseData(secretManagerDecryptor, dynamicSecretLease.encryptedLeaseData)+ },+ dynamicSecretLease.config as TDynamicSecretLeaseConfig+ );await dynamicSecretLeaseDAL.deleteById(dynamicSecretLease.id);return;}@@ -212,12 +219,13 @@ export const dynamicSecretLeaseQueueServiceFactory = ({await Promise.all(dynamicSecretLeases.map(({ id }) => unsetLeaseRevocation(id)));await Promise.all(- dynamicSecretLeases.map(({ externalEntityId, config }) =>+ dynamicSecretLeases.map(({ externalEntityId, config, encryptedLeaseData }) =>selectedProvider.revoke(decryptedStoredInput,externalEntityId,{- projectId: folder.projectId+ projectId: folder.projectId,+ leaseData: decryptLeaseData(secretManagerDecryptor, encryptedLeaseData)},config as TDynamicSecretLeaseConfig)diff --git a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-service.ts b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-service.tsindex ff5f3ec3c2..685a26eb64 100644--- a/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-service.ts+++ b/backend/src/ee/services/dynamic-secret-lease/dynamic-secret-lease-service.ts@@ -29,6 +29,7 @@ import { TDynamicSecretDALFactory } from "../dynamic-secret/dynamic-secret-dal";import { DynamicSecretProviders, TDynamicProviderFns } from "../dynamic-secret/providers/models";import { toSafeUsername } from "../dynamic-secret/providers/templateUtils";import { TDynamicSecretLeaseDALFactory } from "./dynamic-secret-lease-dal";+import { decryptLeaseData, pickPersistedLeaseData } from "./dynamic-secret-lease-fns";import { TDynamicSecretLeaseQueueServiceFactory } from "./dynamic-secret-lease-queue";import {DynamicSecretLeaseStatus,@@ -131,10 +132,11 @@ export const dynamicSecretLeaseServiceFactory = ({const selectedProvider = dynamicSecretProviders[dynamicSecretCfg.type as DynamicSecretProviders];- const { decryptor: secretManagerDecryptor } = await kmsService.createCipherPairWithDataKey({- type: KmsDataKey.SecretManager,- projectId- });+ const { encryptor: secretManagerEncryptor, decryptor: secretManagerDecryptor } =+ await kmsService.createCipherPairWithDataKey({+ type: KmsDataKey.SecretManager,+ projectId+ });const decryptedStoredInput = JSON.parse(secretManagerDecryptor({ cipherTextBlob: Buffer.from(dynamicSecretCfg.encryptedInput) }).toString()@@ -199,13 +201,34 @@ export const dynamicSecretLeaseServiceFactory = ({}const { entityId, data } = result;- const dynamicSecretLease = await dynamicSecretLeaseDAL.create({- expireAt,- version: 1,- dynamicSecretId: dynamicSecretCfg.id,- externalEntityId: entityId,- config- });+ const leaseData = selectedProvider.persistedLeaseFields?.length+ ? pickPersistedLeaseData(data, selectedProvider.persistedLeaseFields)+ : undefined;++ let dynamicSecretLease;+ try {+ dynamicSecretLease = await dynamicSecretLeaseDAL.create({+ expireAt,+ version: 1,+ dynamicSecretId: dynamicSecretCfg.id,+ externalEntityId: entityId,+ config,+ encryptedLeaseData: leaseData+ ? secretManagerEncryptor({ plainText: Buffer.from(JSON.stringify(leaseData)) }).cipherTextBlob+ : undefined+ });+ } catch (error) {+ // the credential already exists upstream; without a lease row nothing would ever revoke it+ await selectedProvider+ .revoke(decryptedStoredInput, entityId, { projectId, leaseData }, config)+ .catch((revokeError: Error) =>+ logger.error(+ revokeError,+ `Failed to revoke credential after lease insert failed [dynamicSecretId=${dynamicSecretCfg.id}] [provider=${dynamicSecretCfg.type}]`+ )+ );+ throw error;+ }await dynamicSecretQueueService.setLeaseRevocation(dynamicSecretLease.id, dynamicSecretCfg.id, expireAt);return {@@ -389,7 +412,7 @@ export const dynamicSecretLeaseServiceFactory = ({.revoke(decryptedStoredInput,dynamicSecretLease.externalEntityId,- { projectId },+ { projectId, leaseData: decryptLeaseData(secretManagerDecryptor, dynamicSecretLease.encryptedLeaseData) },dynamicSecretLease.config as TDynamicSecretLeaseConfig).catch(async (err) => {diff --git a/backend/src/ee/services/dynamic-secret/dynamic-secret-service.ts b/backend/src/ee/services/dynamic-secret/dynamic-secret-service.tsindex 27fcdfc20c..a937b16b2f 100644--- a/backend/src/ee/services/dynamic-secret/dynamic-secret-service.ts+++ b/backend/src/ee/services/dynamic-secret/dynamic-secret-service.ts@@ -28,11 +28,12 @@ import { DynamicSecretStatus, TDynamicSecretServiceFactory } from "./dynamic-secimport { AzureEntraIDProvider } from "./providers/azure-entra-id";import { GcpIamServiceAccountSuffixError } from "./providers/gcp-iam";import { IbmApiConnectProvider } from "./providers/ibm-api-connect";-import { DynamicSecretProviders, redactStoredInputs, SshStoredSchema, TDynamicProviderFns } from "./providers/models";+import { DynamicSecretProviders, SshStoredSchema, TDynamicProviderFns } from "./providers/models";+import { redactStoredInputs, restoreOmittedSecretFields } from "./providers/redact";type TDynamicSecretServiceFactoryDep = {dynamicSecretDAL: TDynamicSecretDALFactory;- dynamicSecretLeaseDAL: Pick<TDynamicSecretLeaseDALFactory, "find">;+ dynamicSecretLeaseDAL: Pick<TDynamicSecretLeaseDALFactory, "find" | "countLeasesForDynamicSecret">;dynamicSecretProviders: Record<DynamicSecretProviders, TDynamicProviderFns>;dynamicSecretQueueService: Pick<TDynamicSecretLeaseQueueServiceFactory,@@ -202,7 +203,7 @@ export const dynamicSecretServiceFactory = ({selectedGatewayId = gatewayv2.id;}- const isConnected = await selectedProvider.validateConnection(provider.inputs, { projectId });+ const isConnected = await selectedProvider.validateConnection(provider.inputs, { projectId, defaultTTL, maxTTL });if (!isConnected) throw new BadRequestError({ message: "Provider connection failed" });const { encryptor: secretManagerEncryptor } = await kmsService.createCipherPairWithDataKey({@@ -334,7 +335,10 @@ export const dynamicSecretServiceFactory = ({const decryptedStoredInput = JSON.parse(secretManagerDecryptor({ cipherTextBlob: dynamicSecretCfg.encryptedInput }).toString()) as object;- const newInput = { ...decryptedStoredInput, ...(inputs || {}) };+ const newInput = restoreOmittedSecretFields(dynamicSecretCfg.type as DynamicSecretProviders, decryptedStoredInput, {+ ...decryptedStoredInput,+ ...(inputs || {})+ });// Mutual exclusion: reject if both gateway fields are setif (inputs &&@@ -362,11 +366,13 @@ export const dynamicSecretServiceFactory = ({throw error;}}+ const activeLeaseCount = await dynamicSecretLeaseDAL.countLeasesForDynamicSecret(dynamicSecretCfg.id);const updatedInput = await selectedProvider.validateProviderInputs(newInput, {projectId,previousInputs: decryptedStoredInput,defaultTTL,- maxTTL+ maxTTL,+ hasActiveLeases: activeLeaseCount > 0});const updatedFields = getUpdatedFieldPaths(@@ -436,7 +442,11 @@ export const dynamicSecretServiceFactory = ({selectedGatewayId = gatewayv2.id;}- const isConnected = await selectedProvider.validateConnection(newInput, { projectId });+ const isConnected = await selectedProvider.validateConnection(newInput, {+ projectId,+ defaultTTL: defaultTTL ?? dynamicSecretCfg.defaultTTL,+ maxTTL: maxTTL === undefined ? dynamicSecretCfg.maxTTL : maxTTL+ });if (!isConnected) throw new BadRequestError({ message: "Provider connection failed" });const updatedDynamicCfg = await dynamicSecretDAL.transaction(async (tx) => {diff --git a/backend/src/ee/services/dynamic-secret/providers/index.ts b/backend/src/ee/services/dynamic-secret/providers/index.tsindex 04b777ff90..3e4b8c54c2 100644--- a/backend/src/ee/services/dynamic-secret/providers/index.ts+++ b/backend/src/ee/services/dynamic-secret/providers/index.ts@@ -21,6 +21,7 @@ import { MilvusProvider } from "./milvus";import { DynamicSecretProviders, TDynamicProviderFns } from "./models";import { MongoAtlasProvider } from "./mongo-atlas";import { MongoDBProvider } from "./mongo-db";+import { OAuthProvider } from "./oauth";import { RabbitMqProvider } from "./rabbit-mq";import { RedisDatabaseProvider } from "./redis";import { SapAseProvider } from "./sap-ase";@@ -68,5 +69,6 @@ export const buildDynamicSecretProviders = ({[DynamicSecretProviders.Milvus]: MilvusProvider({ gatewayV2Service, gatewayPoolService }),[DynamicSecretProviders.Ssh]: SshProvider(),[DynamicSecretProviders.IbmApiConnect]: IbmApiConnectProvider(),- [DynamicSecretProviders.Tailscale]: TailscaleProvider()+ [DynamicSecretProviders.Tailscale]: TailscaleProvider(),+ [DynamicSecretProviders.OAuth]: OAuthProvider()});diff --git a/backend/src/ee/services/dynamic-secret/providers/models.test.ts b/backend/src/ee/services/dynamic-secret/providers/models.test.tsindex a1094a4f60..19a1b6adbd 100644--- a/backend/src/ee/services/dynamic-secret/providers/models.test.ts+++ b/backend/src/ee/services/dynamic-secret/providers/models.test.ts@@ -2,51 +2,7 @@ import { describe, expect, test } from "vitest";import { SshCertKeyAlgorithm } from "@app/lib/ssh";-import {- DYNAMIC_SECRET_SECRET_FIELDS,- DynamicSecretProviders,- DynamicSecretSshSchema,- redactStoredInputs-} from "./models";--describe("redactStoredInputs", () => {- const sshStoredInputs = {- caPrivateKey: "-----BEGIN OPENSSH PRIVATE KEY-----\nca-key-material\n-----END OPENSSH PRIVATE KEY-----",- caPublicKey: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5 ca@infisical",- principals: ["ubuntu"],- keyAlgorithm: SshCertKeyAlgorithm.ED25519,- caKeyAlgorithm: SshCertKeyAlgorithm.ED25519- };-- test("withholds the SSH CA private key and keeps the rest of the configuration", () => {- const redacted = redactStoredInputs(DynamicSecretProviders.Ssh, sshStoredInputs);-- expect(redacted).toStrictEqual({- caPublicKey: sshStoredInputs.caPublicKey,- principals: sshStoredInputs.principals,- keyAlgorithm: SshCertKeyAlgorithm.ED25519,- caKeyAlgorithm: SshCertKeyAlgorithm.ED25519- });- expect(JSON.stringify(redacted)).not.toContain("ca-key-material");- });-- test("returns inputs untouched for a provider that declares no secret fields", () => {- const sqlStoredInputs = { host: "db.internal", username: "admin", password: "hunter2" };-- expect(redactStoredInputs(DynamicSecretProviders.SqlDatabase, sqlStoredInputs)).toStrictEqual(sqlStoredInputs);- });-- test("tolerates stored input that is not an object", () => {- expect(redactStoredInputs(DynamicSecretProviders.Ssh, null)).toBeNull();- expect(redactStoredInputs(DynamicSecretProviders.Ssh, undefined)).toBeUndefined();- });-- test("declares a secret field list for every provider", () => {- const declared = Object.keys(DYNAMIC_SECRET_SECRET_FIELDS).sort();-- expect(declared).toStrictEqual(Object.values(DynamicSecretProviders).sort());- });-});+import { DynamicSecretSshSchema } from "./models";describe("DynamicSecretSshSchema", () => {test("accepts a supported cert algorithm value", () => {diff --git a/backend/src/ee/services/dynamic-secret/providers/models.ts b/backend/src/ee/services/dynamic-secret/providers/models.tsindex 4c09e601c5..79242a05be 100644--- a/backend/src/ee/services/dynamic-secret/providers/models.ts+++ b/backend/src/ee/services/dynamic-secret/providers/models.ts@@ -830,7 +830,8 @@ export enum DynamicSecretProviders {Milvus = "milvus",Ssh = "ssh",IbmApiConnect = "ibm-api-connect",- Tailscale = "tailscale"+ Tailscale = "tailscale",+ OAuth = "oauth"}export const DynamicSecretIbmApiConnectSchema = z.object({@@ -973,6 +974,131 @@ export const DynamicSecretTailscaleSchema = z}});+export enum OAuthGrantType {+ ClientCredentials = "client-credentials"+}++export const OAUTH_MAX_EXTRA_PARAMS = 20;++// Parameters Infisical sets itself or that carry client authentication; letting extra params+// override them would change the grant or leak credentials into the request body.+export const OAUTH_RESERVED_PARAMS = new Set([+ "grant_type",+ "scope",+ "client_id",+ "client_secret",+ "client_assertion",+ "client_assertion_type"+]);++// RFC 6749 section 3.3: scope-token = 1*( %x21 / %x23-5B / %x5D-7E )+const OAUTH_SCOPE_TOKEN_REGEX = new RE2(/^[\x21\x23-\x5B\x5D-\x7E]+$/);+const OAUTH_PARAM_KEY_REGEX = new RE2(/^[A-Za-z0-9._~:[\]-]+$/);+const WHITESPACE_REGEX = new RE2(/\s+/);++export const normalizeOAuthScope = (scope: string) =>+ [...new Set(scope.split(WHITESPACE_REGEX).filter(Boolean))].join(" ");++// RFC 7591 registry names, so they match what servers advertise in token_endpoint_auth_methods_supported+export enum OAuthClientAuthMethod {+ ClientSecretBasic = "client_secret_basic",+ ClientSecretPost = "client_secret_post"+}++const OAuthClientSecretSchema = z+ .string()+ .trim()+ .min(1, "Client secret is required")+ .max(4096)+ .describe("The OAuth client secret.");++export const OAuthClientAuthSchema = z.discriminatedUnion("method", [+ z.object({+ method: z+ .literal(OAuthClientAuthMethod.ClientSecretBasic)+ .describe("Send the client credentials in an HTTP Basic Authorization header."),+ clientSecret: OAuthClientSecretSchema+ }),+ z.object({+ method: z+ .literal(OAuthClientAuthMethod.ClientSecretPost)+ .describe("Send the client credentials as client_id and client_secret form parameters."),+ clientSecret: OAuthClientSecretSchema+ })+]);++export const DynamicSecretOAuthSchema = z.discriminatedUnion("grantType", [+ z.object({+ grantType: z.literal(OAuthGrantType.ClientCredentials),+ tokenUrl: z+ .string()+ .trim()+ .max(2048)+ .url("Token URL must be a valid URL")+ .describe("The authorization server's token endpoint."),+ revocationUrl: z+ .string()+ .trim()+ .max(2048)+ .url("Revocation URL must be a valid URL")+ .describe("The authorization server's RFC 7009 token revocation endpoint."),+ clientId: z.string().trim().min(1, "Client ID is required").max(1024).describe("The OAuth client ID."),+ clientAuth: OAuthClientAuthSchema.describe(+ "How Infisical authenticates the client to the token and revocation endpoints."+ ),+ scope: z+ .string()+ .trim()+ .max(2048)+ .superRefine((scope, ctx) => {+ const invalidTokens = scope+ .split(WHITESPACE_REGEX)+ .filter((token) => token && !OAUTH_SCOPE_TOKEN_REGEX.test(token));+ if (invalidTokens.length) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ message: `Scope contains invalid characters: ${invalidTokens.map((token) => `'${token}'`).join(", ")}`+ });+ }+ })+ .transform((scope) => normalizeOAuthScope(scope) || undefined)+ .optional()+ .describe("Space-separated scopes to request. Leave empty to use the client's default scopes."),+ extraParams: z+ .array(+ z.object({+ key: z+ .string()+ .trim()+ .min(1, "Parameter name is required")+ .max(128)+ .refine((key) => OAUTH_PARAM_KEY_REGEX.test(key), "Parameter name contains invalid characters")+ .refine(+ (key) => !OAUTH_RESERVED_PARAMS.has(key.toLowerCase()),+ (key) => ({ message: `'${key}' is set by Infisical and can't be used as an extra parameter` })+ ),+ value: z.string().trim().min(1, "Parameter value is required").max(2048)+ })+ )+ .max(OAUTH_MAX_EXTRA_PARAMS, `At most ${OAUTH_MAX_EXTRA_PARAMS} extra parameters are allowed`)+ .superRefine((params, ctx) => {+ const seen = new Set<string>();+ params.forEach(({ key }, index) => {+ if (seen.has(key)) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: [index, "key"],+ message: `Extra parameter '${key}' is set more than once`+ });+ }+ seen.add(key);+ });+ })+ .default([])+ .describe("Additional form parameters sent with the token request, such as audience or resource.")+ })+]);+export const DynamicSecretSshSchema = z.object({principals: z.array(z.string().trim().min(1)).min(1),keyAlgorithm: z.enum(SSH_CERT_KEY_ALGORITHMS).default(SshCertKeyAlgorithm.ED25519),@@ -987,43 +1113,6 @@ export const SshStoredSchema = z.object({caKeyAlgorithm: z.enum(SSH_CERT_KEY_ALGORITHMS).default(SshCertKeyAlgorithm.ED25519)});-export const DYNAMIC_SECRET_SECRET_FIELDS: Record<DynamicSecretProviders, readonly string[]> = {- [DynamicSecretProviders.Ssh]: ["caPrivateKey"],- [DynamicSecretProviders.SqlDatabase]: [],- [DynamicSecretProviders.Clickhouse]: [],- [DynamicSecretProviders.Cassandra]: [],- [DynamicSecretProviders.AwsIam]: [],- [DynamicSecretProviders.Redis]: [],- [DynamicSecretProviders.AwsElastiCache]: [],- [DynamicSecretProviders.AwsMemoryDb]: [],- [DynamicSecretProviders.MongoAtlas]: [],- [DynamicSecretProviders.ElasticSearch]: [],- [DynamicSecretProviders.MongoDB]: [],- [DynamicSecretProviders.RabbitMq]: [],- [DynamicSecretProviders.AzureEntraID]: [],- [DynamicSecretProviders.AzureSqlDatabase]: [],- [DynamicSecretProviders.Ldap]: [],- [DynamicSecretProviders.SapHana]: [],- [DynamicSecretProviders.Snowflake]: [],- [DynamicSecretProviders.Totp]: [],- [DynamicSecretProviders.SapAse]: [],- [DynamicSecretProviders.Kubernetes]: [],- [DynamicSecretProviders.Vertica]: [],- [DynamicSecretProviders.GcpIam]: [],- [DynamicSecretProviders.Github]: [],- [DynamicSecretProviders.Couchbase]: [],- [DynamicSecretProviders.Milvus]: [],- [DynamicSecretProviders.IbmApiConnect]: [],- [DynamicSecretProviders.Tailscale]: []-};--export const redactStoredInputs = (type: DynamicSecretProviders, inputs: unknown): unknown => {- const secretFields = DYNAMIC_SECRET_SECRET_FIELDS[type];- if (!secretFields?.length || typeof inputs !== "object" || inputs === null) return inputs;-- return Object.fromEntries(Object.entries(inputs).filter(([field]) => !secretFields.includes(field)));-};-export const DynamicSecretProviderSchema = z.discriminatedUnion("type", [z.object({ type: z.literal(DynamicSecretProviders.SqlDatabase), inputs: DynamicSecretSqlDBSchema }),z.object({ type: z.literal(DynamicSecretProviders.Clickhouse), inputs: DynamicSecretClickhouseSchema }),@@ -1054,7 +1143,8 @@ export const DynamicSecretProviderSchema = z.discriminatedUnion("type", [type: z.literal(DynamicSecretProviders.IbmApiConnect),inputs: DynamicSecretIbmApiConnectSchema}),- z.object({ type: z.literal(DynamicSecretProviders.Tailscale), inputs: DynamicSecretTailscaleSchema })+ z.object({ type: z.literal(DynamicSecretProviders.Tailscale), inputs: DynamicSecretTailscaleSchema }),+ z.object({ type: z.literal(DynamicSecretProviders.OAuth), inputs: DynamicSecretOAuthSchema })]);// Extended metadata passed to a provider's create() call. When the project@@ -1075,9 +1165,12 @@ export type TDynamicProviderValidateMetadata = {previousInputs?: object;defaultTTL?: string;maxTTL?: string | null;+ hasActiveLeases?: boolean;};export type TDynamicProviderFns = {+ // keys of create()'s `data` that revoke() needs; stored encrypted on the lease and passed back as metadata.leaseData+ persistedLeaseFields?: string[];create: (arg: {inputs: unknown;expireAt: number;@@ -1087,12 +1180,15 @@ export type TDynamicProviderFns = {metadata: TDynamicProviderCreateMetadata;config?: TDynamicSecretLeaseConfig;}) => Promise<{ entityId: string; data: unknown }>;- validateConnection: (inputs: unknown, metadata: { projectId: string }) => Promise<boolean>;+ validateConnection: (+ inputs: unknown,+ metadata: { projectId: string; defaultTTL?: string; maxTTL?: string | null }+ ) => Promise<boolean>;validateProviderInputs: (inputs: object, metadata: TDynamicProviderValidateMetadata) => Promise<unknown>;revoke: (inputs: unknown,entityId: string,- metadata: { projectId: string },+ metadata: { projectId: string; leaseData?: Record<string, string> },config?: TDynamicSecretLeaseConfig) => Promise<{ entityId: string }>;renew: (diff --git a/backend/src/ee/services/dynamic-secret/providers/oauth.test.ts b/backend/src/ee/services/dynamic-secret/providers/oauth.test.tsnew file mode 100644index 0000000000..d0f2d4c02a--- /dev/null+++ b/backend/src/ee/services/dynamic-secret/providers/oauth.test.ts@@ -0,0 +1,445 @@+import { AxiosError, AxiosResponse } from "axios";+import { beforeEach, describe, expect, test, vi } from "vitest";++import { TDynamicSecrets } from "@app/db/schemas";+import { BadRequestError } from "@app/lib/errors";+import { safeRequest } from "@app/lib/validator";++import { DynamicSecretOAuthSchema, OAuthClientAuthMethod, OAuthGrantType } from "./models";+import { OAuthProvider } from "./oauth";++const { appConfig } = vi.hoisted(() => ({ appConfig: { isDevelopmentMode: false } }));++vi.mock("@app/lib/config/env", () => ({ getConfig: () => appConfig }));++vi.mock("@app/lib/logger", async () => ({+ logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },+ sanitizeUrlForLog: (+ await vi.importActual<typeof import("@app/lib/logger/sanitize-url")>("@app/lib/logger/sanitize-url")+ ).sanitizeUrlForLog+}));++// the crypto layer isn't initialised in the unit environment+vi.mock("@app/lib/crypto", async () => {+ const jwt = await vi.importActual<typeof import("jsonwebtoken")>("jsonwebtoken");+ return { crypto: { jwt: () => ({ decode: jwt.decode }) } };+});++vi.mock("@app/lib/validator", () => ({ safeRequest: { post: vi.fn() } }));++const mockedPost = vi.mocked(safeRequest.post);++const TOKEN_URL = "https://auth.example.com/oauth2/token";+const REVOCATION_URL = "https://auth.example.com/oauth2/revoke";++const baseInputs = {+ grantType: OAuthGrantType.ClientCredentials,+ tokenUrl: TOKEN_URL,+ revocationUrl: REVOCATION_URL,+ clientId: "infisical-client",+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretBasic, clientSecret: "super-secret-value" },+ extraParams: []+};++const metadata = { projectId: "proj-1" };++const createArgs = (expireAt: number, inputs: object = baseInputs) => ({+ inputs,+ expireAt,+ identity: { name: "tester" },+ dynamicSecret: {} as TDynamicSecrets,+ metadata+});++const tokenResponse = (data: unknown) => ({ data }) as AxiosResponse;++const upstreamError = (status: number, data: unknown) =>+ new AxiosError(`Request failed with status code ${status}`, "ERR_BAD_REQUEST", undefined, undefined, {+ status,+ data,+ statusText: "",+ headers: {},+ config: {} as AxiosResponse["config"]+ });++const jwtWithExp = (exp: number) =>+ [+ Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),+ Buffer.from(JSON.stringify({ sub: "client", exp })).toString("base64url"),+ ""+ ].join(".");++const decodeBasic = (header: unknown) => Buffer.from(String(header).replace("Basic ", ""), "base64").toString();++const callAt = (index: number) => {+ const [url, body, options] = mockedPost.mock.calls[index];+ return {+ url,+ body: new URLSearchParams(body as string),+ options: options as Record<string, unknown> & { headers: Record<string, string> }+ };+};++describe("OAuth dynamic secret schema", () => {+ test("normalizes scope by splitting on whitespace and removing duplicates", () => {+ const parsed = DynamicSecretOAuthSchema.parse({ ...baseInputs, scope: " read write\tread " });+ expect(parsed.scope).toBe("read write");+ });++ test("treats a blank scope as unset", () => {+ expect(DynamicSecretOAuthSchema.parse({ ...baseInputs, scope: " " }).scope).toBeUndefined();+ });++ test("rejects scope tokens with characters outside RFC 6749 section 3.3", () => {+ expect(() => DynamicSecretOAuthSchema.parse({ ...baseInputs, scope: 'read "write"' })).toThrow(+ "Scope contains invalid characters"+ );+ });++ test.each(["grant_type", "scope", "client_id", "client_secret", "client_assertion", "Client_Assertion_Type"])(+ "rejects the reserved extra parameter %s",+ (key) => {+ expect(() => DynamicSecretOAuthSchema.parse({ ...baseInputs, extraParams: [{ key, value: "x" }] })).toThrow(+ "can't be used as an extra parameter"+ );+ }+ );++ test("rejects duplicate and excessive extra parameters", () => {+ expect(() =>+ DynamicSecretOAuthSchema.parse({+ ...baseInputs,+ extraParams: [+ { key: "audience", value: "a" },+ { key: "audience", value: "b" }+ ]+ })+ ).toThrow("set more than once");++ expect(() =>+ DynamicSecretOAuthSchema.parse({+ ...baseInputs,+ extraParams: Array.from({ length: 21 }, (_, index) => ({ key: `param${index}`, value: "x" }))+ })+ ).toThrow("At most 20 extra parameters");+ });+});++describe("OAuthProvider.validateProviderInputs", () => {+ beforeEach(() => {+ appConfig.isDevelopmentMode = false;+ });++ test("rejects http URLs outside development mode", async () => {+ await expect(+ OAuthProvider().validateProviderInputs({ ...baseInputs, tokenUrl: "http://auth.example.com/token" }, metadata)+ ).rejects.toThrow("Token URL must use https");+ });++ test("allows http URLs in development mode", async () => {+ appConfig.isDevelopmentMode = true;+ await expect(+ OAuthProvider().validateProviderInputs({ ...baseInputs, revocationUrl: "http://localhost:8080/revoke" }, metadata)+ ).resolves.toMatchObject({ revocationUrl: "http://localhost:8080/revoke" });+ });++ test("rejects a token URL change while leases are active", async () => {+ await expect(+ OAuthProvider().validateProviderInputs(+ { ...baseInputs, tokenUrl: "https://other.example.com/token" },+ { ...metadata, previousInputs: baseInputs, hasActiveLeases: true }+ )+ ).rejects.toThrow("can't be changed while this dynamic secret has active leases");+ });++ test("allows a token URL change when there are no leases, and a client ID change with leases", async () => {+ const provider = OAuthProvider();+ await expect(+ provider.validateProviderInputs(+ { ...baseInputs, tokenUrl: "https://other.example.com/token" },+ { ...metadata, previousInputs: baseInputs, hasActiveLeases: false }+ )+ ).resolves.toBeDefined();+ await expect(+ provider.validateProviderInputs(+ { ...baseInputs, clientId: "rotated-client" },+ { ...metadata, previousInputs: baseInputs, hasActiveLeases: true }+ )+ ).resolves.toBeDefined();+ });+});++describe("OAuthProvider token request", () => {+ beforeEach(() => {+ mockedPost.mockReset();+ appConfig.isDevelopmentMode = false;+ });++ test("form-urlencodes client credentials before base64 encoding them", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse({ access_token: "opaque-access-token" }));++ await OAuthProvider().create(+ createArgs(Date.now() + 60_000, {+ ...baseInputs,+ clientId: "my client",+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretBasic, clientSecret: "p+s%:w" }+ })+ );++ expect(decodeBasic(callAt(0).options.headers.Authorization)).toBe("my+client:p%2Bs%25%3Aw");+ });++ test("sends client credentials in the body without an Authorization header for client_secret_post", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse({ access_token: "opaque-access-token" }));++ await OAuthProvider().create(+ createArgs(Date.now() + 60_000, {+ ...baseInputs,+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretPost, clientSecret: "p+s%:w" }+ })+ );++ const { body, options } = callAt(0);+ expect(Object.fromEntries(body)).toEqual({+ grant_type: "client_credentials",+ client_id: "infisical-client",+ client_secret: "p+s%:w"+ });+ expect(options.headers).not.toHaveProperty("Authorization");+ });++ test("sends grant_type, normalized scope and extra params with retries disabled", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse({ access_token: "opaque-access-token" }));++ await OAuthProvider().create(+ createArgs(Date.now() + 60_000, {+ ...baseInputs,+ scope: "read write read",+ extraParams: [{ key: "audience", value: "https://api.example.com" }]+ })+ );++ const { url, body, options } = callAt(0);+ expect(url).toBe(TOKEN_URL);+ expect(Object.fromEntries(body)).toEqual({+ grant_type: "client_credentials",+ scope: "read write",+ audience: "https://api.example.com"+ });+ expect(body.has("client_secret")).toBe(false);+ expect(options.headers["Content-Type"]).toBe("application/x-www-form-urlencoded");+ expect(options["axios-retry"]).toEqual({ retries: 0 });+ });++ test("returns the token and derives EXPIRES_AT from expires_in", async () => {+ mockedPost.mockResolvedValueOnce(+ tokenResponse({ access_token: "opaque-access-token", token_type: "Bearer", expires_in: 3600, scope: "read" })+ );++ const before = Date.now();+ const { entityId, data } = await OAuthProvider().create(createArgs(Date.now() + 60_000));++ expect(entityId).toHaveLength(32);+ const leaseData = data as Record<string, string>;+ expect(leaseData).toMatchObject({ ACCESS_TOKEN: "opaque-access-token", TOKEN_TYPE: "Bearer", SCOPE: "read" });+ const expiresAt = new Date(leaseData.EXPIRES_AT).getTime();+ expect(expiresAt).toBeGreaterThanOrEqual(before + 3_600_000 - 1000);+ expect(expiresAt).toBeLessThanOrEqual(Date.now() + 3_600_000);+ });++ test("falls back to the JWT exp claim when expires_in is missing", async () => {+ const exp = Math.floor(Date.now() / 1000) + 1800;+ mockedPost.mockResolvedValueOnce(tokenResponse({ access_token: jwtWithExp(exp) }));++ const { data } = await OAuthProvider().create(createArgs(Date.now() + 60_000));++ expect((data as Record<string, string>).EXPIRES_AT).toBe(new Date(exp * 1000).toISOString());+ });++ test("skips the TTL check when the lifetime is unknown", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse({ access_token: "opaque-access-token" }));++ const { data } = await OAuthProvider().create(createArgs(Date.now() + 365 * 24 * 3_600_000));++ expect(data).not.toHaveProperty("EXPIRES_AT");+ expect(mockedPost).toHaveBeenCalledOnce();+ });++ test("accepts a lease TTL within the 60s clock skew tolerance", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse({ access_token: "opaque-access-token", expires_in: 3599 }));++ await expect(OAuthProvider().create(createArgs(Date.now() + 3_600_000))).resolves.toBeDefined();+ });++ test("rejects a lease TTL longer than the token lifetime and revokes the token", async () => {+ mockedPost+ .mockResolvedValueOnce(tokenResponse({ access_token: "opaque-access-token", expires_in: 1800 }))+ .mockResolvedValueOnce(tokenResponse(""));++ await expect(OAuthProvider().create(createArgs(Date.now() + 3_600_000))).rejects.toThrow(+ /lease TTL \(3600s\) is longer than the lifetime of the access tokens the authorization server issues \(1800s\)/+ );++ expect(mockedPost).toHaveBeenCalledTimes(2);+ const { url, body } = callAt(1);+ expect(url).toBe(REVOCATION_URL);+ expect(body.get("token")).toBe("opaque-access-token");+ });++ test("maps RFC 6749 token errors to a readable message without leaking credentials", async () => {+ mockedPost.mockRejectedValueOnce(+ upstreamError(401, {+ error: "invalid_client",+ error_description: "Client authentication failed for super-secret-value"+ })+ );++ const result = OAuthProvider().create(createArgs(Date.now() + 60_000));++ await expect(result).rejects.toBeInstanceOf(BadRequestError);+ await expect(result).rejects.toThrow(/rejected the token request: invalid_client: Client authentication failed/);+ await expect(result).rejects.not.toThrow(/super-secret-value/);+ });++ test("rejects a token response without an access_token", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse({ token_type: "Bearer" }));++ await expect(OAuthProvider().create(createArgs(Date.now() + 60_000))).rejects.toThrow("without an access_token");+ });+});++describe("OAuthProvider.revoke", () => {+ beforeEach(() => {+ mockedPost.mockReset();+ });++ test("posts the stored token to the revocation endpoint with an access_token hint", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse(""));++ await OAuthProvider().revoke(baseInputs, "entity-1", { ...metadata, leaseData: { ACCESS_TOKEN: "stored-token" } });++ const { url, body, options } = callAt(0);+ expect(url).toBe(REVOCATION_URL);+ expect(Object.fromEntries(body)).toEqual({ token: "stored-token", token_type_hint: "access_token" });+ expect(decodeBasic(options.headers.Authorization)).toBe("infisical-client:super-secret-value");+ expect(options).not.toHaveProperty("axios-retry");+ });++ test("authenticates the revocation request the same way as the token request for client_secret_post", async () => {+ mockedPost.mockResolvedValueOnce(tokenResponse(""));++ await OAuthProvider().revoke(+ { ...baseInputs, clientAuth: { method: OAuthClientAuthMethod.ClientSecretPost, clientSecret: "post-secret" } },+ "entity-1",+ { ...metadata, leaseData: { ACCESS_TOKEN: "stored-token" } }+ );++ const { body, options } = callAt(0);+ expect(Object.fromEntries(body)).toEqual({+ token: "stored-token",+ token_type_hint: "access_token",+ client_id: "infisical-client",+ client_secret: "post-secret"+ });+ expect(options.headers).not.toHaveProperty("Authorization");+ });++ test("redacts a client_secret_post secret from revocation errors", async () => {+ mockedPost.mockRejectedValueOnce(+ upstreamError(401, { error: "invalid_client", error_description: "unknown secret post-secret-value" })+ );++ const result = OAuthProvider().revoke(+ {+ ...baseInputs,+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretPost, clientSecret: "post-secret-value" }+ },+ "entity-1",+ { ...metadata, leaseData: { ACCESS_TOKEN: "stored-token" } }+ );++ await expect(result).rejects.toThrow("[REDACTED]");+ await expect(result).rejects.not.toThrow("post-secret-value");+ });++ test("rejects an unknown client auth method", async () => {+ await expect(+ OAuthProvider().revoke(+ { ...baseInputs, clientAuth: { method: "private_key_jwt", privateKey: "key" } },+ "entity-1",+ { ...metadata, leaseData: { ACCESS_TOKEN: "stored-token" } }+ )+ ).rejects.toThrow();+ expect(mockedPost).not.toHaveBeenCalled();+ });++ test("throws a readable error when the lease has no stored token", async () => {+ await expect(OAuthProvider().revoke(baseInputs, "entity-1", metadata)).rejects.toThrow(+ "This lease has no stored access token"+ );+ expect(mockedPost).not.toHaveBeenCalled();+ });++ test("redacts the access token from revocation errors", async () => {+ const accessToken = jwtWithExp(Math.floor(Date.now() / 1000) + 60);+ mockedPost.mockRejectedValueOnce(+ upstreamError(400, { error: "invalid_request", error_description: `bad token ${accessToken}` })+ );++ const result = OAuthProvider().revoke(baseInputs, "entity-1", {+ ...metadata,+ leaseData: { ACCESS_TOKEN: accessToken }+ });++ await expect(result).rejects.toThrow("[REDACTED]");+ await expect(result).rejects.not.toThrow(accessToken);+ });+});++describe("OAuthProvider.validateConnection", () => {+ beforeEach(() => {+ mockedPost.mockReset();+ });++ test("issues a test token, checks the TTLs and revokes it", async () => {+ mockedPost+ .mockResolvedValueOnce(tokenResponse({ access_token: "test-token", expires_in: 3600 }))+ .mockResolvedValueOnce(tokenResponse(""));++ await expect(+ OAuthProvider().validateConnection(baseInputs, { ...metadata, defaultTTL: "30m", maxTTL: "1h" })+ ).resolves.toBe(true);++ expect(callAt(1).url).toBe(REVOCATION_URL);+ expect(callAt(1).body.get("token")).toBe("test-token");+ });++ test("rejects a max TTL longer than the token lifetime", async () => {+ mockedPost+ .mockResolvedValueOnce(tokenResponse({ access_token: "test-token", expires_in: 3600 }))+ .mockResolvedValueOnce(tokenResponse(""));++ await expect(+ OAuthProvider().validateConnection(baseInputs, { ...metadata, defaultTTL: "30m", maxTTL: "2h" })+ ).rejects.toThrow(/max TTL \(7200s\)/);+ expect(callAt(1).url).toBe(REVOCATION_URL);+ });++ test("rejects authorization servers that can't revoke access tokens", async () => {+ mockedPost+ .mockResolvedValueOnce(tokenResponse({ access_token: "test-token", expires_in: 3600 }))+ .mockRejectedValueOnce(upstreamError(400, { error: "unsupported_token_type" }));++ await expect(OAuthProvider().validateConnection(baseInputs, { ...metadata, defaultTTL: "30m" })).rejects.toThrow(+ /couldn't revoke it.*doesn't support revoking access tokens \(unsupported_token_type\)/+ );+ });+});++describe("OAuthProvider.renew", () => {+ test("is not supported", async () => {+ await expect(OAuthProvider().renew(baseInputs, "entity-1", Date.now(), metadata)).rejects.toThrow(+ "OAuth access tokens can't be extended"+ );+ });+});diff --git a/backend/src/ee/services/dynamic-secret/providers/oauth.ts b/backend/src/ee/services/dynamic-secret/providers/oauth.tsnew file mode 100644index 0000000000..f48dc7f50b--- /dev/null+++ b/backend/src/ee/services/dynamic-secret/providers/oauth.ts@@ -0,0 +1,344 @@+import { isAxiosError } from "axios";+import { z } from "zod";++import { getConfig } from "@app/lib/config/env";+import { crypto } from "@app/lib/crypto";+import { BadRequestError } from "@app/lib/errors";+import { sanitizeString } from "@app/lib/fn";+import { logger, sanitizeUrlForLog } from "@app/lib/logger";+import { ms } from "@app/lib/ms";+import { alphaNumericNanoId } from "@app/lib/nanoid";+import { safeRequest } from "@app/lib/validator";++import {+ DynamicSecretOAuthSchema,+ OAuthClientAuthMethod,+ TDynamicProviderFns,+ TDynamicProviderValidateMetadata+} from "./models";++type TOAuthProviderInputs = z.infer<typeof DynamicSecretOAuthSchema>;++type TIssuedToken = {+ accessToken: string;+ tokenType?: string;+ scope?: string;+ requestedAt: number;+ expiresAt: number | null;+};++const REQUEST_TIMEOUT_MS = 30_000;+// Entra and Google report 3599s for a 1h token, and Entra randomizes lifetimes, so an exact+// comparison would reject TTLs that match what the admin configured on the server.+const TTL_TOLERANCE_MS = 60_000;+const MAX_UPSTREAM_ERROR_LENGTH = 300;+const MIN_LITERAL_REDACTION_LENGTH = 8;++const OAuthTokenResponseSchema = z.object({+ access_token: z.string().min(1),+ token_type: z.string().optional(),+ scope: z.string().optional(),+ expires_in: z.union([z.number(), z.string()]).optional()+});++const OAuthLeaseDataSchema = z.object({+ ACCESS_TOKEN: z.string().min(1)+});++// RFC 6749 section 2.3.1: credentials are form-urlencoded before being joined and base64 encoded+const formEncode = (value: string) => new URLSearchParams([["", value]]).toString().slice(1);++// RFC 7009 section 2.1 requires the revocation request to authenticate the same way as the token request,+// so both go through here; it adds body parameters in place and returns any headers to send+const applyClientAuth = ({ clientId, clientAuth }: TOAuthProviderInputs, body: URLSearchParams) => {+ switch (clientAuth.method) {+ case OAuthClientAuthMethod.ClientSecretBasic:+ return {+ Authorization: `Basic ${Buffer.from(`${formEncode(clientId)}:${formEncode(clientAuth.clientSecret)}`).toString("base64")}`+ };+ case OAuthClientAuthMethod.ClientSecretPost:+ body.set("client_id", clientId);+ body.set("client_secret", clientAuth.clientSecret);+ return {};+ default: {+ const exhaustiveCheck: never = clientAuth;+ throw new Error(`Unhandled OAuth client auth method: ${JSON.stringify(exhaustiveCheck)}`);+ }+ }+};++const getClientCredentialSecrets = ({ clientId, clientAuth }: TOAuthProviderInputs) => [+ clientId,+ clientAuth.clientSecret+];++const parseJsonBody = (data: unknown): unknown => {+ if (typeof data !== "string") return data;+ try {+ return JSON.parse(data) as unknown;+ } catch {+ return data;+ }+};++const redact = (message: string, secrets: (string | undefined)[]) => {+ const tokens = secrets+ .filter((secret): secret is string => Boolean(secret))+ .flatMap((secret) => [secret, formEncode(secret), encodeURIComponent(secret)]);++ // sanitizeString only matches whole \w+ words, which misses JWTs and secrets containing punctuation+ const literallyRedacted = [...new Set(tokens)]+ .filter((token) => token.length >= MIN_LITERAL_REDACTION_LENGTH)+ .sort((a, b) => b.length - a.length)+ .reduce((acc, token) => acc.split(token).join("[REDACTED]"), message);++ return sanitizeString({ unsanitizedString: literallyRedacted, tokens });+};++const describeUpstreamError = (err: unknown): { code?: string; status?: number; message: string } => {+ if (isAxiosError(err) && err.response) {+ const { status } = err.response;+ const body = parseJsonBody(err.response.data);+ if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {+ const code = body.error.slice(0, MAX_UPSTREAM_ERROR_LENGTH);+ const description =+ "error_description" in body && typeof body.error_description === "string"+ ? body.error_description.slice(0, MAX_UPSTREAM_ERROR_LENGTH)+ : undefined;+ return { code, status, message: description ? `${code}: ${description}` : code };+ }+ return { status, message: `HTTP ${status}` };+ }+ return { message: (err as Error)?.message || "Unknown error" };+};++const assertSecureUrl = (url: string, fieldLabel: string) => {+ const { protocol } = new URL(url);+ if (protocol === "https:") return;+ if (protocol === "http:" && getConfig().isDevelopmentMode) return;+ throw new BadRequestError({ message: `${fieldLabel} must use https` });+};++const resolveExpiresAt = (accessToken: string, expiresIn: number | string | undefined, requestedAt: number) => {+ const expiresInSeconds = Number(expiresIn);+ if (expiresIn !== undefined && Number.isFinite(expiresInSeconds) && expiresInSeconds > 0) {+ return requestedAt + expiresInSeconds * 1000;+ }++ try {+ const payload = crypto.jwt().decode(accessToken) as { exp?: unknown } | null;+ if (payload && typeof payload.exp === "number" && Number.isFinite(payload.exp)) {+ return payload.exp * 1000;+ }+ } catch {+ // opaque tokens are not JWTs; their lifetime is unknown+ }++ return null;+};++export const OAuthProvider = (): TDynamicProviderFns => {+ const $parseInputs = async (inputs: unknown) => {+ const providerInputs = await DynamicSecretOAuthSchema.parseAsync(inputs);+ assertSecureUrl(providerInputs.tokenUrl, "Token URL");+ assertSecureUrl(providerInputs.revocationUrl, "Revocation URL");+ return providerInputs;+ };++ const validateProviderInputs = async (+ inputs: object,+ { previousInputs, hasActiveLeases }: TDynamicProviderValidateMetadata+ ) => {+ const providerInputs = await $parseInputs(inputs);++ const previousTokenUrl = (previousInputs as { tokenUrl?: unknown } | undefined)?.tokenUrl;+ if (hasActiveLeases && typeof previousTokenUrl === "string" && previousTokenUrl !== providerInputs.tokenUrl) {+ throw new BadRequestError({+ message:+ "The token URL can't be changed while this dynamic secret has active leases, because their tokens were issued by the current authorization server. Revoke the active leases first, then change the token URL."+ });+ }++ return providerInputs;+ };++ const $requestToken = async (providerInputs: TOAuthProviderInputs): Promise<TIssuedToken> => {+ const body = new URLSearchParams({ grant_type: "client_credentials" });+ if (providerInputs.scope) body.set("scope", providerInputs.scope);+ providerInputs.extraParams.forEach(({ key, value }) => body.set(key, value));+ const authHeaders = applyClientAuth(providerInputs, body);++ // measured before sending so a slow response can't make the token look longer-lived than it is+ const requestedAt = Date.now();++ let responseData: unknown;+ try {+ const response = await safeRequest.post<unknown>(providerInputs.tokenUrl, body.toString(), {+ headers: {+ ...authHeaders,+ "Content-Type": "application/x-www-form-urlencoded",+ Accept: "application/json"+ },+ timeout: REQUEST_TIMEOUT_MS,+ // a retried token request can mint a token whose response we never see, and so never revoke+ "axios-retry": { retries: 0 }+ });+ responseData = response.data;+ } catch (err) {+ const { message } = describeUpstreamError(err);+ throw new BadRequestError({+ message: `The authorization server at ${sanitizeUrlForLog(providerInputs.tokenUrl)} rejected the token request: ${redact(message, getClientCredentialSecrets(providerInputs))}`+ });+ }++ const parsed = OAuthTokenResponseSchema.safeParse(parseJsonBody(responseData));+ if (!parsed.success) {+ throw new BadRequestError({+ message: `The authorization server at ${sanitizeUrlForLog(providerInputs.tokenUrl)} returned a token response without an access_token. Check that the token URL points to an OAuth 2.0 token endpoint.`+ });+ }++ const { access_token: accessToken, token_type: tokenType, scope, expires_in: expiresIn } = parsed.data;++ return {+ accessToken,+ tokenType,+ scope,+ requestedAt,+ expiresAt: resolveExpiresAt(accessToken, expiresIn, requestedAt)+ };+ };++ const $revokeToken = async (providerInputs: TOAuthProviderInputs, accessToken: string) => {+ const body = new URLSearchParams({ token: accessToken, token_type_hint: "access_token" });+ const authHeaders = applyClientAuth(providerInputs, body);++ try {+ await safeRequest.post(providerInputs.revocationUrl, body.toString(), {+ headers: {+ ...authHeaders,+ "Content-Type": "application/x-www-form-urlencoded",+ Accept: "application/json"+ },+ timeout: REQUEST_TIMEOUT_MS+ });+ } catch (err) {+ const { code, status, message } = describeUpstreamError(err);+ const sanitizedMessage = redact(message, [...getClientCredentialSecrets(providerInputs), accessToken]);+ const revocationUrl = sanitizeUrlForLog(providerInputs.revocationUrl);++ if (code === "unsupported_token_type") {+ throw new BadRequestError({+ message: `The authorization server at ${revocationUrl} doesn't support revoking access tokens (unsupported_token_type). The OAuth dynamic secret requires RFC 7009 access token revocation.`+ });+ }+ if (status === 503) {+ throw new BadRequestError({+ message: `The revocation endpoint at ${revocationUrl} is temporarily unavailable (HTTP 503). Try again later.`+ });+ }+ throw new BadRequestError({+ message: `Failed to revoke the access token at ${revocationUrl}: ${sanitizedMessage}`+ });+ }+ };++ const $assertLeaseWithinTokenLifetime = (token: TIssuedToken, leaseEndsAt: number, ttlLabel: string) => {+ if (token.expiresAt === null) return;+ if (leaseEndsAt <= token.expiresAt + TTL_TOLERANCE_MS) return;++ const ttlSeconds = Math.ceil((leaseEndsAt - token.requestedAt) / 1000);+ const lifetimeSeconds = Math.max(Math.floor((token.expiresAt - token.requestedAt) / 1000), 0);+ throw new BadRequestError({+ message: `The ${ttlLabel} (${ttlSeconds}s) is longer than the lifetime of the access tokens the authorization server issues (${lifetimeSeconds}s). Set the ${ttlLabel} to ${lifetimeSeconds}s or less.`+ });+ };++ const $revokeBestEffort = async (providerInputs: TOAuthProviderInputs, accessToken: string, reason: string) => {+ try {+ await $revokeToken(providerInputs, accessToken);+ } catch (err) {+ logger.warn(+ `OAuth dynamic secret: failed to revoke token after ${reason} [revocationUrl=${sanitizeUrlForLog(providerInputs.revocationUrl)}]: ${(err as Error)?.message}`+ );+ }+ };++ const validateConnection = async (+ inputs: unknown,+ { defaultTTL, maxTTL }: { projectId: string; defaultTTL?: string; maxTTL?: string | null }+ ) => {+ const providerInputs = await $parseInputs(inputs);+ const token = await $requestToken(providerInputs);++ try {+ if (defaultTTL) $assertLeaseWithinTokenLifetime(token, token.requestedAt + ms(defaultTTL), "default TTL");+ if (maxTTL) $assertLeaseWithinTokenLifetime(token, token.requestedAt + ms(maxTTL), "max TTL");+ } catch (err) {+ await $revokeBestEffort(providerInputs, token.accessToken, "rejecting the configuration");+ throw err;+ }++ try {+ await $revokeToken(providerInputs, token.accessToken);+ } catch (err) {+ throw new BadRequestError({+ message: `Infisical got a test token from the authorization server but couldn't revoke it, so it couldn't revoke lease tokens either. ${(err as Error)?.message}`+ });+ }++ return true;+ };++ const create = async ({ inputs, expireAt }: { inputs: unknown; expireAt: number }) => {+ const providerInputs = await $parseInputs(inputs);+ const token = await $requestToken(providerInputs);++ try {+ $assertLeaseWithinTokenLifetime(token, expireAt, "lease TTL");+ } catch (err) {+ await $revokeBestEffort(providerInputs, token.accessToken, "rejecting the lease TTL");+ throw err;+ }++ return {+ entityId: alphaNumericNanoId(32),+ data: {+ ACCESS_TOKEN: token.accessToken,+ ...(token.tokenType ? { TOKEN_TYPE: token.tokenType } : {}),+ ...(token.expiresAt !== null ? { EXPIRES_AT: new Date(token.expiresAt).toISOString() } : {}),+ ...(token.scope ? { SCOPE: token.scope } : {})+ }+ };+ };++ const revoke = async (inputs: unknown, entityId: string, metadata: { leaseData?: Record<string, string> }) => {+ const providerInputs = await $parseInputs(inputs);++ const leaseData = OAuthLeaseDataSchema.safeParse(metadata.leaseData);+ if (!leaseData.success) {+ throw new BadRequestError({+ message:+ "This lease has no stored access token, so Infisical can't revoke it. Force delete the lease to remove it; the token stays valid until it expires."+ });+ }++ await $revokeToken(providerInputs, leaseData.data.ACCESS_TOKEN);+ return { entityId };+ };++ const renew = async (): Promise<{ entityId: string }> => {+ throw new BadRequestError({+ message: "OAuth access tokens can't be extended. Create a new lease to get a new token."+ });+ };++ return {+ persistedLeaseFields: ["ACCESS_TOKEN"],+ validateProviderInputs,+ validateConnection,+ create,+ revoke,+ renew+ };+};diff --git a/backend/src/ee/services/dynamic-secret/providers/redact.test.ts b/backend/src/ee/services/dynamic-secret/providers/redact.test.tsnew file mode 100644index 0000000000..4fc5e20d7a--- /dev/null+++ b/backend/src/ee/services/dynamic-secret/providers/redact.test.ts@@ -0,0 +1,93 @@+import { describe, expect, test } from "vitest";++import { SshCertKeyAlgorithm } from "@app/lib/ssh";++import { DynamicSecretProviders, OAuthClientAuthMethod, OAuthGrantType } from "./models";+import { DYNAMIC_SECRET_SECRET_FIELDS, redactStoredInputs, restoreOmittedSecretFields } from "./redact";++const oauthStoredInputs = {+ grantType: OAuthGrantType.ClientCredentials,+ tokenUrl: "https://auth.example.com/token",+ revocationUrl: "https://auth.example.com/revoke",+ clientId: "client-id",+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretPost, clientSecret: "stored-secret" },+ extraParams: []+};++describe("redactStoredInputs", () => {+ const sshStoredInputs = {+ caPrivateKey: "-----BEGIN OPENSSH PRIVATE KEY-----\nca-key-material\n-----END OPENSSH PRIVATE KEY-----",+ caPublicKey: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5 ca@infisical",+ principals: ["ubuntu"],+ keyAlgorithm: SshCertKeyAlgorithm.ED25519,+ caKeyAlgorithm: SshCertKeyAlgorithm.ED25519+ };++ test("withholds the SSH CA private key and keeps the rest of the configuration", () => {+ const redacted = redactStoredInputs(DynamicSecretProviders.Ssh, sshStoredInputs);++ expect(redacted).toStrictEqual({+ caPublicKey: sshStoredInputs.caPublicKey,+ principals: sshStoredInputs.principals,+ keyAlgorithm: SshCertKeyAlgorithm.ED25519,+ caKeyAlgorithm: SshCertKeyAlgorithm.ED25519+ });+ expect(JSON.stringify(redacted)).not.toContain("ca-key-material");+ });++ test("returns inputs untouched for a provider that declares no secret fields", () => {+ const sqlStoredInputs = { host: "db.internal", username: "admin", password: "hunter2" };++ expect(redactStoredInputs(DynamicSecretProviders.SqlDatabase, sqlStoredInputs)).toStrictEqual(sqlStoredInputs);+ });++ test("tolerates stored input that is not an object", () => {+ expect(redactStoredInputs(DynamicSecretProviders.Ssh, null)).toBeNull();+ expect(redactStoredInputs(DynamicSecretProviders.Ssh, undefined)).toBeUndefined();+ });++ test("declares a secret field list for every provider", () => {+ const declared = Object.keys(DYNAMIC_SECRET_SECRET_FIELDS).sort();++ expect(declared).toStrictEqual(Object.values(DynamicSecretProviders).sort());+ });++ test("withholds a nested secret field and keeps its siblings", () => {+ const redacted = redactStoredInputs(DynamicSecretProviders.OAuth, oauthStoredInputs);++ expect(redacted).toStrictEqual({+ ...oauthStoredInputs,+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretPost }+ });+ expect(JSON.stringify(redacted)).not.toContain("stored-secret");+ });+});++describe("restoreOmittedSecretFields", () => {+ test("restores a nested secret the edit left out", () => {+ const restored = restoreOmittedSecretFields(DynamicSecretProviders.OAuth, oauthStoredInputs, {+ ...oauthStoredInputs,+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretBasic }+ });++ expect(restored).toStrictEqual({+ ...oauthStoredInputs,+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretBasic, clientSecret: "stored-secret" }+ });+ });++ test("keeps a secret the edit supplied", () => {+ const edited = {+ ...oauthStoredInputs,+ clientAuth: { method: OAuthClientAuthMethod.ClientSecretPost, clientSecret: "rotated-secret" }+ };++ expect(restoreOmittedSecretFields(DynamicSecretProviders.OAuth, oauthStoredInputs, edited)).toStrictEqual(edited);+ });++ test("leaves inputs untouched for a provider that declares no secret fields", () => {+ const edited = { host: "db.internal" };++ expect(restoreOmittedSecretFields(DynamicSecretProviders.SqlDatabase, { password: "x" }, edited)).toBe(edited);+ });+});diff --git a/backend/src/ee/services/dynamic-secret/providers/redact.ts b/backend/src/ee/services/dynamic-secret/providers/redact.tsnew file mode 100644index 0000000000..9c40c794f7--- /dev/null+++ b/backend/src/ee/services/dynamic-secret/providers/redact.ts@@ -0,0 +1,83 @@+import { DynamicSecretProviders } from "./models";++export const DYNAMIC_SECRET_SECRET_FIELDS: Record<DynamicSecretProviders, readonly string[]> = {+ [DynamicSecretProviders.Ssh]: ["caPrivateKey"],+ [DynamicSecretProviders.SqlDatabase]: [],+ [DynamicSecretProviders.Clickhouse]: [],+ [DynamicSecretProviders.Cassandra]: [],+ [DynamicSecretProviders.AwsIam]: [],+ [DynamicSecretProviders.Redis]: [],+ [DynamicSecretProviders.AwsElastiCache]: [],+ [DynamicSecretProviders.AwsMemoryDb]: [],+ [DynamicSecretProviders.MongoAtlas]: [],+ [DynamicSecretProviders.ElasticSearch]: [],+ [DynamicSecretProviders.MongoDB]: [],+ [DynamicSecretProviders.RabbitMq]: [],+ [DynamicSecretProviders.AzureEntraID]: [],+ [DynamicSecretProviders.AzureSqlDatabase]: [],+ [DynamicSecretProviders.Ldap]: [],+ [DynamicSecretProviders.SapHana]: [],+ [DynamicSecretProviders.Snowflake]: [],+ [DynamicSecretProviders.Totp]: [],+ [DynamicSecretProviders.SapAse]: [],+ [DynamicSecretProviders.Kubernetes]: [],+ [DynamicSecretProviders.Vertica]: [],+ [DynamicSecretProviders.GcpIam]: [],+ [DynamicSecretProviders.Github]: [],+ [DynamicSecretProviders.Couchbase]: [],+ [DynamicSecretProviders.Milvus]: [],+ [DynamicSecretProviders.IbmApiConnect]: [],+ [DynamicSecretProviders.Tailscale]: [],+ [DynamicSecretProviders.OAuth]: ["clientAuth.clientSecret"]+};++const isPlainObject = (value: unknown): value is Record<string, unknown> =>+ typeof value === "object" && value !== null && !Array.isArray(value);++const omitPath = (value: unknown, [head, ...rest]: string[]): unknown => {+ if (!isPlainObject(value) || !(head in value)) return value;+ if (!rest.length) return Object.fromEntries(Object.entries(value).filter(([field]) => field !== head));+ return { ...value, [head]: omitPath(value[head], rest) };+};++const getPath = (value: unknown, path: string[]): unknown =>+ path.reduce<unknown>((current, segment) => (isPlainObject(current) ? current[segment] : undefined), value);++const setPath = (+ value: Record<string, unknown>,+ [head, ...rest]: string[],+ fieldValue: unknown+): Record<string, unknown> => {+ if (!rest.length) return { ...value, [head]: fieldValue };+ const child = value[head];+ if (!isPlainObject(child)) return value;+ return { ...value, [head]: setPath(child, rest, fieldValue) };+};++export const redactStoredInputs = (type: DynamicSecretProviders, inputs: unknown): unknown => {+ const secretFields = DYNAMIC_SECRET_SECRET_FIELDS[type];+ if (!secretFields?.length || !isPlainObject(inputs)) return inputs;++ return secretFields.reduce<unknown>((acc, field) => omitPath(acc, field.split(".")), inputs);+};++// reads never return secret fields, so an edit that leaves one out keeps the stored value; the provider+// schema drops it again if the edit switched to a shape that has no such field+export const restoreOmittedSecretFields = (+ type: DynamicSecretProviders,+ storedInputs: object,+ newInputs: object+): object => {+ const secretFields = DYNAMIC_SECRET_SECRET_FIELDS[type];+ if (!secretFields?.length) return newInputs;++ return secretFields.reduce<Record<string, unknown>>(+ (acc, field) => {+ const path = field.split(".");+ const storedValue = getPath(storedInputs, path);+ if (storedValue === undefined || getPath(acc, path) !== undefined) return acc;+ return setPath(acc, path, storedValue);+ },+ newInputs as Record<string, unknown>+ );+};diff --git a/backend/src/server/routes/sanitizedSchemas.ts b/backend/src/server/routes/sanitizedSchemas.tsindex 6d2bde616b..ef048e3f01 100644--- a/backend/src/server/routes/sanitizedSchemas.ts+++ b/backend/src/server/routes/sanitizedSchemas.ts@@ -2,6 +2,7 @@ import { z } from "zod";import {CertificateAuthoritiesSchema,+ DynamicSecretLeasesSchema,DynamicSecretsSchema,HoneyTokensSchema,IdentityProjectAdditionalPrivilegeSchema,@@ -282,6 +283,10 @@ export const SanitizedDynamicSecretSchema = DynamicSecretsSchema.omit({metadata: ResourceMetadataNonEncryptionSchema.optional()});+export const SanitizedDynamicSecretLeaseSchema = DynamicSecretLeasesSchema.omit({+ encryptedLeaseData: true+});+export const SanitizedHoneyTokenSchema = HoneyTokensSchema.pick({id: true,name: true,