Skip to content

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

encrypt details

Matheus Nogueira038620a24c7e
diff --git a/backend/src/db/migrations/20260924120000_encrypt-secret-scanning-finding-details.ts b/backend/src/db/migrations/20260924120000_encrypt-secret-scanning-finding-details.ts
new file mode 100644
index 0000000000..c25369f33d
--- /dev/null
+++ b/backend/src/db/migrations/20260924120000_encrypt-secret-scanning-finding-details.ts
@@ -0,0 +1,123 @@
+import { Knex } from "knex";
+
+import { inMemoryKeyStore } from "@app/keystore/memory";
+import { initLogger, logger } from "@app/lib/logger";
+import { kmsRootConfigDALFactory } from "@app/services/kms/kms-root-config-dal";
+import { KmsDataKey } from "@app/services/kms/kms-types";
+import { superAdminDALFactory } from "@app/services/super-admin/super-admin-dal";
+
+import { TableName } from "../schemas";
+import { getMigrationEnvConfig, getMigrationHsmConfig } from "./utils/env-config";
+import { createCircularCache } from "./utils/ring-buffer";
+import { getMigrationEncryptionServices, getMigrationHsmService } from "./utils/services";
+
+const BATCH_SIZE = 500;
+
+type TFindingRow = { id: string; projectId: string; details?: unknown; encryptedDetails?: Buffer };
+
+type TProjectKms = Awaited<
+ ReturnType<Awaited<ReturnType<typeof getMigrationEncryptionServices>>["kmsService"]["createCipherPairWithDataKey"]>
+>;
+
+// Walks the table in id order so a large findings table is never held in memory at once.
+const rewriteFindings = async (
+ knex: Knex,
+ sourceColumn: "details" | "encryptedDetails",
+ convert: (row: TFindingRow, projectKms: TProjectKms) => Record<string, unknown>
+) => {
+ const [{ count }] = await knex(TableName.SecretScanningFinding).count({ count: "*" });
+ const batchCount = Math.ceil(Number(count) / BATCH_SIZE);
+ if (!batchCount) return;
+
+ initLogger();
+
+ const { hsmService } = await getMigrationHsmService({ envConfig: getMigrationHsmConfig() });
+ const superAdminDAL = superAdminDALFactory(knex);
+ const kmsRootConfigDAL = kmsRootConfigDALFactory(knex);
+ const envConfig = await getMigrationEnvConfig(superAdminDAL, hsmService, kmsRootConfigDAL);
+ const keyStore = inMemoryKeyStore();
+ const { kmsService } = await getMigrationEncryptionServices({ envConfig, keyStore, db: knex });
+ const projectKmsCache = createCircularCache<TProjectKms>(25);
+
+ let lastId: string | undefined;
+
+ for (let batch = 0; batch < batchCount; batch += 1) {
+ const query = knex(TableName.SecretScanningFinding)
+ .select("id", "projectId", sourceColumn)
+ .orderBy("id")
+ .limit(BATCH_SIZE);
+ if (lastId) void query.where("id", ">", lastId);
+
+ // eslint-disable-next-line no-await-in-loop
+ const rows = (await query) as TFindingRow[];
+ if (!rows.length) break;
+
+ const updates: { id: string; data: Record<string, unknown> }[] = [];
+
+ for (const row of rows) {
+ let projectKms = projectKmsCache.getItem(row.projectId);
+ if (!projectKms) {
+ // eslint-disable-next-line no-await-in-loop
+ projectKms = await kmsService.createCipherPairWithDataKey(
+ { type: KmsDataKey.SecretManager, projectId: row.projectId },
+ knex
+ );
+ projectKmsCache.push(row.projectId, projectKms);
+ }
+
+ try {
+ updates.push({ id: row.id, data: convert(row, projectKms) });
+ } catch (err) {
+ logger.error(err, `Migration failed to convert secret scanning finding details [findingId=${row.id}]`);
+ throw err;
+ }
+ }
+
+ // eslint-disable-next-line no-await-in-loop
+ await knex.transaction(async (trx) => {
+ await Promise.all(
+ updates.map((update) => trx(TableName.SecretScanningFinding).where({ id: update.id }).update(update.data))
+ );
+ });
+
+ lastId = rows[rows.length - 1].id;
+ }
+};
+
+export async function up(knex: Knex): Promise<void> {
+ if (!(await knex.schema.hasColumn(TableName.SecretScanningFinding, "encryptedDetails"))) {
+ await knex.schema.alterTable(TableName.SecretScanningFinding, (t) => {
+ t.binary("encryptedDetails");
+ });
+ }
+
+ if (!(await knex.schema.hasColumn(TableName.SecretScanningFinding, "details"))) return;
+
+ await rewriteFindings(knex, "details", (row, projectKms) => ({
+ encryptedDetails: projectKms.encryptor({ plainText: Buffer.from(JSON.stringify(row.details ?? {})) }).cipherTextBlob
+ }));
+
+ await knex.schema.alterTable(TableName.SecretScanningFinding, (t) => {
+ t.binary("encryptedDetails").notNullable().alter();
+ t.dropColumn("details");
+ });
+}
+
+export async function down(knex: Knex): Promise<void> {
+ if (!(await knex.schema.hasColumn(TableName.SecretScanningFinding, "details"))) {
+ await knex.schema.alterTable(TableName.SecretScanningFinding, (t) => {
+ t.jsonb("details");
+ });
+ }
+
+ if (!(await knex.schema.hasColumn(TableName.SecretScanningFinding, "encryptedDetails"))) return;
+
+ await rewriteFindings(knex, "encryptedDetails", (row, projectKms) => ({
+ details: projectKms.decryptor({ cipherTextBlob: row.encryptedDetails as Buffer }).toString()
+ }));
+
+ await knex.schema.alterTable(TableName.SecretScanningFinding, (t) => {
+ t.jsonb("details").notNullable().alter();
+ t.dropColumn("encryptedDetails");
+ });
+}
diff --git a/backend/src/db/schemas/secret-scanning-findings.ts b/backend/src/db/schemas/secret-scanning-findings.ts
index c36f229f83..40dfdd87b7 100644
--- a/backend/src/db/schemas/secret-scanning-findings.ts
+++ b/backend/src/db/schemas/secret-scanning-findings.ts
@@ -5,6 +5,8 @@
import { z } from "zod";
+import { zodBuffer } from "@app/lib/zod";
+
import { TImmutableDBKeys } from "./models";
export const SecretScanningFindingsSchema = z.object({
@@ -18,11 +20,11 @@ export const SecretScanningFindingsSchema = z.object({
status: z.string().default("unresolved"),
remarks: z.string().nullable().optional(),
fingerprint: z.string(),
- details: z.unknown(),
projectId: z.string(),
scanId: z.string().uuid().nullable().optional(),
createdAt: z.date(),
- updatedAt: z.date()
+ updatedAt: z.date(),
+ encryptedDetails: zodBuffer
});
export type TSecretScanningFindings = z.infer<typeof SecretScanningFindingsSchema>;
diff --git a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-fns.ts b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-fns.ts
index 966117c0da..7a923230be 100644
--- a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-fns.ts
+++ b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-fns.ts
@@ -326,22 +326,7 @@ export async function scanFile(inputPath: string, configPath?: string): Promise<
export const toFindingDetails = (finding: SecretMatch): unknown =>
titleCaseToCamelCase({
- Description: finding.Description,
- StartLine: finding.StartLine,
- EndLine: finding.EndLine,
- StartColumn: finding.StartColumn,
- EndColumn: finding.EndColumn,
- File: finding.File,
- SymlinkFile: finding.SymlinkFile,
- Commit: finding.Commit,
- Entropy: finding.Entropy,
- Author: finding.Author,
- Email: finding.Email,
- Date: finding.Date,
- Message: finding.Message,
- Tags: finding.Tags,
- RuleID: finding.RuleID,
- Fingerprint: finding.Fingerprint,
+ ...finding,
Link: finding.Attributes?.url ?? ""
});
diff --git a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-queue.ts b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-queue.ts
index e1f6e1f450..4f195e1930 100644
--- a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-queue.ts
+++ b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-queue.ts
@@ -25,6 +25,7 @@ import { decryptAppConnection } from "@app/services/app-connection/app-connectio
import { TAppConnection } from "@app/services/app-connection/app-connection-types";
import { ActorType } from "@app/services/auth/auth-type";
import { TKmsServiceFactory } from "@app/services/kms/kms-service";
+import { KmsDataKey } from "@app/services/kms/kms-types";
import { TNotificationServiceFactory } from "@app/services/notification/notification-service";
import { NotificationType } from "@app/services/notification/notification-types";
import { TProjectDALFactory } from "@app/services/project/project-dal";
@@ -313,6 +314,11 @@ export const secretScanningV2QueueServiceFactory = ({
let connection: TAppConnection | null = null;
if (dataSource.connection) connection = await decryptAppConnection(dataSource.connection, kmsService);
+ const { encryptor: findingsEncryptor } = await kmsService.createCipherPairWithDataKey({
+ type: KmsDataKey.SecretManager,
+ projectId: dataSource.projectId
+ });
+
const factory = SECRET_SCANNING_FACTORY_MAP[dataSource.type as SecretScanningDataSource]({
kmsService,
appConnectionDAL
@@ -358,8 +364,9 @@ export const secretScanningV2QueueServiceFactory = ({
const owned = await secretScanningV2DAL.findings.transaction(async (tx) => {
if (batchFindings.length) {
await secretScanningV2DAL.findings.upsert(
- batchFindings.map((finding) => ({
+ batchFindings.map(({ details, ...finding }) => ({
...finding,
+ encryptedDetails: findingsEncryptor({ plainText: Buffer.from(JSON.stringify(details)) }).cipherTextBlob,
projectId: dataSource.projectId,
dataSourceName: dataSource.name,
dataSourceType: dataSource.type,
@@ -698,13 +705,20 @@ export const secretScanningV2QueueServiceFactory = ({
configPath
});
+ const { encryptor: findingsEncryptor, decryptor: findingsDecryptor } =
+ await kmsService.createCipherPairWithDataKey({
+ type: KmsDataKey.SecretManager,
+ projectId: dataSource.projectId
+ });
+
const { allFindings, closedOutByThisRun } = await secretScanningV2DAL.findings.transaction(async (tx) => {
let findings: TSecretScanningFindings[] = [];
if (findingsPayload.length) {
findings = await secretScanningV2DAL.findings.upsert(
- findingsPayload.map((finding) => ({
+ findingsPayload.map(({ details, ...finding }) => ({
...finding,
+ encryptedDetails: findingsEncryptor({ plainText: Buffer.from(JSON.stringify(details)) }).cipherTextBlob,
projectId: dataSource.projectId,
dataSourceName: dataSource.name,
dataSourceType: dataSource.type,
@@ -740,7 +754,9 @@ export const secretScanningV2QueueServiceFactory = ({
const newFindings = allFindings.filter((finding) => finding.scanId === scanId);
if (newFindings.length) {
- const finding = newFindings[0] as TSecretScanningFinding;
+ const details = JSON.parse(
+ findingsDecryptor({ cipherTextBlob: newFindings[0].encryptedDetails }).toString()
+ ) as TSecretScanningFinding["details"];
await queueService.queue(
QueueName.SecretScanningV2,
QueueJobs.SecretScanningV2SendNotification,
@@ -751,8 +767,8 @@ export const secretScanningV2QueueServiceFactory = ({
dataSource,
numberOfSecrets: newFindings.length,
scanId,
- authorName: finding?.details?.author,
- authorEmail: finding?.details?.email
+ authorName: details.author,
+ authorEmail: details.email
},
{ jobId: `secret-scanning-notification-${scanId}` }
);
diff --git a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-schemas.ts b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-schemas.ts
index 730427a18f..701c04391e 100644
--- a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-schemas.ts
+++ b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-schemas.ts
@@ -94,5 +94,5 @@ export const GitRepositoryScanFindingDetailsSchema = z.object({
export const BaseSecretScanningFindingSchema = SecretScanningFindingsSchema.omit({
dataSourceType: true,
resourceType: true,
- details: true
+ encryptedDetails: true
});
diff --git a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-service.ts b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-service.ts
index 36a425d7b2..2cc04a2b8f 100644
--- a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-service.ts
+++ b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-service.ts
@@ -791,7 +791,15 @@ export const secretScanningV2ServiceFactory = ({
projectId
});
- return findings as TSecretScanningFinding[];
+ const { decryptor } = await kmsService.createCipherPairWithDataKey({
+ type: KmsDataKey.SecretManager,
+ projectId
+ });
+
+ return findings.map(({ encryptedDetails, ...finding }) => ({
+ ...finding,
+ details: JSON.parse(decryptor({ cipherTextBlob: encryptedDetails }).toString()) as unknown
+ })) as TSecretScanningFinding[];
};
const updateSecretScanningFindingById = async (
@@ -832,7 +840,20 @@ export const secretScanningV2ServiceFactory = ({
status
});
- return { finding: updatedFinding as TSecretScanningFinding, projectId: finding.projectId };
+ const { decryptor } = await kmsService.createCipherPairWithDataKey({
+ type: KmsDataKey.SecretManager,
+ projectId: finding.projectId
+ });
+
+ const { encryptedDetails, ...rest } = updatedFinding;
+
+ return {
+ finding: {
+ ...rest,
+ details: JSON.parse(decryptor({ cipherTextBlob: encryptedDetails }).toString()) as unknown
+ } as TSecretScanningFinding,
+ projectId: finding.projectId
+ };
};
const findSecretScanningConfigByProjectId = async (projectId: string, actor: OrgServiceActor) => {
diff --git a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-types.ts b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-types.ts
index d885b05f5f..6db5d7e900 100644
--- a/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-types.ts
+++ b/backend/src/ee/services/secret-scanning-v2/secret-scanning-v2-types.ts
@@ -239,7 +239,9 @@ export type TSecretScanningFactory<
getDiffScanFindingsPayload: TSecretScanningFactoryGetDiffScanFindingsPayload<T, P>;
};
-export type TFindingsPayload = Pick<TSecretScanningFindingsInsert, "details" | "fingerprint" | "severity" | "rule">[];
+export type TFindingsPayload = (Pick<TSecretScanningFindingsInsert, "fingerprint" | "severity" | "rule"> & {
+ details: unknown;
+})[];
export type TGetFindingsPayload = Promise<TFindingsPayload>;
export type TUpdateSecretScanningFindingDTO = {