Skip to content

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

fix(pki-sync): check ownership for all cleanup candidates

bernie-g6912f3c7bf6d
diff --git a/backend/src/services/certificate-sync/certificate-sync-dal.ts b/backend/src/services/certificate-sync/certificate-sync-dal.ts
index 9512f05681..a0a00f2042 100644
--- a/backend/src/services/certificate-sync/certificate-sync-dal.ts
+++ b/backend/src/services/certificate-sync/certificate-sync-dal.ts
@@ -77,7 +77,7 @@ export const certificateSyncDALFactory = (db: TDbClient) => {
): Promise<Set<string>> => {
try {
if (externalIdentifiers.length === 0) return new Set();
- const docs = (await (tx || db.replicaNode())(TableName.CertificateSync)
+ const docs = (await (tx || db)(TableName.CertificateSync)
.whereIn("externalIdentifier", externalIdentifiers)
.andWhereNot({ pkiSyncId: excludePkiSyncId })
.select("externalIdentifier")) as Array<{ externalIdentifier: string | null }>;
diff --git a/backend/src/services/pki-sync/aws-secrets-manager/aws-secrets-manager-pki-sync-fns.ts b/backend/src/services/pki-sync/aws-secrets-manager/aws-secrets-manager-pki-sync-fns.ts
index d9b513a6d8..c77d91d27f 100644
--- a/backend/src/services/pki-sync/aws-secrets-manager/aws-secrets-manager-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/aws-secrets-manager/aws-secrets-manager-pki-sync-fns.ts
@@ -442,15 +442,13 @@ export const awsSecretsManagerPkiSyncFactory = ({
const allowPatternCleanup = !certificateNameSchemaHasFreeTextPlaceholder(syncOptions?.certificateNameSchema);
const orphanedSecretNames = Object.keys(existingSecrets).filter(
- (secretName) => !activeExternalIdentifiers.has(secretName)
+ (secretName) =>
+ !activeExternalIdentifiers.has(secretName) && (allowPatternCleanup || trackedExternalIds.has(secretName))
);
- const untrackedSecretNames = allowPatternCleanup
- ? orphanedSecretNames.filter((secretName) => !trackedExternalIds.has(secretName))
- : [];
- const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(untrackedSecretNames, pkiSync.id);
+ const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(orphanedSecretNames, pkiSync.id);
for (const secretName of orphanedSecretNames) {
- if (trackedExternalIds.has(secretName) || (allowPatternCleanup && !ownedByOtherSync.has(secretName))) {
+ if (!ownedByOtherSync.has(secretName)) {
try {
await withRateLimitRetry(
() =>
diff --git a/backend/src/services/pki-sync/azure-key-vault/azure-key-vault-pki-sync-fns.ts b/backend/src/services/pki-sync/azure-key-vault/azure-key-vault-pki-sync-fns.ts
index 76666b5a03..d96c2f8e4e 100644
--- a/backend/src/services/pki-sync/azure-key-vault/azure-key-vault-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/azure-key-vault/azure-key-vault-pki-sync-fns.ts
@@ -441,27 +441,35 @@ export const azureKeyVaultPkiSyncFactory = ({
const certificatesToRemove: string[] = [];
if (canRemoveCertificates) {
+ const removalCandidates = new Set<string>();
existingSyncRecords.forEach((syncRecord) => {
- if (syncRecord.externalIdentifier && !activeExternalIdentifiers.has(syncRecord.externalIdentifier)) {
- if (vaultCertificates[syncRecord.externalIdentifier]) {
- certificatesToRemove.push(syncRecord.externalIdentifier);
- }
+ if (
+ syncRecord.externalIdentifier &&
+ !activeExternalIdentifiers.has(syncRecord.externalIdentifier) &&
+ vaultCertificates[syncRecord.externalIdentifier]
+ ) {
+ removalCandidates.add(syncRecord.externalIdentifier);
}
});
if (!certificateNameSchemaHasFreeTextPlaceholder(syncOptions?.certificateNameSchema)) {
- const patternCandidates = Object.keys(vaultCertificates).filter(
- (certificateName) =>
+ Object.keys(vaultCertificates).forEach((certificateName) => {
+ if (
isInfisicalManagedCertificate(certificateName, pkiSync) &&
- !existingSyncRecords.some((record) => record.externalIdentifier === certificateName) &&
- !activeExternalIdentifiers.has(certificateName) &&
- !certificatesToRemove.includes(certificateName)
- );
- const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(patternCandidates, pkiSync.id);
- certificatesToRemove.push(
- ...patternCandidates.filter((certificateName) => !ownedByOtherSync.has(certificateName))
- );
+ !activeExternalIdentifiers.has(certificateName)
+ ) {
+ removalCandidates.add(certificateName);
+ }
+ });
}
+
+ const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(
+ [...removalCandidates],
+ pkiSync.id
+ );
+ certificatesToRemove.push(
+ ...[...removalCandidates].filter((certificateName) => !ownedByOtherSync.has(certificateName))
+ );
}
// Upload certificates to Azure Key Vault with rate limiting
diff --git a/backend/src/services/pki-sync/chef/chef-pki-sync-fns.ts b/backend/src/services/pki-sync/chef/chef-pki-sync-fns.ts
index e6654abbdd..810afcf59f 100644
--- a/backend/src/services/pki-sync/chef/chef-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/chef/chef-pki-sync-fns.ts
@@ -376,25 +376,19 @@ export const chefPkiSyncFactory = ({
let failedRemovals: Array<{ name: string; error: string }> = [];
if (canRemoveCertificates) {
- const itemsToRemove: string[] = [];
-
const trackedExternalIds = new Set(
existingSyncRecords.map((record) => record.externalIdentifier).filter((id): id is string => Boolean(id))
);
const allowPatternCleanup = !certificateNameSchemaHasFreeTextPlaceholder(syncOptions?.certificateNameSchema);
- const patternCandidates: string[] = [];
- Object.keys(chefDataBagItems).forEach((itemName) => {
- if (activeExternalIdentifiers.has(itemName)) return;
- if (trackedExternalIds.has(itemName)) {
- itemsToRemove.push(itemName);
- } else if (allowPatternCleanup && isInfisicalManagedCertificate(itemName, pkiSync)) {
- patternCandidates.push(itemName);
- }
- });
-
- const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(patternCandidates, pkiSync.id);
- itemsToRemove.push(...patternCandidates.filter((itemName) => !ownedByOtherSync.has(itemName)));
+ const removalCandidates = Object.keys(chefDataBagItems).filter(
+ (itemName) =>
+ !activeExternalIdentifiers.has(itemName) &&
+ (trackedExternalIds.has(itemName) ||
+ (allowPatternCleanup && isInfisicalManagedCertificate(itemName, pkiSync)))
+ );
+ const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(removalCandidates, pkiSync.id);
+ const itemsToRemove = removalCandidates.filter((itemName) => !ownedByOtherSync.has(itemName));
if (itemsToRemove.length > 0) {
const removalPromises = itemsToRemove.map(async (itemName) => {
diff --git a/backend/src/services/pki-sync/kemp-loadmaster/kemp-loadmaster-pki-sync-fns.ts b/backend/src/services/pki-sync/kemp-loadmaster/kemp-loadmaster-pki-sync-fns.ts
index b2117d477e..1877d55294 100644
--- a/backend/src/services/pki-sync/kemp-loadmaster/kemp-loadmaster-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/kemp-loadmaster/kemp-loadmaster-pki-sync-fns.ts
@@ -617,6 +617,7 @@ export const kempLoadMasterPkiSyncFactory = ({
const identifiersToRemove = new Set<string>();
if (canRemoveCertificates) {
+ const removalCandidates = new Set<string>();
for (const syncRecord of existingSyncRecords) {
if (
syncRecord.externalIdentifier &&
@@ -624,7 +625,7 @@ export const kempLoadMasterPkiSyncFactory = ({
existingCertNames.has(syncRecord.externalIdentifier) &&
!(syncRecord.certificateId && managedCertificateIds.has(syncRecord.certificateId))
) {
- identifiersToRemove.add(syncRecord.externalIdentifier);
+ removalCandidates.add(syncRecord.externalIdentifier);
}
}
@@ -632,21 +633,27 @@ export const kempLoadMasterPkiSyncFactory = ({
// this run so a failed upload is not treated as an orphan.
if (!certificateNameSchemaHasFreeTextPlaceholder(certificateNameSchema)) {
const managedCertNamePattern = buildManagedCertNamePattern(certificateNameSchema);
- const patternCandidates = [...existingCertNames].filter(
- (certName) =>
+ for (const certName of existingCertNames) {
+ if (
managedCertNamePattern.test(certName) &&
!activeIdentifiers.has(certName) &&
- !attemptedIdentifiers.has(certName) &&
- !identifiersToRemove.has(certName)
- );
- const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(patternCandidates, pkiSync.id);
- for (const certName of patternCandidates) {
- if (!ownedByOtherSync.has(certName)) {
- identifiersToRemove.add(certName);
+ !attemptedIdentifiers.has(certName)
+ ) {
+ removalCandidates.add(certName);
}
}
}
+ const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(
+ [...removalCandidates],
+ pkiSync.id
+ );
+ for (const identifier of removalCandidates) {
+ if (!ownedByOtherSync.has(identifier)) {
+ identifiersToRemove.add(identifier);
+ }
+ }
+
identifiersToRemove.forEach((identifier) => managedIdentifiers.add(identifier));
}
diff --git a/backend/src/services/pki-sync/netscaler/netscaler-pki-sync-fns.ts b/backend/src/services/pki-sync/netscaler/netscaler-pki-sync-fns.ts
index 38a274c98e..1b69756b73 100644
--- a/backend/src/services/pki-sync/netscaler/netscaler-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/netscaler/netscaler-pki-sync-fns.ts
@@ -569,7 +569,7 @@ export const netScalerPkiSyncFactory = ({
}
if (canRemoveCertificates) {
- const certKeysToRemove = new Set<string>();
+ const removalCandidates = new Set<string>();
for (const syncRecord of existingSyncRecords) {
if (
@@ -577,30 +577,26 @@ export const netScalerPkiSyncFactory = ({
!activeExternalIdentifiers.has(syncRecord.externalIdentifier) &&
existingCertKeyNames.has(syncRecord.externalIdentifier)
) {
- certKeysToRemove.add(syncRecord.externalIdentifier);
+ removalCandidates.add(syncRecord.externalIdentifier);
}
}
if (!certificateNameSchemaHasFreeTextPlaceholder(certificateNameSchema)) {
const managedCertNamePattern = buildManagedCertNamePattern(certificateNameSchema);
- const patternCandidates = [...existingCertKeyNames].filter(
- (certKeyName) =>
- managedCertNamePattern.test(certKeyName) &&
- !activeExternalIdentifiers.has(certKeyName) &&
- !certKeysToRemove.has(certKeyName)
- );
- const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(
- patternCandidates,
- pkiSync.id
- );
- for (const certKeyName of patternCandidates) {
- if (!ownedByOtherSync.has(certKeyName)) {
- certKeysToRemove.add(certKeyName);
+ for (const certKeyName of existingCertKeyNames) {
+ if (managedCertNamePattern.test(certKeyName) && !activeExternalIdentifiers.has(certKeyName)) {
+ removalCandidates.add(certKeyName);
}
}
}
+ const ownedByOtherSync = await certificateSyncDAL.findExternalIdentifiersInUse(
+ [...removalCandidates],
+ pkiSync.id
+ );
+ const certKeysToRemove = [...removalCandidates].filter((certKeyName) => !ownedByOtherSync.has(certKeyName));
+
for (const certKeyName of certKeysToRemove) {
try {
await removeNetScalerCertificate(session, certKeyName, config);