Skip to content

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

perf(blind-index): derive the value index key once per data key

Calvin9fe3460247df
diff --git a/backend/src/lib/crypto/blind-index.test.ts b/backend/src/lib/crypto/blind-index.test.ts
new file mode 100644
index 0000000000..8136996687
--- /dev/null
+++ b/backend/src/lib/crypto/blind-index.test.ts
@@ -0,0 +1,33 @@
+import crypto from "node:crypto";
+
+import { createSecretValueBlindIndexer, generateSecretValueBlindIndexFromKmsKey } from "./blind-index";
+
+describe("createSecretValueBlindIndexer", () => {
+ const dataKey = crypto.randomBytes(32);
+
+ test("matches the per-value derivation, so existing digests stay searchable", async () => {
+ const generate = createSecretValueBlindIndexer(dataKey);
+ const values = ["sk_live_abc123", "", " padded ", "-----BEGIN KEY-----\nline\n-----END KEY-----"];
+
+ for await (const value of values) {
+ expect(await generate(Buffer.from(value))).toBe(
+ await generateSecretValueBlindIndexFromKmsKey(Buffer.from(value), dataKey)
+ );
+ }
+ });
+
+ test("gives the same digest when many values are hashed at once", async () => {
+ const generate = createSecretValueBlindIndexer(dataKey);
+ const digests = await Promise.all(Array.from({ length: 20 }, () => generate(Buffer.from("same"))));
+
+ expect(new Set(digests).size).toBe(1);
+ });
+
+ test("gives different digests under different data keys", async () => {
+ const value = Buffer.from("same");
+ const a = await createSecretValueBlindIndexer(dataKey)(value);
+ const b = await createSecretValueBlindIndexer(crypto.randomBytes(32))(value);
+
+ expect(a).not.toBe(b);
+ });
+});
diff --git a/backend/src/lib/crypto/blind-index.ts b/backend/src/lib/crypto/blind-index.ts
index fce6e734b2..09925e4d4a 100644
--- a/backend/src/lib/crypto/blind-index.ts
+++ b/backend/src/lib/crypto/blind-index.ts
@@ -27,16 +27,18 @@ export const deriveSecretValueBlindIndexKey = async (kmsDataKey: Buffer): Promis
* Generates a blind index for a secret value using HMAC-SHA256.
* Uses Web Crypto API for async, non-blocking operation.
*/
-export const generateSecretValueBlindIndex = async (secretValue: Buffer, blindIndexKey: Buffer): Promise<string> => {
- const cryptoKey = await crypto.subtle.importKey("raw", blindIndexKey, { name: "HMAC", hash: "SHA-256" }, false, [
- "sign"
- ]);
+const importBlindIndexKey = (blindIndexKey: Buffer) =>
+ crypto.subtle.importKey("raw", blindIndexKey, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+const signBlindIndex = async (secretValue: Buffer, cryptoKey: CryptoKey): Promise<string> => {
const signature = await crypto.subtle.sign("HMAC", cryptoKey, secretValue);
return Buffer.from(signature).toString("hex");
};
+export const generateSecretValueBlindIndex = async (secretValue: Buffer, blindIndexKey: Buffer): Promise<string> =>
+ signBlindIndex(secretValue, await importBlindIndexKey(blindIndexKey));
+
/**
* Convenience wrapper that derives the blind index key from KMS data key
* and generates the blind index in one call.
@@ -48,3 +50,24 @@ export const generateSecretValueBlindIndexFromKmsKey = async (
const blindIndexKey = await deriveSecretValueBlindIndexKey(kmsDataKey);
return generateSecretValueBlindIndex(secretValue, blindIndexKey);
};
+
+// Derives and imports the key once, on first use, then reuses it for every value hashed under the same
+// data key. A backfill or a bulk write hashes thousands of values per key, and redoing the HKDF and the
+// import for each one adds threadpool work that changes nothing in the output. Lazy, because most
+// callers of a cipher pair never hash anything.
+export const createSecretValueBlindIndexer = (kmsDataKey: Buffer) => {
+ let cryptoKey: Promise<CryptoKey> | undefined;
+
+ const getCryptoKey = () => {
+ if (!cryptoKey) {
+ cryptoKey = deriveSecretValueBlindIndexKey(kmsDataKey).then(importBlindIndexKey);
+ // A failed derivation is not cached, so the next value tries again rather than inheriting it.
+ cryptoKey.catch(() => {
+ cryptoKey = undefined;
+ });
+ }
+ return cryptoKey;
+ };
+
+ return async (secretValue: Buffer): Promise<string> => signBlindIndex(secretValue, await getCryptoKey());
+};
diff --git a/backend/src/lib/crypto/index.ts b/backend/src/lib/crypto/index.ts
index 432677e71e..04360000db 100644
--- a/backend/src/lib/crypto/index.ts
+++ b/backend/src/lib/crypto/index.ts
@@ -1,4 +1,5 @@
export {
+ createSecretValueBlindIndexer,
deriveSecretValueBlindIndexKey,
generateSecretValueBlindIndex,
generateSecretValueBlindIndexFromKmsKey
diff --git a/backend/src/services/kms/kms-service.ts b/backend/src/services/kms/kms-service.ts
index 524e549451..4afc1827c0 100644
--- a/backend/src/services/kms/kms-service.ts
+++ b/backend/src/services/kms/kms-service.ts
@@ -16,7 +16,7 @@ import { THsmStatus } from "@app/ee/services/hsm/hsm-types";
import { KeyStorePrefixes, PgSqlLock, TKeyStoreFactory } from "@app/keystore/keystore";
import { withCache } from "@app/lib/cache/with-cache";
import { getOriginalConfig, TEnvConfig } from "@app/lib/config/env";
-import { generateSecretValueBlindIndexFromKmsKey } from "@app/lib/crypto/blind-index";
+import { createSecretValueBlindIndexer } from "@app/lib/crypto/blind-index";
import { symmetricCipherService, SymmetricKeyAlgorithm } from "@app/lib/crypto/cipher";
import { deriveCookieSigningKey } from "@app/lib/crypto/cookie-signing-key";
import { crypto } from "@app/lib/crypto/cryptography";
@@ -1289,6 +1289,7 @@ export const kmsServiceFactory = ({
const dataKey = await $getDataKey(encryptionContext, trx);
const cipher = symmetricCipherService(SymmetricKeyAlgorithm.AES_GCM_256);
+ const generateSecretBlindIndex = createSecretValueBlindIndexer(dataKey);
return {
encryptor: ({ plainText }: Pick<TEncryptWithKmsDTO, "plainText">) => {
@@ -1304,7 +1305,7 @@ export const kmsServiceFactory = ({
const decryptedBlob = cipher.decrypt(cipherTextBlob, dataKey);
return decryptedBlob;
},
- generateSecretBlindIndex: (secretValue: Buffer) => generateSecretValueBlindIndexFromKmsKey(secretValue, dataKey)
+ generateSecretBlindIndex
};
};