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(secret-sync): reject a recursive sync with duplicate names at create
Calvin3deb4449a884
diff --git a/backend/e2e-test/routes/v1/secret-sync-recursive-duplicates.spec.ts b/backend/e2e-test/routes/v1/secret-sync-recursive-duplicates.spec.tsnew file mode 100644index 0000000000..221c8714ec--- /dev/null+++ b/backend/e2e-test/routes/v1/secret-sync-recursive-duplicates.spec.ts@@ -0,0 +1,160 @@+import { randomUUID } from "node:crypto";++import { createFolder } from "e2e-test/testUtils/folders";+import {+ createAwsAppConnection,+ createSecretSync,+ deleteAppConnection,+ deleteSecretSync+} from "e2e-test/testUtils/secret-syncs";+import { createSecretV2 } from "e2e-test/testUtils/secrets";++import { TableName } from "@app/db/schemas";+import { initEnvConfig } from "@app/lib/config/env";+import { initLogger, logger } from "@app/lib/logger";+import { SecretSyncInitialSyncBehavior } from "@app/services/secret-sync/secret-sync-enums";++// A destination that stores secrets in one flat list cannot hold the same name twice, so a+// recursive sync whose subtree reuses a name is broken from the moment it is saved. The+// job-time check still exists for the sync that only clashes later.++const ENV = "dev";+const REGION = "us-east-1";++const adminHeaders = { authorization: `Bearer ${jwtAuthToken}` };++describe("A recursive secret sync is refused when two folders use the same secret name", async () => {+ vi.setConfig({ testTimeout: 30_000, hookTimeout: 30_000 });++ let projectId: string;+ let connectionId: string;+ const createdSyncIds: string[] = [];++ const newSync = async (dto: { name: string; recursive: boolean; expectStatusCode?: number }) => {+ const result = await createSecretSync({+ name: dto.name,+ projectId,+ connectionId,+ environmentSlug: ENV,+ secretPath: "/backend",+ region: REGION,+ destinationPath: `/${dto.name}/`,+ initialSyncBehavior: SecretSyncInitialSyncBehavior.OverwriteDestination,+ recursive: dto.recursive,+ isAutoSyncEnabled: false,+ authToken: jwtAuthToken,+ expectStatusCode: dto.expectStatusCode+ });++ if (result.secretSync) createdSyncIds.push(result.secretSync.id);++ return result;+ };++ beforeAll(async () => {+ initLogger();+ await initEnvConfig(testHsmService, testKmsRootConfigDAL, testSuperAdminDAL, logger);++ const suffix = randomUUID().slice(0, 8);++ const projectRes = await testServer.inject({+ method: "POST",+ url: "/api/v1/projects",+ headers: adminHeaders,+ body: { projectName: `secret-sync-recursive-dupes-${suffix}` }+ });+ expect(projectRes.statusCode).toBe(200);+ projectId = projectRes.json().project.id as string;++ connectionId = await createAwsAppConnection({+ name: `secret-sync-recursive-dupes-${suffix}`,+ authToken: jwtAuthToken+ });++ await createFolder({+ authToken: jwtAuthToken,+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/",+ name: "backend"+ });+ await createFolder({+ authToken: jwtAuthToken,+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/backend",+ name: "api"+ });++ await createSecretV2({+ authToken: jwtAuthToken,+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/backend",+ key: "DB_URL",+ value: "postgres://backend"+ });+ await createSecretV2({+ authToken: jwtAuthToken,+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/backend/api",+ key: "DB_URL",+ value: "postgres://api"+ });+ });++ afterAll(async () => {+ for (const syncId of createdSyncIds) {+ // eslint-disable-next-line no-await-in-loop+ await deleteSecretSync({ syncId, authToken: jwtAuthToken });+ }++ await deleteAppConnection({ connectionId, authToken: jwtAuthToken });+ await testServer.inject({+ method: "DELETE",+ url: `/api/v1/projects/${projectId}`,+ headers: adminHeaders+ });+ });++ test("creating it is refused, naming the secret and both folders", async () => {+ const { error } = await newSync({ name: "recursive-duplicate", recursive: true, expectStatusCode: 400 });++ expect(error.message).toContain("DB_URL");+ expect(error.message).toContain("/backend");+ expect(error.message).toContain("/backend/api");+ });++ test("the refused request leaves no sync behind", async () => {+ const rows = await testDb(TableName.SecretSync).where({ projectId, name: "recursive-duplicate" });++ expect(rows).toHaveLength(0);+ });++ test("creating the same sync without subfolders succeeds", async () => {+ const { secretSync } = await newSync({ name: "non-recursive-duplicate", recursive: false });++ expect(secretSync).toEqual(expect.objectContaining({ name: "non-recursive-duplicate" }));+ });++ test("turning subfolders on for an existing sync is refused", async () => {+ const { secretSync } = await newSync({ name: "recursive-turned-on-later", recursive: false });++ const res = await testServer.inject({+ method: "PATCH",+ url: `/api/v1/secret-syncs/aws-parameter-store/${secretSync!.id}`,+ headers: adminHeaders,+ body: {+ syncOptions: {+ initialSyncBehavior: SecretSyncInitialSyncBehavior.OverwriteDestination,+ recursive: true+ }+ }+ });++ expect(res.statusCode).toBe(400);+ expect(res.json().message).toContain("DB_URL");+ expect(res.json().message).toContain("/backend/api");+ });+});diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.tsindex 022c4ea2ec..b626327126 100644--- a/backend/src/server/routes/index.ts+++ b/backend/src/server/routes/index.ts@@ -3169,6 +3169,8 @@ export const registerRoutes = async (orgDAL,folderDAL,projectEnvDAL,+ projectDAL,+ projectFolderGrantDAL,secretSyncQueue,projectBotService,keyStore,diff --git a/backend/src/services/secret-sync/secret-sync-service.ts b/backend/src/services/secret-sync/secret-sync-service.tsindex cfab649988..f98cd82e1f 100644--- a/backend/src/services/secret-sync/secret-sync-service.ts+++ b/backend/src/services/secret-sync/secret-sync-service.ts@@ -20,18 +20,22 @@ import { OrgServiceActor } from "@app/lib/types";import { decryptAppConnectionCredentials } from "@app/services/app-connection/app-connection-fns";import { TAppConnectionServiceFactory } from "@app/services/app-connection/app-connection-service";import { TAppConnection } from "@app/services/app-connection/app-connection-types";+import { KmsDataKey } from "@app/services/kms/kms-types";import { TOrgDALFactory } from "@app/services/org/org-dal";+import { TProjectDALFactory } from "@app/services/project/project-dal";import { TProjectBotServiceFactory } from "@app/services/project-bot/project-bot-service";import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";+import { TProjectFolderGrantDALFactory } from "@app/services/project-folder-grant/project-folder-grant-dal";import { TSecretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";import { SecretSync } from "@app/services/secret-sync/secret-sync-enums";+import { SecretSyncError } from "@app/services/secret-sync/secret-sync-errors";import {enterpriseSyncCheck,listSecretSyncOptions,preSaveTransformDestinationConfig,preSaveTransformSyncOptions} from "@app/services/secret-sync/secret-sync-fns";-import { resolveSyncFolders } from "@app/services/secret-sync/secret-sync-recursive-fns";+import { buildSyncPayload, resolveSyncFolders } from "@app/services/secret-sync/secret-sync-recursive-fns";import {SecretSyncStatus,TCheckDuplicateDestinationDTO,@@ -47,6 +51,7 @@ import {TTriggerSecretSyncSyncSecretsByIdDTO,TUpdateSecretSyncDTO} from "@app/services/secret-sync/secret-sync-types";+import { expandSecretReferencesFactory } from "@app/services/secret-v2-bridge/secret-reference-fns";import { TAppConnectionDALFactory } from "../app-connection/app-connection-dal";import { TKmsServiceFactory } from "../kms/kms-service";@@ -64,15 +69,20 @@ import { TSecretSyncQueueFactory } from "./secret-sync-queue";type TSecretSyncServiceFactoryDep = {secretSyncDAL: TSecretSyncDALFactory;secretImportDAL: TSecretImportDALFactory;- secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "findOne">;+ secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "findOne" | "find" | "findByFolderId" | "findByFolderIds">;appConnectionDAL: Pick<TAppConnectionDALFactory, "findById" | "updateById">;appConnectionService: Pick<TAppConnectionServiceFactory, "validateAppConnectionUsageById">;kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;permissionService: Pick<TPermissionServiceFactory, "getProjectPermission" | "getOrgPermission">;- orgDAL: Pick<TOrgDALFactory, "findById">;+ orgDAL: Pick<TOrgDALFactory, "findById" | "findOrgById">;projectBotService: Pick<TProjectBotServiceFactory, "getBotKey">;- folderDAL: Pick<TSecretFolderDALFactory, "findByProjectId" | "findById" | "findBySecretPath" | "find">;+ folderDAL: Pick<+ TSecretFolderDALFactory,+ "findByProjectId" | "findById" | "findBySecretPath" | "find" | "findByManySecretPath"+ >;projectEnvDAL: Pick<TProjectEnvDALFactory, "findOne">;+ projectDAL: Pick<TProjectDALFactory, "find">;+ projectFolderGrantDAL: Pick<TProjectFolderGrantDALFactory, "find">;keyStore: Pick<TKeyStoreFactory, "getItem">;secretSyncQueue: Pick<TSecretSyncQueueFactory,@@ -87,6 +97,8 @@ export const secretSyncServiceFactory = ({secretSyncDAL,folderDAL,projectEnvDAL,+ projectDAL,+ projectFolderGrantDAL,secretImportDAL,secretV2BridgeDAL,appConnectionDAL,@@ -177,6 +189,88 @@ export const secretSyncServiceFactory = ({}};+ // Flattening a subtree onto a destination that holds one flat list can produce two secrets with+ // the same destination key. flatten() is what detects that, and the job runs it on every sync, so+ // calling it here means a user reads the same sentence at save time and when the sync later drifts+ // into the same state.+ const $assertSyncableAtDestination = async ({+ projectId,+ actorOrgId,+ environment,+ sourcePath,+ sourceFolderId,+ recursive,+ keySchema+ }: {+ projectId: string;+ actorOrgId: string;+ environment: string;+ sourcePath: string;+ sourceFolderId: string;+ recursive: boolean;+ keySchema?: string;+ }) => {+ if (!recursive) return;++ const { decryptor: secretManagerDecryptor } = await kmsService.createCipherPairWithDataKey({+ type: KmsDataKey.SecretManager,+ projectId+ });++ const decryptSecretValue = (value?: Buffer | null) =>+ value ? secretManagerDecryptor({ cipherTextBlob: value }).toString() : "";++ const { expandSecretReferences } = expandSecretReferencesFactory({+ decryptSecretValue,+ secretDAL: secretV2BridgeDAL,+ folderDAL,+ projectId,+ canExpandValue: () => true,+ actorOrgId,+ orgDAL,+ licenseService,+ projectFolderGrantDAL,+ projectDAL,+ kmsService+ });++ try {+ const payload = await buildSyncPayload(+ {+ folderDAL,+ projectEnvDAL,+ secretV2BridgeDAL,+ secretImportDAL,+ expandSecretReferences,+ decryptSecretValue,+ fnSecretsV2FromImportsDeps: {+ projectFolderGrantDAL,+ actorOrgId,+ orgDAL,+ licenseService,+ kmsService+ }+ },+ {+ projectId,+ environment,+ sourcePath,+ sourceFolderId,+ recursive,+ keySchema,+ includeImports: true,+ dedupeForRemoval: false+ }+ );++ payload.flatten();+ } catch (error) {+ if (error instanceof SecretSyncError) throw new BadRequestError({ message: error.message });++ throw error;+ }+ };+const listSecretSyncsByProjectId = async ({ projectId, destination }: TListSecretSyncsByProjectId,actor: OrgServiceActor@@ -477,12 +571,27 @@ export const secretSyncServiceFactory = ({message: `Could not find folder with path "${secretPath}" in environment "${environment}" for project with ID "${projectId}"`});+ const requestedSyncOptions = params.syncOptions as { recursive?: boolean; keySchema?: string } | undefined;+ const isRecursive = Boolean(requestedSyncOptions?.recursive);+await $assertCanReadSyncedFolders(projectPermission, {projectId,environment,sourcePath: secretPath,sourceFolderId: folder.id,- recursive: Boolean((params.syncOptions as { recursive?: boolean } | undefined)?.recursive)+ recursive: isRecursive+ });++ // Runs after the permission check above: the conflict it raises names every folder beneath the+ // source, including ones this actor is denied on.+ await $assertSyncableAtDestination({+ projectId,+ actorOrgId: actor.orgId,+ environment,+ sourcePath: secretPath,+ sourceFolderId: folder.id,+ recursive: isRecursive,+ keySchema: requestedSyncOptions?.keySchema});// getProjectPermission above throws NotFoundError if the project doesn't exist and@@ -708,6 +817,18 @@ export const secretSyncServiceFactory = ({sourceFolderId: folderId,recursive: isRecursive});++ await $assertSyncableAtDestination({+ projectId: secretSync.projectId,+ actorOrgId: actor.orgId,+ environment: updatedEnvironment,+ sourcePath: updatedSecretPath,+ sourceFolderId: folderId,+ recursive: isRecursive,+ keySchema:+ (params.syncOptions as { keySchema?: string } | undefined)?.keySchema ??+ (secretSync.syncOptions as { keySchema?: string } | undefined)?.keySchema+ });}const isAutoSyncEnabled = params.isAutoSyncEnabled ?? secretSync.isAutoSyncEnabled;