Skip to content

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

fix(pki): release an imperva slot claim when the upload is refused

bernie-gca98e87b46af
diff --git a/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.test.ts b/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.test.ts
index d659422a3d..37180fe0de 100644
--- a/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.test.ts
+++ b/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.test.ts
@@ -374,7 +374,59 @@ describe("Imperva retry decisions", () => {
expect(isImpervaRetryable(new Error("socket hang up"))).toBe(true);
});
- test("does not claim a slot when the upload is rejected", async () => {
+ test("releases the claim when Imperva refuses, and keeps it when the answer is unknown", async () => {
+ const { impervaPkiSyncFactory } = await import("./imperva-pki-sync-fns");
+ const { ImpervaRequestError } = await import("@app/services/app-connection/imperva/imperva-connection-fns");
+
+ const run = async (error: Error, existing: Array<Record<string, unknown>>) => {
+ impervaRequest.mockReset();
+ impervaRequest.mockRejectedValue(error);
+ const removeCertificates = vi.fn();
+ const updateById = vi.fn();
+ const factory = impervaPkiSyncFactory({
+ certificateSyncDAL: {
+ findByPkiSyncId: vi.fn().mockResolvedValue(existing),
+ removeCertificates,
+ addCertificates: vi.fn(),
+ findByPkiSyncAndCertificate: vi.fn().mockResolvedValue(undefined),
+ updateById,
+ updateSyncStatus: vi.fn(),
+ findExternalIdentifiersInUse: vi.fn().mockResolvedValue(new Set<string>()),
+ claimExternalIdentifier: vi.fn()
+ } as never,
+ certificateDAL: { findById: vi.fn().mockResolvedValue(undefined) } as never
+ });
+
+ await expect(
+ factory.syncCertificates(
+ {
+ id: "sync-1",
+ destination: "imperva",
+ projectId: "project-1",
+ destinationConfig: { siteId: "111", siteName: "waf.example.com" },
+ syncOptions: { canRemoveCertificates: true },
+ connection: { credentials: { apiId: "id", apiKey: "key" }, gatewayId: null, gatewayPoolId: null }
+ } as never,
+ { leaf: { cert: RSA_CERT_PEM, privateKey: "key", certificateId: "cert-1" } } as never
+ )
+ ).rejects.toThrow();
+
+ return { removeCertificates, updateById };
+ };
+
+ const refused = await run(new ImpervaRequestError({ message: "Invalid input", status: 400 }), []);
+ expect(refused.removeCertificates).toHaveBeenCalledWith("sync-1", ["cert-1"]);
+
+ const renewed = await run(new ImpervaRequestError({ message: "Invalid input", status: 400 }), [
+ { id: "row-1", certificateId: "cert-1", externalIdentifier: "111:ECC" }
+ ]);
+ expect(renewed.updateById).toHaveBeenCalledWith("row-1", { externalIdentifier: "111:ECC" });
+
+ const unknown = await run(new Error("socket hang up"), []);
+ expect(unknown.removeCertificates).not.toHaveBeenCalled();
+ });
+
+ test("marks a refused upload as final rather than retrying it", async () => {
const { impervaPkiSyncFactory } = await import("./imperva-pki-sync-fns");
const { ImpervaRequestError } = await import("@app/services/app-connection/imperva/imperva-connection-fns");
@@ -410,6 +462,6 @@ describe("Imperva retry decisions", () => {
)
).rejects.toMatchObject({ shouldRetry: false });
- expect(claimExternalIdentifier).not.toHaveBeenCalled();
+ expect(claimExternalIdentifier).toHaveBeenCalledWith("sync-1", "cert-1", "111:RSA");
});
});
diff --git a/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.ts b/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.ts
index 9636f37671..61ee1375f1 100644
--- a/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.ts
+++ b/backend/src/services/pki-sync/imperva/imperva-pki-sync-fns.ts
@@ -389,6 +389,18 @@ export const impervaPkiSyncFactory = ({
const externalIdentifier = buildImpervaExternalIdentifier(siteId, authType);
+ // Claimed up front so the slot is never held by a live certificate no record points at,
+ // and released below when Imperva answers that it wrote nothing.
+ const claimedRecord = certificate.certificateId
+ ? existingSyncRecords.find(
+ (record: TCertificateSyncs) => record.certificateId === certificate.certificateId
+ )
+ : undefined;
+
+ if (certificate.certificateId) {
+ await certificateSyncDAL.claimExternalIdentifier(pkiSync.id, certificate.certificateId, externalIdentifier);
+ }
+
try {
await uploadCustomCertificate(makeRequest, credentials, siteId, {
certificate: buildImpervaCertificatePayload(certificate.cert, certificate.certificateChain),
@@ -399,16 +411,6 @@ export const impervaPkiSyncFactory = ({
occupiedSlots.add(externalIdentifier);
uploaded += 1;
- // Claimed only once the upload has landed. A claim for a slot nothing was written to
- // would stop another sync cleaning up a certificate this one never placed.
- if (certificate.certificateId) {
- await certificateSyncDAL.claimExternalIdentifier(
- pkiSync.id,
- certificate.certificateId,
- externalIdentifier
- );
- }
-
deploymentWarning = await buildDeploymentWarning(makeRequest, credentials, siteId, authType);
if (deploymentWarning) {
undeployedCertificates.push({ name: certificate.certName, error: deploymentWarning });
@@ -446,6 +448,18 @@ export const impervaPkiSyncFactory = ({
`Imperva PKI sync [syncId=${pkiSync.id}]: uploaded ${authType} custom certificate to site ${siteLabel}`
);
} catch (error: unknown) {
+ // Imperva answering a refusal means nothing was written, so the claim has to go back to
+ // whatever it said before. A timeout says nothing either way, so the claim stands.
+ if (certificate.certificateId && !isImpervaRetryable(error)) {
+ if (claimedRecord) {
+ await certificateSyncDAL.updateById(claimedRecord.id, {
+ externalIdentifier: claimedRecord.externalIdentifier
+ });
+ } else {
+ await certificateSyncDAL.removeCertificates(pkiSync.id, [certificate.certificateId]);
+ }
+ }
+
const errorMessage = describeImpervaUploadFailure(error);
uploadRetryable = isImpervaRetryable(error);
failedUploads.push({ name: certificate.certName, error: errorMessage });