Skip to content

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

feat(blind-index): add org-scoped secret blind indexer

Calvinf5af79538b61
diff --git a/backend/src/services/secret-v2-bridge/secret-blind-index-fns.test.ts b/backend/src/services/secret-v2-bridge/secret-blind-index-fns.test.ts
new file mode 100644
index 0000000000..7cbe274c3e
--- /dev/null
+++ b/backend/src/services/secret-v2-bridge/secret-blind-index-fns.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { KmsDataKey } from "@app/services/kms/kms-types";
+
+import { createSecretBlindIndexer } from "./secret-blind-index-fns";
+
+const PROJECT_ID = "6c1b0e3a-0e3a-4c1b-8e3a-0e3a4c1b8e3a";
+const ORG_ID = "9d2c1f4b-1f4b-4d2c-9f4b-1f4b4d2c9f4b";
+
+const makeKmsService = () => ({
+ createCipherPairWithDataKey: vi.fn(async (ctx: { type: KmsDataKey }) => ({
+ generateSecretBlindIndex: async (value: Buffer) =>
+ `${ctx.type === KmsDataKey.Organization ? "org" : "project"}:${value.toString()}`
+ }))
+});
+
+const makeOrgDAL = (secretValueOrgBlindIndexEnabled: boolean) => ({
+ findById: vi.fn(async () => ({ id: ORG_ID, secretValueOrgBlindIndexEnabled }))
+});
+
+describe("createSecretBlindIndexer", () => {
+ it("returns both digests when the org has the index enabled", async () => {
+ const indexer = await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: makeKmsService() as never,
+ orgDAL: makeOrgDAL(true) as never
+ });
+
+ await expect(indexer.generate(Buffer.from("hunter2"))).resolves.toEqual({
+ secretValueBlindIndex: "project:hunter2",
+ secretValueOrgBlindIndex: "org:hunter2"
+ });
+ });
+
+ it("returns a null org digest when the org has opted out", async () => {
+ const indexer = await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: makeKmsService() as never,
+ orgDAL: makeOrgDAL(false) as never
+ });
+
+ await expect(indexer.generate(Buffer.from("hunter2"))).resolves.toEqual({
+ secretValueBlindIndex: "project:hunter2",
+ secretValueOrgBlindIndex: null
+ });
+ });
+
+ it("does not resolve the org data key at all when the org has opted out", async () => {
+ const kmsService = makeKmsService();
+
+ await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: kmsService as never,
+ orgDAL: makeOrgDAL(false) as never
+ });
+
+ expect(kmsService.createCipherPairWithDataKey).toHaveBeenCalledTimes(1);
+ expect(kmsService.createCipherPairWithDataKey).not.toHaveBeenCalledWith(
+ expect.objectContaining({ type: KmsDataKey.Organization }),
+ expect.anything()
+ );
+ });
+
+ it("builds each cipher pair once no matter how many values it indexes", async () => {
+ const kmsService = makeKmsService();
+ const indexer = await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: kmsService as never,
+ orgDAL: makeOrgDAL(true) as never
+ });
+
+ await Promise.all(["a", "b", "c", "d"].map((value) => indexer.generate(Buffer.from(value))));
+
+ expect(kmsService.createCipherPairWithDataKey).toHaveBeenCalledTimes(2);
+ });
+
+ it("returns null for a secret with no value rather than hashing an empty buffer", async () => {
+ const indexer = await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: makeKmsService() as never,
+ orgDAL: makeOrgDAL(true) as never
+ });
+
+ await expect(indexer.generateOptional(undefined)).resolves.toBeNull();
+ await expect(indexer.generateOptional(null)).resolves.toBeNull();
+ });
+
+ it("indexes the empty string when it is an actual value", async () => {
+ const indexer = await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: makeKmsService() as never,
+ orgDAL: makeOrgDAL(true) as never
+ });
+
+ await expect(indexer.generateOptional("")).resolves.toEqual({
+ secretValueBlindIndex: "project:",
+ secretValueOrgBlindIndex: "org:"
+ });
+ });
+
+ it("threads the transaction into both the org lookup and the key resolution", async () => {
+ const kmsService = makeKmsService();
+ const orgDAL = makeOrgDAL(true);
+ const tx = { marker: "tx" };
+
+ await createSecretBlindIndexer({
+ projectId: PROJECT_ID,
+ orgId: ORG_ID,
+ kmsService: kmsService as never,
+ orgDAL: orgDAL as never,
+ tx: tx as never
+ });
+
+ expect(orgDAL.findById).toHaveBeenCalledWith(ORG_ID, tx);
+ expect(kmsService.createCipherPairWithDataKey).toHaveBeenCalledWith(expect.anything(), tx);
+ });
+});
diff --git a/backend/src/services/secret-v2-bridge/secret-blind-index-fns.ts b/backend/src/services/secret-v2-bridge/secret-blind-index-fns.ts
new file mode 100644
index 0000000000..6471ded5d4
--- /dev/null
+++ b/backend/src/services/secret-v2-bridge/secret-blind-index-fns.ts
@@ -0,0 +1,58 @@
+import { Knex } from "knex";
+
+import { TKmsServiceFactory } from "@app/services/kms/kms-service";
+import { KmsDataKey } from "@app/services/kms/kms-types";
+import { TOrgDALFactory } from "@app/services/org/org-dal";
+
+export type TSecretValueBlindIndexes = {
+ secretValueBlindIndex: string;
+ secretValueOrgBlindIndex: string | null;
+};
+
+export type TSecretBlindIndexer = {
+ generate: (secretValue: Buffer) => Promise<TSecretValueBlindIndexes>;
+ generateOptional: (secretValue?: string | null) => Promise<TSecretValueBlindIndexes | null>;
+};
+
+export type TCreateSecretBlindIndexerDTO = {
+ projectId: string;
+ orgId: string;
+ kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
+ orgDAL: Pick<TOrgDALFactory, "findById">;
+ tx?: Knex;
+};
+
+// Build one of these per request and reuse it for every secret in that request. A bulk write can
+// carry thousands of values, and resolving a data key per value would hit an external KMS that many
+// times.
+export const createSecretBlindIndexer = async ({
+ projectId,
+ orgId,
+ kmsService,
+ orgDAL,
+ tx
+}: TCreateSecretBlindIndexerDTO): Promise<TSecretBlindIndexer> => {
+ const [projectCipher, org] = await Promise.all([
+ kmsService.createCipherPairWithDataKey({ type: KmsDataKey.SecretManager, projectId }, tx),
+ orgDAL.findById(orgId, tx)
+ ]);
+
+ const orgCipher = org?.secretValueOrgBlindIndexEnabled
+ ? await kmsService.createCipherPairWithDataKey({ type: KmsDataKey.Organization, orgId }, tx)
+ : null;
+
+ const generate = async (secretValue: Buffer): Promise<TSecretValueBlindIndexes> => {
+ const [secretValueBlindIndex, secretValueOrgBlindIndex] = await Promise.all([
+ projectCipher.generateSecretBlindIndex(secretValue),
+ orgCipher ? orgCipher.generateSecretBlindIndex(secretValue) : Promise.resolve(null)
+ ]);
+
+ return { secretValueBlindIndex, secretValueOrgBlindIndex };
+ };
+
+ return {
+ generate,
+ generateOptional: async (secretValue?: string | null) =>
+ secretValue === undefined || secretValue === null ? null : generate(Buffer.from(secretValue))
+ };
+};