Skip to content

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

fix(secret-value-tracking): address review on value search and the backfill

Calvin467dc899f416
diff --git a/backend/e2e-test/routes/v1/org-secret-value-tracking.spec.ts b/backend/e2e-test/routes/v1/org-secret-value-tracking.spec.ts
deleted file mode 100644
index f7045c6e88..0000000000
--- a/backend/e2e-test/routes/v1/org-secret-value-tracking.spec.ts
+++ /dev/null
@@ -1,423 +0,0 @@
-import { packRules } from "@casl/ability/extra";
-import { createIsolatedOrgAndProject } from "e2e-test/testUtils/fixtures";
-import { createSecretV2, updateSecretV2 } from "e2e-test/testUtils/secrets";
-import jwt from "jsonwebtoken";
-
-import { AccessScope, OrgMembershipRole, OrgMembershipStatus, SecretType, TableName } from "@app/db/schemas";
-import {
- OrgPermissionSecretsManagementInsightsActions,
- OrgPermissionSubjects
-} from "@app/ee/services/permission/org-permission";
-import { AuthMethod, AuthTokenType } from "@app/services/auth/auth-type";
-
-const ENV = "dev";
-
-type TStatus = {
- status: string;
- message?: string;
- projectsTotal: number;
- projectsDone: number;
- secretsProcessed: number;
-};
-
-const enable = (authToken: string) =>
- testServer.inject({
- method: "POST",
- url: "/api/v1/organization/secret-value-tracking",
- headers: { authorization: `Bearer ${authToken}` }
- });
-
-const status = async (authToken: string): Promise<TStatus> => {
- const res = await testServer.inject({
- method: "GET",
- url: "/api/v1/organization/secret-value-tracking/status",
- headers: { authorization: `Bearer ${authToken}` }
- });
- expect(res.statusCode).toBe(200);
- return res.json();
-};
-
-const searchByValue = (secretValue: string, authToken: string) =>
- testServer.inject({
- method: "POST",
- url: "/api/v4/secrets/search-by-value",
- headers: { authorization: `Bearer ${authToken}` },
- body: { secretValue }
- });
-
-// Manufactures the state a customer upgrading into this feature is actually in: secrets that were
-// written before the org-scoped digest existed, and an organization that has never run the walk.
-// A test organization cannot otherwise reach it, because it is created complete.
-const makeOrgIncomplete = async (orgId: string) => {
- await testDb(TableName.Organization).where({ id: orgId }).update({ orgWideSecretValueTrackingEnabled: false });
- await testDb(TableName.SecretV2)
- .whereIn(
- `${TableName.SecretV2}.folderId`,
- testDb(TableName.SecretFolder)
- .join(TableName.Environment, `${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`)
- .join(TableName.Project, `${TableName.Environment}.projectId`, `${TableName.Project}.id`)
- .where(`${TableName.Project}.orgId`, orgId)
- .select(`${TableName.SecretFolder}.id`)
- )
- .update({ secretValueOrgBlindIndex: null });
-};
-
-const listCommits = async (authToken: string, projectId: string) => {
- const res = await testServer.inject({
- method: "GET",
- url: `/api/v1/pit/commits?environment=${ENV}&path=%2F&projectId=${projectId}`,
- headers: { authorization: `Bearer ${authToken}` }
- });
- expect(res.statusCode).toBe(200);
- return res.json();
-};
-
-const rollbackTo = async (authToken: string, projectId: string, commitId: string, folderId: string) => {
- const res = await testServer.inject({
- method: "POST",
- url: `/api/v1/pit/commits/${commitId}/rollback`,
- headers: { authorization: `Bearer ${authToken}` },
- body: { folderId, environment: ENV, projectId, deepRollback: false, message: "rollback under test" }
- });
- expect(res.statusCode).toBe(200);
- return res.json();
-};
-
-const waitForCompletion = async (authToken: string, timeoutMs = 30_000) => {
- const deadline = Date.now() + timeoutMs;
- for (;;) {
- // eslint-disable-next-line no-await-in-loop
- const current = await status(authToken);
- if (current.status === "completed") return current;
- if (current.status === "failed") throw new Error(`Backfill failed: ${current.message ?? "unknown"}`);
- if (Date.now() > deadline) throw new Error(`Backfill did not complete, last status ${current.status}`);
- // eslint-disable-next-line no-await-in-loop
- await new Promise((resolve) => {
- setTimeout(resolve, 250);
- });
- }
-};
-
-// A backfill is refused while one is already in flight for the same scope, so a test that drives a
-// run to completion cannot share an organization with the next one: the previous job may still be
-// finishing when the next enable arrives, and would swallow it. Each such test gets its own.
-const withOwnOrg = async (
- name: string,
- body: (ctx: Awaited<ReturnType<typeof createIsolatedOrgAndProject>>) => Promise<void>
-) => {
- const ctx = await createIsolatedOrgAndProject(name);
- try {
- await body(ctx);
- } finally {
- await ctx.cleanup();
- }
-};
-
-// An org member with no project membership. With `insightsActions` they hold a custom org role
-// granting exactly those Secrets Management Insights actions; without, the built-in member role.
-const createOrgMemberToken = async (
- orgId: string,
- name: string,
- insightsActions?: OrgPermissionSecretsManagementInsightsActions[]
-) => {
- const username = `${name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}@example.com`;
- const [user] = await testDb(TableName.Users)
- .insert({ username, email: username, isGhost: false, isAccepted: true, authMethods: [AuthMethod.EMAIL] })
- .returning("*");
- const [orgMembership] = await testDb(TableName.Membership)
- .insert({
- scope: AccessScope.Organization,
- scopeOrgId: orgId,
- actorUserId: user.id,
- status: OrgMembershipStatus.Accepted,
- isActive: true
- })
- .returning("*");
-
- if (insightsActions) {
- const [role] = await testDb(TableName.Role)
- .insert({
- name: username,
- slug: `role-${user.id}`,
- orgId,
- permissions: JSON.stringify(
- packRules([{ subject: OrgPermissionSubjects.SecretsManagementInsights, action: insightsActions }] as never)
- )
- })
- .returning("*");
- await testDb(TableName.MembershipRole).insert({
- membershipId: orgMembership.id,
- role: OrgMembershipRole.Custom,
- customRoleId: role.id
- });
- } else {
- await testDb(TableName.MembershipRole).insert({
- membershipId: orgMembership.id,
- role: OrgMembershipRole.Member
- });
- }
-
- const [tokenVersion] = await testDb(TableName.AuthTokenSession)
- .insert({
- userId: user.id,
- ip: "127.0.0.1",
- userAgent: "test",
- accessVersion: 1,
- refreshVersion: 1,
- lastUsed: new Date()
- })
- .returning("*");
-
- // Signed with jsonwebtoken directly rather than through the crypto wrapper: that module is a
- // singleton the spec worker has not initialised, and this only needs the same claims the test
- // environment mints for the seeded user.
- return jwt.sign(
- {
- authTokenType: AuthTokenType.ACCESS_TOKEN,
- userId: user.id,
- tokenVersionId: tokenVersion.id,
- authMethod: AuthMethod.EMAIL,
- organizationId: orgId,
- accessVersion: 1
- },
- process.env.AUTH_SECRET as string,
- { expiresIn: "1h" }
- );
-};
-
-describe("Org-wide secret value tracking", () => {
- // The walk is a queue round trip per chunk, so it takes longer than the 5s default.
- vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
-
- let orgId: string;
- let projectId: string;
- let authToken: string;
- let cleanup: () => Promise<void>;
-
- beforeAll(async () => {
- ({ orgId, projectId, authToken, cleanup } = await createIsolatedOrgAndProject("org-value-tracking-e2e"));
- });
-
- afterAll(async () => {
- await cleanup();
- });
-
- test("an organization created after this shipped is already tracking", async () => {
- expect((await status(authToken)).status).toBe("completed");
- });
-
- // Re-running a completed backfill is the repair path for every way an unindexed row can get back
- // into a finished org, so it has to be accepted rather than refused as "already enabled".
- test("a completed organization can run the backfill again", async () =>
- withOwnOrg("org-value-tracking-rerun", async (ctx) => {
- expect((await enable(ctx.authToken)).statusCode).toBe(200);
- await waitForCompletion(ctx.authToken);
- expect((await status(ctx.authToken)).status).toBe("completed");
- }));
-
- test("searching by value refuses while tracking is off, and works once the backfill completes", async () =>
- withOwnOrg("org-value-tracking-search", async (ctx) => {
- await createSecretV2({
- workspaceId: ctx.projectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "PREDATES_TRACKING",
- value: "written-before-tracking",
- authToken: ctx.authToken
- });
-
- await makeOrgIncomplete(ctx.orgId);
-
- const refused = await searchByValue("written-before-tracking", ctx.authToken);
- expect(refused.statusCode).toBe(400);
- expect(refused.json().message).toMatch(/org-wide secret value tracking/i);
-
- expect((await enable(ctx.authToken)).statusCode).toBe(200);
-
- const finished = await waitForCompletion(ctx.authToken);
- expect(finished.projectsTotal).toBeGreaterThanOrEqual(1);
- expect(finished.projectsDone).toBeGreaterThanOrEqual(1);
-
- const found = await searchByValue("written-before-tracking", ctx.authToken);
- expect(found.statusCode).toBe(200);
- expect(found.json().secrets.map((secret: { key: string }) => secret.key)).toEqual(["PREDATES_TRACKING"]);
- }));
-
- // The (key, id) cursor exists for this: the unique index on (key, folderId) is partial on
- // type = 'shared', so a personal override shares a key with the shared secret beside it and a
- // key-only cursor would walk past one of them.
- test("a personal override sharing a key with a shared secret is backfilled too", async () =>
- withOwnOrg("org-value-tracking-personal", async (ctx) => {
- await createSecretV2({
- workspaceId: ctx.projectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "SHARED_AND_PERSONAL",
- value: "the-shared-value",
- authToken: ctx.authToken
- });
- await createSecretV2({
- workspaceId: ctx.projectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "SHARED_AND_PERSONAL",
- value: "the-personal-value",
- type: SecretType.Personal,
- authToken: ctx.authToken
- });
-
- await makeOrgIncomplete(ctx.orgId);
- expect((await enable(ctx.authToken)).statusCode).toBe(200);
- await waitForCompletion(ctx.authToken);
-
- const rows = await testDb(TableName.SecretV2)
- .where({ key: "SHARED_AND_PERSONAL" })
- .select("id", "type", "secretValueOrgBlindIndex");
-
- expect(rows).toHaveLength(2);
- rows.forEach((row) => expect(row.secretValueOrgBlindIndex).toEqual(expect.any(String)));
- // Two different values must not collide on one digest.
- expect(new Set(rows.map((row) => row.secretValueOrgBlindIndex)).size).toBe(2);
- }));
-
- // Version rows written before the org digest existed carry none, and a rollback copies a version's
- // digests straight onto the live secret. Without repair that silently puts an unindexed row back
- // into a project the org has already been told is fully searchable.
- test("rolling back to a version written before the org digest existed still leaves the secret findable", async () => {
- const value = `rolled-back-${Date.now()}`;
-
- await createSecretV2({
- workspaceId: projectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "ROLLED_BACK",
- value,
- authToken
- });
- const { commits } = await listCommits(authToken, projectId);
- const target = commits[0];
-
- await updateSecretV2({
- workspaceId: projectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "ROLLED_BACK",
- value: "some-other-value",
- authToken
- });
-
- // Every version row predating the migration looks like this.
- await testDb(TableName.SecretVersionV2).update({ secretValueOrgBlindIndex: null });
-
- await rollbackTo(authToken, projectId, target.id, target.folderId);
-
- const found = await searchByValue(value, authToken);
- expect(found.statusCode).toBe(200);
- expect(found.json().secrets.map((s: { key: string }) => s.key)).toEqual(["ROLLED_BACK"]);
- });
-
- // The security-critical branch: the search reports WHERE a value is used, so a hit in a project the
- // caller cannot read must never reach them, even inside their own organization.
- test("a member who cannot read a project does not see its hits", async () => {
- const shared = `cross-project-${Date.now()}`;
-
- const secondProjectRes = await testServer.inject({
- method: "POST",
- url: "/api/v1/projects",
- headers: { authorization: `Bearer ${authToken}` },
- body: { projectName: `value-tracking-second-${Date.now()}` }
- });
- expect(secondProjectRes.statusCode).toBe(200);
- const secondProjectId = secondProjectRes.json().project.id as string;
-
- await createSecretV2({
- workspaceId: projectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "IN_READABLE",
- value: shared,
- authToken
- });
- await createSecretV2({
- workspaceId: secondProjectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "IN_UNREADABLE",
- value: shared,
- authToken
- });
-
- // A member of the org with no project membership at all.
- const outsiderToken = await createOrgMemberToken(orgId, "value-tracking-outsider");
-
- const owner = await searchByValue(shared, authToken);
- expect(
- owner
- .json()
- .secrets.map((s: { key: string }) => s.key)
- .sort()
- ).toEqual(["IN_READABLE", "IN_UNREADABLE"]);
-
- const outsider = await searchByValue(shared, outsiderToken);
- expect(outsider.statusCode).toBe(200);
- expect(outsider.json().secrets).toEqual([]);
- });
-
- test("reading insights is not enough to see or start the backfill", async () => {
- const readerToken = await createOrgMemberToken(orgId, "value-tracking-reader", [
- OrgPermissionSecretsManagementInsightsActions.Read
- ]);
-
- expect((await enable(readerToken)).statusCode).toBe(403);
-
- const statusRes = await testServer.inject({
- method: "GET",
- url: "/api/v1/organization/secret-value-tracking/status",
- headers: { authorization: `Bearer ${readerToken}` }
- });
- expect(statusRes.statusCode).toBe(403);
- });
-
- test("searching all secret values finds hits in projects the searcher is not a member of", async () => {
- const shared = `search-all-${Date.now()}`;
-
- const otherProjectRes = await testServer.inject({
- method: "POST",
- url: "/api/v1/projects",
- headers: { authorization: `Bearer ${authToken}` },
- body: { projectName: `value-tracking-search-all-${Date.now()}` }
- });
- expect(otherProjectRes.statusCode).toBe(200);
- const otherProjectId = otherProjectRes.json().project.id as string;
-
- await createSecretV2({
- workspaceId: otherProjectId,
- environmentSlug: ENV,
- secretPath: "/",
- key: "IN_A_PROJECT_THEY_ARE_NOT_IN",
- value: shared,
- authToken
- });
-
- const searcherToken = await createOrgMemberToken(orgId, "value-tracking-searcher", [
- OrgPermissionSecretsManagementInsightsActions.SearchAllSecretValues
- ]);
-
- const res = await searchByValue(shared, searcherToken);
- expect(res.statusCode).toBe(200);
- expect(res.json().secrets.map((s: { key: string }) => s.key)).toEqual(["IN_A_PROJECT_THEY_ARE_NOT_IN"]);
- });
-
- test("a second enable while a run is moving does not start a second walk", async () =>
- withOwnOrg("org-value-tracking-double", async (ctx) => {
- await makeOrgIncomplete(ctx.orgId);
-
- expect((await enable(ctx.authToken)).statusCode).toBe(200);
- // Accepted rather than refused: one job id per scope means the second enable is absorbed by
- // the run already in flight instead of starting a competing one.
- expect((await enable(ctx.authToken)).statusCode).toBe(200);
-
- await waitForCompletion(ctx.authToken);
- expect((await status(ctx.authToken)).status).toBe("completed");
- }));
-});
diff --git a/backend/e2e-test/routes/v3/secrets-management.spec.ts b/backend/e2e-test/routes/v3/secrets-management.spec.ts
index 37b2d30122..bb0cb3b1c2 100644
--- a/backend/e2e-test/routes/v3/secrets-management.spec.ts
+++ b/backend/e2e-test/routes/v3/secrets-management.spec.ts
@@ -1,5 +1,5 @@
import { createFakeWebhookServer, TFakeWebhookServer } from "e2e-test/fakes/webhook-destination";
-import { createIsolatedOrgAndProject } from "e2e-test/testUtils/fixtures";
+import { createIsolatedOrgAndProject, createProject } from "e2e-test/testUtils/fixtures";
import { createFolder } from "e2e-test/testUtils/folders";
import { createSecretV2, deleteSecretV2, updateSecretV2 } from "e2e-test/testUtils/secrets";
import { createWebhook, waitForWebhookRun } from "e2e-test/testUtils/webhooks";
@@ -288,14 +288,7 @@ describe("Secrets management", () => {
test("a value held in a second project of the same org is found in both, and project scope narrows it", async () => {
const shared = `across-projects-${Date.now()}`;
- const secondProjectRes = await testServer.inject({
- method: "POST",
- url: "/api/v1/projects",
- headers: { authorization: `Bearer ${authToken}` },
- body: { projectName: "secrets-management-e2e-second" }
- });
- expect(secondProjectRes.statusCode).toBe(200);
- const secondProjectId = secondProjectRes.json().project.id as string;
+ const secondProjectId = await createProject(authToken, "secrets-management-e2e-second");
await createSecretV2({
workspaceId: projectId,
diff --git a/backend/e2e-test/testUtils/fixtures.ts b/backend/e2e-test/testUtils/fixtures.ts
index fe5b561601..8af56c5ee9 100644
--- a/backend/e2e-test/testUtils/fixtures.ts
+++ b/backend/e2e-test/testUtils/fixtures.ts
@@ -2,6 +2,19 @@ import { randomUUID } from "node:crypto";
import { selectOrg } from "./auth";
+// Creates a project in whichever org `authToken` is scoped to, and returns its id. Cleanup comes
+// with the org: deleting it cascades to every project underneath.
+export const createProject = async (authToken: string, projectName: string) => {
+ const res = await testServer.inject({
+ method: "POST",
+ url: "/api/v1/projects",
+ headers: { authorization: `Bearer ${authToken}` },
+ body: { projectName }
+ });
+ expect(res.statusCode).toBe(200);
+ return res.json().project.id as string;
+};
+
// Full isolation per test: a fresh org and project rather than a fresh project inside the shared
// seeded org. Org-scoped state (roles, membership) can't leak between tests either this way, not
// just project-scoped state. Cheaper alternatives exist (see secret-sync.spec.ts's beforeEach,
@@ -26,14 +39,7 @@ export const createIsolatedOrgAndProject = async (namePrefix: string) => {
expect(selectOrgRes.statusCode).toBe(200);
const authToken = selectOrgRes.payload.token as string;
- const projectRes = await testServer.inject({
- method: "POST",
- url: "/api/v1/projects",
- headers: { authorization: `Bearer ${authToken}` },
- body: { projectName: name }
- });
- expect(projectRes.statusCode).toBe(200);
- const projectId = projectRes.json().project.id as string;
+ const projectId = await createProject(authToken, name);
// Hard-deletes the org row; every project/environment/secret/webhook underneath it is reaped by
// FK cascade (org-service.ts:deleteOrganizationById), so there's nothing else to tear down.
diff --git a/backend/src/ee/services/audit-log/audit-log-types.ts b/backend/src/ee/services/audit-log/audit-log-types.ts
index e26f956748..1ee9a55648 100644
--- a/backend/src/ee/services/audit-log/audit-log-types.ts
+++ b/backend/src/ee/services/audit-log/audit-log-types.ts
@@ -1285,6 +1285,7 @@ interface SearchSecretsByValueEvent {
metadata: {
scope: SecretValueSearchScope;
projectId?: string;
+ projectName?: string;
matchCount: number;
};
}
diff --git a/backend/src/server/routes/v4/secret-router.ts b/backend/src/server/routes/v4/secret-router.ts
index c17264a1d5..6df113afff 100644
--- a/backend/src/server/routes/v4/secret-router.ts
+++ b/backend/src/server/routes/v4/secret-router.ts
@@ -1640,7 +1640,7 @@ export const registerSecretRouter = async (server: FastifyZodProvider) => {
operationId: "searchByValue",
tags: [ApiDocsTags.Secrets],
description:
- "Find every secret holding the supplied value, across the organization or within one project, in projects the caller can read.",
+ "Find every secret holding the supplied value, across the organization or within one project. Requires the Search All Secret Values organization permission, and returns matches in every project, including ones the caller is not a member of.",
security: [{ bearerAuth: [] }],
body: z
.object({
@@ -1683,7 +1683,7 @@ export const registerSecretRouter = async (server: FastifyZodProvider) => {
onRequest: verifyAuth([AuthMode.JWT]),
handler: async (req) => {
const { secretValue, scope, projectId } = req.body;
- const result = await server.services.secret.findSecretsByValue(
+ const { secrets, searchedProject } = await server.services.secret.findSecretsByValue(
scope === SecretValueSearchScope.Project && projectId
? { secretValue, scope, projectId }
: { secretValue, scope: SecretValueSearchScope.Organization },
@@ -1697,13 +1697,14 @@ export const registerSecretRouter = async (server: FastifyZodProvider) => {
type: EventType.SEARCH_SECRETS_BY_VALUE,
metadata: {
scope,
- projectId,
- matchCount: result.secrets.length
+ projectId: searchedProject?.id,
+ projectName: searchedProject?.name,
+ matchCount: secrets.length
}
}
});
- return result;
+ return { secrets };
}
});
};
diff --git a/backend/src/services/secret-v2-bridge/secret-v2-bridge-search-by-value.test.ts b/backend/src/services/secret-v2-bridge/secret-v2-bridge-search-by-value.test.ts
new file mode 100644
index 0000000000..f7e087d36c
--- /dev/null
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-search-by-value.test.ts
@@ -0,0 +1,67 @@
+import { createMongoAbility, ForbiddenError } from "@casl/ability";
+import { vi } from "vitest";
+
+import {
+ OrgPermissionSecretsManagementInsightsActions,
+ OrgPermissionSet,
+ OrgPermissionSubjects
+} from "@app/ee/services/permission/org-permission";
+import { ActorType, AuthMethod } from "@app/services/auth/auth-type";
+
+import { secretV2BridgeServiceFactory } from "./secret-v2-bridge-service";
+import { SecretValueSearchScope } from "./secret-v2-bridge-types";
+
+const actor = {
+ type: ActorType.USER,
+ id: "user",
+ authMethod: AuthMethod.EMAIL,
+ orgId: "org",
+ rootOrgId: "org",
+ parentOrgId: "org"
+};
+
+const buildService = (insightsActions: OrgPermissionSecretsManagementInsightsActions[]) => {
+ const orgDAL = { findById: vi.fn(async () => ({ id: "org", orgWideSecretValueTrackingEnabled: true })) };
+ const projectDAL = { find: vi.fn(async () => []), findById: vi.fn() };
+
+ const service = secretV2BridgeServiceFactory({
+ orgDAL,
+ projectDAL,
+ permissionService: {
+ getOrgPermission: vi.fn(async () => ({
+ permission: createMongoAbility<OrgPermissionSet>(
+ insightsActions.map((action) => ({ action, subject: OrgPermissionSubjects.SecretsManagementInsights }))
+ ),
+ memberships: [],
+ hasRole: () => false
+ })),
+ getProjectPermission: vi.fn(),
+ getProjectPermissionFingerprint: vi.fn()
+ }
+ } as unknown as Parameters<typeof secretV2BridgeServiceFactory>[0]);
+
+ return { service, orgDAL, projectDAL };
+};
+
+describe("findSecretsByValue", () => {
+ // The results name secrets in projects the caller may not be a member of, so the org-wide
+ // permission is the only way in. There is no narrower per-project path.
+ test("refuses a caller without Search All Secret Values before reading anything", async () => {
+ const { service, orgDAL, projectDAL } = buildService([OrgPermissionSecretsManagementInsightsActions.Read]);
+
+ await expect(
+ service.findSecretsByValue({ secretValue: "value", scope: SecretValueSearchScope.Organization }, actor)
+ ).rejects.toThrow(ForbiddenError);
+
+ expect(orgDAL.findById).not.toHaveBeenCalled();
+ expect(projectDAL.find).not.toHaveBeenCalled();
+ });
+
+ test("lets a caller with Search All Secret Values through", async () => {
+ const { service } = buildService([OrgPermissionSecretsManagementInsightsActions.SearchAllSecretValues]);
+
+ await expect(
+ service.findSecretsByValue({ secretValue: "value", scope: SecretValueSearchScope.Organization }, actor)
+ ).resolves.toEqual({ secrets: [] });
+ });
+});
diff --git a/backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts b/backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts
index b07f0b8056..f00940c45a 100644
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts
@@ -4056,9 +4056,24 @@ export const secretV2BridgeServiceFactory = ({
// Answers "is this value in use anywhere", the question someone asks when they learn a value is
// compromised. The caller supplies the value, so nothing here reveals a value that was not already
- // known; what it reveals is the locations, which is why each hit is filtered against the actor's
- // permission on the project holding it.
+ // known; what it reveals is the locations, in every project of the org. That is exactly what Search
+ // All Secret Values grants, so it is the only way in: a narrower per-project filter would have to
+ // honour every environment, path, name and tag condition a role can carry, and still leak through
+ // timing whatever it filtered out after the query.
const findSecretsByValue = async (dto: TFindSecretsByValueDTO, actor: OrgServiceActor) => {
+ const { permission } = await permissionService.getOrgPermission({
+ actor: actor.type,
+ actorId: actor.id,
+ orgId: actor.orgId,
+ actorAuthMethod: actor.authMethod,
+ actorOrgId: actor.orgId,
+ scope: OrganizationActionScope.Any
+ });
+ ForbiddenError.from(permission).throwUnlessCan(
+ OrgPermissionSecretsManagementInsightsActions.SearchAllSecretValues,
+ OrgPermissionSubjects.SecretsManagementInsights
+ );
+
// findById rather than findOrgById: findOrgById takes no tx and reads the replica, which is the
// deadlock trigger CODE_QUALITY.md warns about if this ever moves inside a transaction.
const org = await orgDAL.findById(actor.orgId);
@@ -4083,51 +4098,12 @@ export const secretV2BridgeServiceFactory = ({
throw new NotFoundError({ message: `Secrets management project with ID '${dto.projectId}' not found` });
}
- // Resolving what the caller may see BEFORE the search, rather than filtering matches after, is
- // what keeps this from being an oracle: a value held only in projects they cannot read costs the
- // same work, and takes the same time, as a value held nowhere. It also bounds the query, which
- // would otherwise fan out across every project in the org for a value like "true".
- const { permission: orgPermission } = await permissionService.getOrgPermission({
- actor: actor.type,
- actorId: actor.id,
- orgId: actor.orgId,
- actorAuthMethod: actor.authMethod,
- actorOrgId: actor.orgId,
- scope: OrganizationActionScope.Any
- });
- // Holding this is the grant to see a value's locations in every project, member or not.
- const canSearchAllProjects = orgPermission.can(
- OrgPermissionSecretsManagementInsightsActions.SearchAllSecretValues,
- OrgPermissionSubjects.SecretsManagementInsights
- );
-
- const readableProjectIds: string[] = canSearchAllProjects ? candidates.map((project) => project.id) : [];
- await Promise.all(
- (canSearchAllProjects ? [] : candidates).map(async (project) => {
- try {
- const { permission } = await permissionService.getProjectPermission({
- actor: actor.type,
- actorId: actor.id,
- projectId: project.id,
- actorAuthMethod: actor.authMethod,
- actorOrgId: actor.orgId,
- actionProjectType: ActionProjectType.SecretManager
- });
- // DescribeSecret, not a read of the value: this answers where a value the caller already has
- // is used, so the permission that matters is whether they may know the secret exists.
- if (permission.can(ProjectPermissionSecretActions.DescribeSecret, ProjectPermissionSub.Secrets)) {
- readableProjectIds.push(project.id);
- }
- } catch (error) {
- // Only a refusal means "not a member, so this project is simply absent from their results".
- // Anything else is an infrastructure failure, and answering "your value is used nowhere"
- // because the database was busy is the one answer this feature must never give.
- if (!(error instanceof ForbiddenRequestError) && !(error instanceof NotFoundError)) throw error;
- }
- })
- );
+ // Named so the audit entry for a project-scoped search can say which project, not just its id.
+ const searchedProject =
+ dto.scope === SecretValueSearchScope.Project ? { id: candidates[0].id, name: candidates[0].name } : undefined;
- if (!readableProjectIds.length) return { secrets: [] };
+ const projectIds = candidates.map((project) => project.id);
+ if (!projectIds.length) return { secrets: [], searchedProject };
// Every project in an org shares the org data key, so one digest answers for all of them.
const { generateOrgLevelBlindIndex } = await createOrgSecretBlindIndexer({ orgId: actor.orgId, kmsService });
@@ -4135,11 +4111,11 @@ export const secretV2BridgeServiceFactory = ({
const visible = await secretDAL.findSecretsWithMatchingValue({
orgId: actor.orgId,
- projectIds: readableProjectIds,
+ projectIds,
secretValueDigest,
limit: SECRET_VALUE_SEARCH_LIMIT
});
- if (!visible.length) return { secrets: [] };
+ if (!visible.length) return { secrets: [], searchedProject };
const pathsByProject = await Promise.all(
[...new Set(visible.map((match) => match.projectId))].map((projectId) => {
@@ -4153,6 +4129,7 @@ export const secretV2BridgeServiceFactory = ({
});
return {
+ searchedProject,
secrets: visible.map((match) => ({
key: match.key,
projectId: match.projectId,
diff --git a/backend/src/services/secret-value-tracking/secret-value-tracking-queue.test.ts b/backend/src/services/secret-value-tracking/secret-value-tracking-queue.test.ts
index bb98b14dc1..2422d4dd49 100644
--- a/backend/src/services/secret-value-tracking/secret-value-tracking-queue.test.ts
+++ b/backend/src/services/secret-value-tracking/secret-value-tracking-queue.test.ts
@@ -163,7 +163,9 @@ describe("the backfill job", () => {
expect(harness.flaggedOrgs).toEqual([ORG_ID]);
});
- test("a project with no folders at all is skipped rather than flagged", async () => {
+ // A project with no folders holds no secrets to index, and every secret written later carries both
+ // digests, so leaving it unflagged would only keep project duplicate detection off for no reason.
+ test("a project with no folders at all is still flagged", async () => {
const harness = makeHarness({
projectIds: ["empty", "p2"],
foldersByProject: { empty: [], p2: ["f2"] },
@@ -172,7 +174,15 @@ describe("the backfill job", () => {
await harness.run();
- expect(harness.flaggedProjects).toEqual(["p2"]);
+ expect([...harness.flaggedProjects].sort()).toEqual(["empty", "p2"]);
+ });
+
+ test("an org with no secrets management projects is still flagged", async () => {
+ const harness = makeHarness({ projectIds: [], foldersByProject: {} });
+
+ await harness.run();
+
+ expect(harness.flaggedOrgs).toEqual([ORG_ID]);
});
test("an org with nothing in it still finishes and is flagged", async () => {
diff --git a/backend/src/services/secret-value-tracking/secret-value-tracking-queue.ts b/backend/src/services/secret-value-tracking/secret-value-tracking-queue.ts
index 6029b3b0d8..5774b3fe6e 100644
--- a/backend/src/services/secret-value-tracking/secret-value-tracking-queue.ts
+++ b/backend/src/services/secret-value-tracking/secret-value-tracking-queue.ts
@@ -113,6 +113,8 @@ export const secretValueTrackingQueueFactory = ({
: await projectDAL.find({ orgId: scope.orgId, type: ProjectType.SecretManager });
if (!projects.length) {
+ // Nothing to index is still a finished org: every secret it writes from here carries both digests.
+ if (scope.scope === "org") await orgDAL.updateById(scope.orgId, { orgWideSecretValueTrackingEnabled: true });
logger.info(`SecretValueTrackingBackfill: nothing to walk [scopeId=${scopeId}]`);
return;
}
@@ -154,7 +156,9 @@ export const secretValueTrackingQueueFactory = ({
return pair;
};
+ const markedProjectIds = new Set<string>();
const $markProjectComplete = async (projectId: string) => {
+ markedProjectIds.add(projectId);
await projectDAL.updateById(projectId, { secretBlindIndexEnabled: true });
await keyStore.deleteItems({ pattern: `${KeyStorePrefixes.InsightsCache(projectId, "secrets-duplication")}*` });
};
@@ -228,6 +232,15 @@ export const secretValueTrackingQueueFactory = ({
});
}
+ // The cursor steps over projects with no folders, so they are never finished inside the walk.
+ // They hold nothing to index, and every secret written to them later carries both digests.
+ for await (const projectId of projectIds) {
+ if (!markedProjectIds.has(projectId)) {
+ await $markProjectComplete(projectId);
+ projectsDone += 1;
+ }
+ }
+
if (scope.scope === "org") await orgDAL.updateById(scope.orgId, { orgWideSecretValueTrackingEnabled: true });
await job.updateProgress({ projectsTotal: projectIds.length, projectsDone, secretsProcessed });
diff --git a/frontend/src/components/secrets/SecretValueSearchSheet.tsx b/frontend/src/components/secrets/SecretValueSearchSheet.tsx
index be83ff98fa..26c6bee8f4 100644
--- a/frontend/src/components/secrets/SecretValueSearchSheet.tsx
+++ b/frontend/src/components/secrets/SecretValueSearchSheet.tsx
@@ -78,7 +78,7 @@ const SearchContent = ({ orgId, onClose }: { orgId: string; onClose: () => void
if (!search.data) {
return (
- <Empty className="bg-transparent shadow-none">
+ <Empty variant="unstyled">
<EmptyHeader>
<EmptyTitle>Enter a secret value to find where it is used</EmptyTitle>
<EmptyDescription>
@@ -92,7 +92,7 @@ const SearchContent = ({ orgId, onClose }: { orgId: string; onClose: () => void
if (matches.length === 0) {
return (
- <Empty className="bg-transparent shadow-none">
+ <Empty variant="unstyled">
<EmptyHeader>
<EmptyTitle>No secret in the organization holds this value</EmptyTitle>
<EmptyDescription>Personal overrides are not searched.</EmptyDescription>
@@ -227,7 +227,7 @@ const SearchContent = ({ orgId, onClose }: { orgId: string; onClose: () => void
export const SecretValueSearchSheet = ({ orgId, isOpen, onOpenChange }: Props) => (
<Sheet open={isOpen} onOpenChange={onOpenChange}>
- <SheetContent className="flex flex-col overflow-hidden sm:max-w-7xl">
+ <SheetContent size="workspace" className="flex flex-col overflow-hidden">
<SheetHeader>
<SheetTitle>Search by Secret Value</SheetTitle>
<SheetDescription>