Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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;