Skip to content

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

fix(pki): share stale-file cleanup, keep files without a saved host, expose fips formats on sync options

bernie-gee6f267094bb
diff --git a/backend/src/server/routes/v1/pki-sync-routers/pki-sync-router.ts b/backend/src/server/routes/v1/pki-sync-routers/pki-sync-router.ts
index d47d20c5fd..9b16dfac0b 100644
--- a/backend/src/server/routes/v1/pki-sync-routers/pki-sync-router.ts
+++ b/backend/src/server/routes/v1/pki-sync-routers/pki-sync-router.ts
@@ -10,6 +10,7 @@ import { AuthMode } from "@app/services/auth/auth-type";
import { CertificateSyncStatus } from "@app/services/certificate-sync/certificate-sync-enums";
import { SyncMetadataSchema } from "@app/services/certificate-sync/certificate-sync-schemas";
import { PkiSync, PkiSyncStatus } from "@app/services/pki-sync/pki-sync-enums";
+import { PkiSyncExportFormat } from "@app/services/pki-sync/pki-sync-export-fns";
import { PkiSyncFiltersField, PkiSyncStoredFiltersField } from "@app/services/pki-sync/pki-sync-schemas";
const PkiSyncCertificateRefSchema = z.object({
@@ -97,7 +98,12 @@ const PkiSyncOptionsSchema = z.object({
forbiddenCharacters: z.string().optional(),
allowedCharacterPattern: z.string().optional(),
maxCertificateNameLength: z.number().optional(),
- minCertificateNameLength: z.number().optional()
+ minCertificateNameLength: z.number().optional(),
+ unsupportedExportFormats: z
+ .nativeEnum(PkiSyncExportFormat)
+ .array()
+ .optional()
+ .describe("Export formats this instance cannot produce, such as Java KeyStore when running in FIPS mode.")
});
const PkiSyncCertificateSchema = z.object({
diff --git a/backend/src/services/pki-sync/linux-server/linux-server-pki-sync-fns.ts b/backend/src/services/pki-sync/linux-server/linux-server-pki-sync-fns.ts
index 85d812a14e..58dafa5fda 100644
--- a/backend/src/services/pki-sync/linux-server/linux-server-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/linux-server/linux-server-pki-sync-fns.ts
@@ -3,7 +3,7 @@ import crypto from "node:crypto";
import path from "node:path";
import RE2 from "re2";
-import { Client, SFTPWrapper, utils as ssh2Utils } from "ssh2";
+import { Client, SFTPWrapper } from "ssh2";
import { TGatewayPoolServiceFactory } from "@app/ee/services/gateway-pool/gateway-pool-service";
import { TGatewayV2ServiceFactory } from "@app/ee/services/gateway-v2/gateway-v2-service";
@@ -30,14 +30,13 @@ import {
buildFileCollisionMessage,
buildStaleFileWarning,
exportCertificateForSync,
- getStaleCertificateFiles,
isExportFormatBlockedByFips,
isKeystoreExportFormat,
JKS_FIPS_UNSUPPORTED_MESSAGE,
JKS_TRUSTSTORE_SUFFIX,
PemCertificateExtension,
PkiSyncExportFormat,
- splitStaleCertificateFiles
+ planStaleCertificateFileCleanup
} from "../pki-sync-export-fns";
import {
buildHealthCheckCommandFailureMessage,
@@ -245,10 +244,13 @@ const unlinkIfExists = (sftp: SFTPWrapper, filePath: string): Promise<void> =>
sftp.unlink(filePath, () => resolve());
});
+// SFTP status code for a missing file. ssh2 is CommonJS, so its "utils" export can't be imported by name.
+const SFTP_STATUS_NO_SUCH_FILE = 2;
+
const unlinkOrThrow = (sftp: SFTPWrapper, filePath: string): Promise<void> =>
new Promise<void>((resolve, reject) => {
sftp.unlink(filePath, (err) => {
- if (!err || (err as { code?: number }).code === ssh2Utils.sftp.STATUS_CODE.NO_SUCH_FILE) {
+ if (!err || (err as { code?: number }).code === SFTP_STATUS_NO_SUCH_FILE) {
resolve();
return;
}
@@ -573,19 +575,13 @@ export const linuxServerPkiSyncFactory = ({
]);
}
if (record) {
- const previousMetadata = record.syncMetadata as TSyncMetadata;
- const previousFiles =
- previousMetadata?.files ?? [record.externalIdentifier].filter((p): p is string => Boolean(p));
- const staleFiles = getStaleCertificateFiles({
- previousFiles,
- previousHost: previousMetadata?.host,
- currentHost: targetHost,
+ const { filesToRemove, buildSyncMetadata } = planStaleCertificateFileCleanup({
+ previousMetadata: record.syncMetadata as TSyncMetadata,
+ previousExternalIdentifier: record.externalIdentifier,
writtenPaths,
- deliveredPaths
- });
- const { filesToRemove, filesToKeep, isTruststore } = splitStaleCertificateFiles({
- staleFiles,
- previousTruststoreFiles: previousMetadata?.truststoreFiles,
+ writtenTruststorePaths,
+ deliveredPaths,
+ currentHost: targetHost,
canRemoveCertificates
});
const staleFilesToRetry: string[] = [];
@@ -594,10 +590,7 @@ export const linuxServerPkiSyncFactory = ({
await unlinkOrThrow(sftp, staleFile);
} catch (removeErr) {
staleFilesToRetry.push(staleFile);
- staleFileFailures.push({
- path: staleFile,
- error: (removeErr as Error)?.message ?? "Unknown error"
- });
+ staleFileFailures.push({ path: staleFile, error: describeFailure(removeErr) });
}
}
const removedCount = filesToRemove.length - staleFilesToRetry.length;
@@ -608,11 +601,7 @@ export const linuxServerPkiSyncFactory = ({
}
await certificateSyncDAL.updateById(record.id, {
externalIdentifier: primaryPath,
- syncMetadata: {
- files: [...writtenPaths, ...filesToKeep, ...staleFilesToRetry],
- truststoreFiles: [...writtenTruststorePaths, ...staleFilesToRetry.filter(isTruststore)],
- host: targetHost
- }
+ syncMetadata: buildSyncMetadata(staleFilesToRetry)
});
}
}
diff --git a/backend/src/services/pki-sync/pki-sync-export-fns.test.ts b/backend/src/services/pki-sync/pki-sync-export-fns.test.ts
index 11b6461b10..0f3ab4fdc1 100644
--- a/backend/src/services/pki-sync/pki-sync-export-fns.test.ts
+++ b/backend/src/services/pki-sync/pki-sync-export-fns.test.ts
@@ -6,12 +6,11 @@ import {
buildStaleFileWarning,
exportCertificateForSync,
getExportedCertificateFileSuffixes,
- getStaleCertificateFiles,
getUnusedKeystoreOptionMessage,
isExportFormatBlockedByFips,
PemCertificateExtension,
PkiSyncExportFormat,
- splitStaleCertificateFiles,
+ planStaleCertificateFileCleanup,
TExportedCertificateFile
} from "./pki-sync-export-fns";
@@ -258,45 +257,106 @@ describe("isExportFormatBlockedByFips", () => {
});
});
-describe("splitStaleCertificateFiles", () => {
- const staleFiles = ["/certs/app.pem", "/certs/app.key", "/certs/app.truststore.jks"];
- const previousTruststoreFiles = ["/certs/app.truststore.jks"];
+describe("planStaleCertificateFileCleanup", () => {
+ const host = "host-a";
+ const base = {
+ writtenPaths: ["/certs/app.jks"],
+ writtenTruststorePaths: [],
+ deliveredPaths: new Set(["/certs/app.jks"]),
+ currentHost: host
+ };
+ const previousMetadata = {
+ host,
+ files: ["/certs/app.pem", "/certs/app.key", "/certs/app.truststore.jks"],
+ truststoreFiles: ["/certs/app.truststore.jks"]
+ };
+
+ test("removes every stale file when certificate removal is on", () => {
+ const plan = planStaleCertificateFileCleanup({ ...base, previousMetadata, canRemoveCertificates: true });
+ expect(plan.filesToRemove).toEqual(previousMetadata.files);
+ expect(plan.buildSyncMetadata([])).toEqual({ files: ["/certs/app.jks"], truststoreFiles: [], host });
+ });
- test("removes every stale file when certificate removal is allowed", () => {
- const split = splitStaleCertificateFiles({ staleFiles, previousTruststoreFiles, canRemoveCertificates: true });
- expect(split.filesToRemove).toEqual(staleFiles);
- expect(split.filesToKeep).toEqual([]);
+ test("only removes a recorded truststore when certificate removal is off, and keeps tracking the rest", () => {
+ const plan = planStaleCertificateFileCleanup({ ...base, previousMetadata, canRemoveCertificates: false });
+ expect(plan.filesToRemove).toEqual(["/certs/app.truststore.jks"]);
+ expect(plan.buildSyncMetadata([]).files).toEqual(["/certs/app.jks", "/certs/app.pem", "/certs/app.key"]);
});
- test("only removes a recorded truststore when certificate removal is off", () => {
- const split = splitStaleCertificateFiles({ staleFiles, previousTruststoreFiles, canRemoveCertificates: false });
- expect(split.filesToRemove).toEqual(["/certs/app.truststore.jks"]);
- expect(split.filesToKeep).toEqual(["/certs/app.pem", "/certs/app.key"]);
+ test("keeps tracking a file whose removal failed so the next sync retries it", () => {
+ const plan = planStaleCertificateFileCleanup({ ...base, previousMetadata, canRemoveCertificates: false });
+ expect(plan.buildSyncMetadata(["/certs/app.truststore.jks"])).toEqual({
+ files: ["/certs/app.jks", "/certs/app.pem", "/certs/app.key", "/certs/app.truststore.jks"],
+ truststoreFiles: ["/certs/app.truststore.jks"],
+ host
+ });
});
test("keeps a keystore whose certificate name ends in .truststore", () => {
- const split = splitStaleCertificateFiles({
- staleFiles: ["/certs/api.truststore.jks"],
- previousTruststoreFiles: [],
+ const plan = planStaleCertificateFileCleanup({
+ ...base,
+ previousMetadata: { host, files: ["/certs/api.truststore.jks"], truststoreFiles: [] },
canRemoveCertificates: false
});
- expect(split.filesToRemove).toEqual([]);
- expect(split.filesToKeep).toEqual(["/certs/api.truststore.jks"]);
+ expect(plan.filesToRemove).toEqual([]);
+ expect(plan.buildSyncMetadata([]).files).toContain("/certs/api.truststore.jks");
});
- test("keeps files when no truststores were recorded", () => {
- const split = splitStaleCertificateFiles({ staleFiles, canRemoveCertificates: false });
- expect(split.filesToRemove).toEqual([]);
- expect(split.filesToKeep).toEqual(staleFiles);
+ test("keeps a file another certificate wrote this run", () => {
+ const plan = planStaleCertificateFileCleanup({
+ ...base,
+ deliveredPaths: new Set(["/certs/app.jks", "/certs/app.pem"]),
+ previousMetadata,
+ canRemoveCertificates: true
+ });
+ expect(plan.filesToRemove).toEqual(["/certs/app.key", "/certs/app.truststore.jks"]);
});
- test("matches recorded truststores without regard to case", () => {
- const split = splitStaleCertificateFiles({
- staleFiles: ["C:\\certs\\App.truststore.jks"],
- previousTruststoreFiles: ["C:\\certs\\app.truststore.jks"],
- canRemoveCertificates: false
+ test("deletes nothing and keeps tracking files recorded before hosts were saved", () => {
+ const plan = planStaleCertificateFileCleanup({
+ ...base,
+ previousMetadata: { files: ["/certs/app.pem", "/certs/app.key"] },
+ canRemoveCertificates: true
+ });
+ expect(plan.filesToRemove).toEqual([]);
+ expect(plan.buildSyncMetadata([])).toEqual({
+ files: ["/certs/app.jks", "/certs/app.pem", "/certs/app.key"],
+ truststoreFiles: [],
+ host
});
- expect(split.filesToRemove).toEqual(["C:\\certs\\App.truststore.jks"]);
+ });
+
+ test("neither deletes nor keeps files recorded on a different host", () => {
+ const plan = planStaleCertificateFileCleanup({
+ ...base,
+ previousMetadata: { ...previousMetadata, host: "host-b" },
+ canRemoveCertificates: true
+ });
+ expect(plan.filesToRemove).toEqual([]);
+ expect(plan.buildSyncMetadata([]).files).toEqual(["/certs/app.jks"]);
+ });
+
+ test("falls back to the external identifier when no files were recorded", () => {
+ const plan = planStaleCertificateFileCleanup({
+ ...base,
+ previousMetadata: { host, files: [] },
+ previousExternalIdentifier: "/certs/app.pfx",
+ canRemoveCertificates: true
+ });
+ expect(plan.filesToRemove).toEqual(["/certs/app.pfx"]);
+ });
+
+ test("compares paths without regard to case when asked", () => {
+ const plan = planStaleCertificateFileCleanup({
+ writtenPaths: ["C:\\certs\\App.jks"],
+ writtenTruststorePaths: [],
+ deliveredPaths: new Set(["C:\\certs\\App.jks"]),
+ currentHost: "HOST-A",
+ previousMetadata: { host, files: ["C:\\certs\\app.jks", "C:\\certs\\app.pem"] },
+ canRemoveCertificates: true,
+ caseInsensitive: true
+ });
+ expect(plan.filesToRemove).toEqual(["C:\\certs\\app.pem"]);
});
});
@@ -311,65 +371,3 @@ describe("buildStaleFileWarning", () => {
expect(warning).toContain("Permission denied");
});
});
-
-describe("getStaleCertificateFiles", () => {
- test("returns files written last time that this run no longer writes", () => {
- expect(
- getStaleCertificateFiles({
- previousHost: "host-a",
- currentHost: "host-a",
- previousFiles: ["/certs/app.jks", "/certs/app.truststore.jks"],
- writtenPaths: ["/certs/app.jks"],
- deliveredPaths: new Set(["/certs/app.jks"])
- })
- ).toEqual(["/certs/app.truststore.jks"]);
- });
-
- test("keeps a file another certificate wrote this run", () => {
- expect(
- getStaleCertificateFiles({
- previousHost: "host-a",
- currentHost: "host-a",
- previousFiles: ["/certs/app.pem", "/certs/shared.pem"],
- writtenPaths: ["/certs/app.jks"],
- deliveredPaths: new Set(["/certs/app.jks", "/certs/shared.pem"])
- })
- ).toEqual(["/certs/app.pem"]);
- });
-
- test("ignores case when paths are case-insensitive", () => {
- expect(
- getStaleCertificateFiles({
- previousHost: "host-a",
- currentHost: "host-a",
- previousFiles: ["C:\\certs\\App.jks", "C:\\certs\\app.truststore.jks"],
- writtenPaths: ["C:\\certs\\app.jks"],
- deliveredPaths: new Set(["C:\\certs\\app.jks"]),
- caseInsensitive: true
- })
- ).toEqual(["C:\\certs\\app.truststore.jks"]);
- });
-
- test("returns nothing when the files were written to another host", () => {
- expect(
- getStaleCertificateFiles({
- previousHost: "host-a",
- currentHost: "host-b",
- previousFiles: ["/certs/app.jks"],
- writtenPaths: ["/certs/other.jks"],
- deliveredPaths: new Set(["/certs/other.jks"])
- })
- ).toEqual([]);
- });
-
- test("returns nothing when the previous host was not recorded", () => {
- expect(
- getStaleCertificateFiles({
- currentHost: "host-a",
- previousFiles: ["/certs/app.pem", "/certs/app.key"],
- writtenPaths: ["/certs/app.jks"],
- deliveredPaths: new Set(["/certs/app.jks"])
- })
- ).toEqual([]);
- });
-});
diff --git a/backend/src/services/pki-sync/pki-sync-export-fns.ts b/backend/src/services/pki-sync/pki-sync-export-fns.ts
index baffcfa2f1..274eea236c 100644
--- a/backend/src/services/pki-sync/pki-sync-export-fns.ts
+++ b/backend/src/services/pki-sync/pki-sync-export-fns.ts
@@ -5,6 +5,7 @@ import {
generateJksTruststore,
getJksTruststoreCertificates
} from "@app/services/certificate/certificate-jks-fns";
+import { TSyncMetadata } from "@app/services/certificate-sync/certificate-sync-schemas";
export enum PkiSyncExportFormat {
Pem = "pem",
@@ -31,30 +32,6 @@ export const JKS_FIPS_UNSUPPORTED_MESSAGE =
export const isExportFormatBlockedByFips = (format: unknown): boolean =>
format === PkiSyncExportFormat.Jks && crypto.isFipsModeEnabled();
-// Files this sync wrote for a certificate last time but no longer writes, such as a truststore
-// after it is turned off. Paths another certificate wrote this run are left alone, and nothing is
-// returned unless the files are known to have been written to the current host.
-export const getStaleCertificateFiles = ({
- previousFiles,
- previousHost,
- currentHost,
- writtenPaths,
- deliveredPaths,
- caseInsensitive = false
-}: {
- previousFiles: string[];
- previousHost?: string;
- currentHost?: string;
- writtenPaths: string[];
- deliveredPaths: Set<string>;
- caseInsensitive?: boolean;
-}): string[] => {
- if (!previousHost || !currentHost || previousHost.toLowerCase() !== currentHost.toLowerCase()) return [];
- const normalize = (filePath: string) => (caseInsensitive ? filePath.toLowerCase() : filePath);
- const current = new Set([...writtenPaths, ...deliveredPaths].map(normalize));
- return previousFiles.filter((filePath) => !current.has(normalize(filePath)));
-};
-
export const buildFileCollisionMessage = (filePath: string) =>
`Another certificate in this sync already writes "${filePath}". Change the certificate name schema so each certificate gets its own file names.`;
@@ -67,25 +44,57 @@ export const KEYSTORE_PASSWORD_REQUIRED_MESSAGE = "A password is required when t
export const JKS_KEYSTORE_SUFFIX = ".jks";
export const JKS_TRUSTSTORE_SUFFIX = ".truststore.jks";
-// A stale truststore still grants trust, so it is always removed. Other stale files may still be read
-// by a server, so they are only removed when the sync is allowed to remove certificates. Truststores
-// are known from what the sync recorded writing, since a certificate name can itself end in ".truststore".
-export const splitStaleCertificateFiles = ({
- staleFiles,
- previousTruststoreFiles = [],
- canRemoveCertificates
+// A stale truststore still grants trust, so it is removed even when certificate removal is off.
+export const planStaleCertificateFileCleanup = ({
+ previousMetadata,
+ previousExternalIdentifier,
+ writtenPaths,
+ writtenTruststorePaths,
+ deliveredPaths,
+ currentHost,
+ canRemoveCertificates,
+ caseInsensitive = false
}: {
- staleFiles: string[];
- previousTruststoreFiles?: string[];
+ previousMetadata: TSyncMetadata;
+ previousExternalIdentifier?: string | null;
+ writtenPaths: string[];
+ writtenTruststorePaths: string[];
+ deliveredPaths: Set<string>;
+ currentHost: string;
canRemoveCertificates: boolean;
+ caseInsensitive?: boolean;
}) => {
- const truststores = new Set(previousTruststoreFiles.map((filePath) => filePath.toLowerCase()));
+ const normalize = (filePath: string) => (caseInsensitive ? filePath.toLowerCase() : filePath);
+ const previousFiles = previousMetadata?.files?.length
+ ? previousMetadata.files
+ : [previousExternalIdentifier].filter((filePath): filePath is string => Boolean(filePath));
+ const current = new Set([...writtenPaths, ...deliveredPaths].map(normalize));
+ const staleFiles = previousFiles.filter((filePath) => !current.has(normalize(filePath)));
+
+ const truststores = new Set((previousMetadata?.truststoreFiles ?? []).map((filePath) => filePath.toLowerCase()));
const isTruststore = (filePath: string) => truststores.has(filePath.toLowerCase());
- return {
- filesToRemove: canRemoveCertificates ? staleFiles : staleFiles.filter(isTruststore),
- filesToKeep: canRemoveCertificates ? [] : staleFiles.filter((filePath) => !isTruststore(filePath)),
- isTruststore
+
+ const previousHost = previousMetadata?.host;
+ let filesToRemove: string[] = [];
+ let filesToKeep: string[] = [];
+ if (!previousHost) {
+ // Recorded before hosts were saved, so keep tracking the files without deleting anything yet.
+ filesToKeep = staleFiles;
+ } else if (previousHost.toLowerCase() === currentHost.toLowerCase()) {
+ filesToRemove = canRemoveCertificates ? staleFiles : staleFiles.filter(isTruststore);
+ filesToKeep = canRemoveCertificates ? [] : staleFiles.filter((filePath) => !isTruststore(filePath));
+ }
+
+ const buildSyncMetadata = (filesToRetry: string[]) => {
+ const trackedStaleFiles = [...filesToKeep, ...filesToRetry];
+ return {
+ files: [...writtenPaths, ...trackedStaleFiles],
+ truststoreFiles: [...writtenTruststorePaths, ...trackedStaleFiles.filter(isTruststore)],
+ host: currentHost
+ };
};
+
+ return { filesToRemove, buildSyncMetadata };
};
const MAX_LISTED_STALE_FILES = 3;
diff --git a/backend/src/services/pki-sync/pki-sync-fns.test.ts b/backend/src/services/pki-sync/pki-sync-fns.test.ts
index 77f4940c56..54dd162da1 100644
--- a/backend/src/services/pki-sync/pki-sync-fns.test.ts
+++ b/backend/src/services/pki-sync/pki-sync-fns.test.ts
@@ -1,10 +1,14 @@
+import { crypto } from "@app/lib/crypto/cryptography";
+
import { PkiSync } from "./pki-sync-enums";
+import { PkiSyncExportFormat } from "./pki-sync-export-fns";
import { hasAnyPkiSyncFilter } from "./pki-sync-filter-fns";
import {
assertFiltersCannotExceedCertificateCap,
assertPkiSyncCanHoldCertificateCount,
getPkiSyncCertificateCap,
getPkiSyncProviderCapabilities,
+ listPkiSyncOptions,
matchesCertificateNameSchema,
parsePkiSyncErrorMessage
} from "./pki-sync-fns";
@@ -387,3 +391,23 @@ describe("assertFiltersCannotExceedCertificateCap", () => {
).toThrow("can name at most 4 certificate orders");
});
});
+
+describe("listPkiSyncOptions", () => {
+ afterEach(() => {
+ vi.restoreAllMocks();
+ });
+
+ const optionFor = (destination: PkiSync) => listPkiSyncOptions().find((o) => o.destination === destination);
+
+ test("marks JKS unsupported for server destinations in FIPS mode", () => {
+ vi.spyOn(crypto, "isFipsModeEnabled").mockReturnValue(true);
+ expect(optionFor(PkiSync.LinuxServer)).toMatchObject({ unsupportedExportFormats: [PkiSyncExportFormat.Jks] });
+ expect(optionFor(PkiSync.WindowsServer)).toMatchObject({ unsupportedExportFormats: [PkiSyncExportFormat.Jks] });
+ expect(optionFor(PkiSync.AzureKeyVault)).not.toHaveProperty("unsupportedExportFormats");
+ });
+
+ test("lists no unsupported formats outside FIPS mode", () => {
+ vi.spyOn(crypto, "isFipsModeEnabled").mockReturnValue(false);
+ expect(optionFor(PkiSync.LinuxServer)).not.toHaveProperty("unsupportedExportFormats");
+ });
+});
diff --git a/backend/src/services/pki-sync/pki-sync-fns.ts b/backend/src/services/pki-sync/pki-sync-fns.ts
index f0f4c50cd4..256a5e424c 100644
--- a/backend/src/services/pki-sync/pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/pki-sync-fns.ts
@@ -54,6 +54,7 @@ import {
} from "./pki-sync-certificate-name-fns";
import { PkiSync } from "./pki-sync-enums";
import { PkiSyncError } from "./pki-sync-errors";
+import { isExportFormatBlockedByFips, PkiSyncExportFormat } from "./pki-sync-export-fns";
import { hasAnyPkiSyncFilter, PKI_SYNC_FILTER_KINDS, TPkiSyncFilterKind } from "./pki-sync-filter-fns";
import { getHealthCheckCommand } from "./pki-sync-health-check-command-fns";
import {
@@ -105,13 +106,22 @@ export const assertPkiSyncLicense = async (
}
};
+const SERVER_PKI_SYNC_DESTINATIONS = new Set<PkiSync>([PkiSync.LinuxServer, PkiSync.WindowsServer]);
+
export const listPkiSyncOptions = () => {
+ const unsupportedExportFormats = Object.values(PkiSyncExportFormat).filter(isExportFormatBlockedByFips);
return Object.values(PKI_SYNC_LIST_OPTIONS)
.map((option) => {
const additionalConnections = getPkiSyncConnectionApps(option.destination).filter(
(app) => app !== option.connection
);
- return additionalConnections.length ? { ...option, additionalConnections } : option;
+ return {
+ ...option,
+ ...(additionalConnections.length ? { additionalConnections } : {}),
+ ...(SERVER_PKI_SYNC_DESTINATIONS.has(option.destination) && unsupportedExportFormats.length
+ ? { unsupportedExportFormats }
+ : {})
+ };
})
.sort((a, b) => a.name.localeCompare(b.name));
};
diff --git a/backend/src/services/pki-sync/windows-server/windows-server-pki-sync-fns.ts b/backend/src/services/pki-sync/windows-server/windows-server-pki-sync-fns.ts
index cfa380e88b..c37eda9da9 100644
--- a/backend/src/services/pki-sync/windows-server/windows-server-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/windows-server/windows-server-pki-sync-fns.ts
@@ -21,14 +21,13 @@ import {
buildFileCollisionMessage,
buildStaleFileWarning,
exportCertificateForSync,
- getStaleCertificateFiles,
isExportFormatBlockedByFips,
isKeystoreExportFormat,
JKS_FIPS_UNSUPPORTED_MESSAGE,
JKS_TRUSTSTORE_SUFFIX,
PemCertificateExtension,
PkiSyncExportFormat,
- splitStaleCertificateFiles
+ planStaleCertificateFileCleanup
} from "../pki-sync-export-fns";
import {
buildHealthCheckCommandFailureMessage,
@@ -430,22 +429,16 @@ export const windowsServerPkiSyncFactory = ({
]);
}
if (record) {
- const previousMetadata = record.syncMetadata as TSyncMetadata;
- const previousFiles =
- previousMetadata?.files ?? [record.externalIdentifier].filter((p): p is string => Boolean(p));
- const staleFiles = getStaleCertificateFiles({
- previousFiles,
- previousHost: previousMetadata?.host,
- currentHost: target.credentials.host,
+ const { filesToRemove, buildSyncMetadata } = planStaleCertificateFileCleanup({
+ previousMetadata: record.syncMetadata as TSyncMetadata,
+ previousExternalIdentifier: record.externalIdentifier,
writtenPaths: paths,
+ writtenTruststorePaths: truststorePaths,
deliveredPaths,
+ currentHost: target.credentials.host,
+ canRemoveCertificates,
caseInsensitive: true
});
- const { filesToRemove, filesToKeep, isTruststore } = splitStaleCertificateFiles({
- staleFiles,
- previousTruststoreFiles: previousMetadata?.truststoreFiles,
- canRemoveCertificates
- });
let staleFilesToRetry: string[] = [];
if (filesToRemove.length > 0) {
try {
@@ -462,11 +455,7 @@ export const windowsServerPkiSyncFactory = ({
}
await certificateSyncDAL.updateById(record.id, {
externalIdentifier: paths[0],
- syncMetadata: {
- files: [...paths, ...filesToKeep, ...staleFilesToRetry],
- truststoreFiles: [...truststorePaths, ...staleFilesToRetry.filter(isTruststore)],
- host: target.credentials.host
- }
+ syncMetadata: buildSyncMetadata(staleFilesToRetry)
});
}
}
diff --git a/frontend/src/components/pki-syncs/forms/PkiSyncOptionsFields/ServerExportFormatFields.tsx b/frontend/src/components/pki-syncs/forms/PkiSyncOptionsFields/ServerExportFormatFields.tsx
index 1c7478d457..8ea70a9fd7 100644
--- a/frontend/src/components/pki-syncs/forms/PkiSyncOptionsFields/ServerExportFormatFields.tsx
+++ b/frontend/src/components/pki-syncs/forms/PkiSyncOptionsFields/ServerExportFormatFields.tsx
@@ -22,12 +22,12 @@ import {
TooltipContent,
TooltipTrigger
} from "@app/components/v3";
-import { useServerConfig } from "@app/context";
import {
isKeystoreExportFormat,
PemCertificateExtension,
PKI_SYNC_EXPORT_FORMAT_LABELS,
- PkiSyncExportFormat
+ PkiSyncExportFormat,
+ usePkiSyncOption
} from "@app/hooks/api/pkiSyncs";
import { TPkiSyncForm } from "../schemas/pki-sync-schema";
@@ -38,10 +38,12 @@ type Props = {
export const ServerExportFormatFields = ({ isUpdate }: Props) => {
const { control, watch } = useFormContext<TPkiSyncForm>();
- const { config } = useServerConfig();
+ const { syncOption } = usePkiSyncOption(watch("destination"));
const exportFormat = watch("syncOptions.exportFormat");
const isKeystore = isKeystoreExportFormat(exportFormat);
- const isJksBlockedByFips = Boolean(config.fipsEnabled);
+ const isJksBlockedByFips = Boolean(
+ syncOption?.unsupportedExportFormats?.includes(PkiSyncExportFormat.Jks)
+ );
const keystoreLabel = exportFormat === PkiSyncExportFormat.Jks ? "JKS" : "PKCS#12";
const keystoreFile = exportFormat === PkiSyncExportFormat.Jks ? ".jks keystore" : ".pfx bundle";
diff --git a/frontend/src/components/pki-syncs/forms/schemas/pki-sync-schema.ts b/frontend/src/components/pki-syncs/forms/schemas/pki-sync-schema.ts
index 12905d9e29..f866b670a4 100644
--- a/frontend/src/components/pki-syncs/forms/schemas/pki-sync-schema.ts
+++ b/frontend/src/components/pki-syncs/forms/schemas/pki-sync-schema.ts
@@ -123,6 +123,11 @@ const refineTargetHost = (data: unknown, ctx: z.RefinementCtx) => {
const isServerDestination = (destination: PkiSync) =>
destination === PkiSync.WindowsServer || destination === PkiSync.LinuxServer;
+const isServerSyncForm = <T extends { destination: PkiSync }>(
+ data: T
+): data is Extract<T, { destination: PkiSync.WindowsServer | PkiSync.LinuxServer }> =>
+ isServerDestination(data.destination);
+
// Only keystore formats use the password, so a value left behind after switching to PEM is ignored.
const refineExportPassword = (
data: { destination: PkiSync; syncOptions?: unknown; credentials?: unknown },
@@ -195,7 +200,7 @@ export const PkiSyncFormSchema = PkiSyncUnionSchema.superRefine((data, ctx) => {
}
if (
- (data.destination === PkiSync.WindowsServer || data.destination === PkiSync.LinuxServer) &&
+ isServerSyncForm(data) &&
isKeystoreExportFormat(data.syncOptions?.exportFormat) &&
!data.credentials?.exportPassword
) {
diff --git a/frontend/src/hooks/api/pkiSyncs/types/index.ts b/frontend/src/hooks/api/pkiSyncs/types/index.ts
index 94a7b72e84..d7c6f88b85 100644
--- a/frontend/src/hooks/api/pkiSyncs/types/index.ts
+++ b/frontend/src/hooks/api/pkiSyncs/types/index.ts
@@ -33,6 +33,7 @@ export type TPkiSyncOption = {
allowedCharacterPattern?: string;
maxCertificateNameLength?: number;
minCertificateNameLength?: number;
+ unsupportedExportFormats?: PkiSyncExportFormat[];
};
export type TPkiSync =