Skip to content

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

greptile fixes

Carlos Monastyrski8bdab25a2ba0
diff --git a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.test.ts b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.test.ts
index d6c9ce38f7..15bcf7f071 100644
--- a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.test.ts
+++ b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.test.ts
@@ -107,22 +107,35 @@ describe("DigiCert cancelPendingRequest", () => {
test("cancels the reissue on DigiCert for a reissue request", async () => {
const metadata = JSON.stringify({ digicert: { ...ORDER_METADATA, previousCertificateId: CURRENT_CERTIFICATE_ID } });
- await expect(buildFns(CURRENT_CERTIFICATE_ID).cancelPendingRequest({ caId: CA_ID, metadata })).resolves.toBe(true);
+ await expect(
+ buildFns(CURRENT_CERTIFICATE_ID).cancelPendingRequest({ caId: CA_ID, metadata })
+ ).resolves.toBeUndefined();
expect(client.cancelOrderReissue).toHaveBeenCalledWith(ORDER_ID, expect.any(String));
});
test("does nothing for a new order", async () => {
const metadata = JSON.stringify({ digicert: ORDER_METADATA });
- await expect(buildFns(CURRENT_CERTIFICATE_ID).cancelPendingRequest({ caId: CA_ID, metadata })).resolves.toBe(false);
+ await expect(
+ buildFns(CURRENT_CERTIFICATE_ID).cancelPendingRequest({ caId: CA_ID, metadata })
+ ).resolves.toBeUndefined();
expect(client.cancelOrderReissue).not.toHaveBeenCalled();
});
test("does nothing when the metadata is missing or not JSON", async () => {
const fns = buildFns(CURRENT_CERTIFICATE_ID);
- await expect(fns.cancelPendingRequest({ caId: CA_ID, metadata: null })).resolves.toBe(false);
- await expect(fns.cancelPendingRequest({ caId: CA_ID, metadata: "not json" })).resolves.toBe(false);
+ await expect(fns.cancelPendingRequest({ caId: CA_ID, metadata: null })).resolves.toBeUndefined();
+ await expect(fns.cancelPendingRequest({ caId: CA_ID, metadata: "not json" })).resolves.toBeUndefined();
expect(client.cancelOrderReissue).not.toHaveBeenCalled();
});
+
+ test("refuses when DigiCert does not confirm the cancellation", async () => {
+ client.cancelOrderReissue.mockRejectedValue(new Error("no response"));
+ const metadata = JSON.stringify({ digicert: { ...ORDER_METADATA, previousCertificateId: CURRENT_CERTIFICATE_ID } });
+
+ await expect(buildFns(CURRENT_CERTIFICATE_ID).cancelPendingRequest({ caId: CA_ID, metadata })).rejects.toThrow(
+ `DigiCert didn't cancel the reissue on order ${ORDER_ID}`
+ );
+ });
});
diff --git a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.ts b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.ts
index c1a03a4844..81735c4ce3 100644
--- a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.ts
+++ b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-fns.ts
@@ -647,20 +647,25 @@ export const DigiCertCertificateAuthorityFns = ({
}: {
caId: string;
metadata: string | null | undefined;
- }): Promise<boolean> => {
- if (!metadata) return false;
+ }): Promise<void> => {
+ if (!metadata) return;
let parsedMetadata: unknown;
try {
parsedMetadata = JSON.parse(metadata);
} catch {
- return false;
+ return;
}
const parsed = DigiCertCertificateRequestMetadataSchema.safeParse(parsedMetadata);
- if (!parsed.success || parsed.data.digicert.previousCertificateId === undefined) return false;
+ if (!parsed.success || parsed.data.digicert.previousCertificateId === undefined) return;
- return cancelReissue({ caId, orderId: parsed.data.digicert.orderId });
+ const { orderId } = parsed.data.digicert;
+ if (!(await cancelReissue({ caId, orderId }))) {
+ throw new BadRequestError({
+ message: `DigiCert didn't cancel the reissue on order ${orderId}, so the request is still open. Try again in a few minutes, or cancel the reissue in DigiCert CertCentral.`
+ });
+ }
};
const fetchAndAttachIssuedCertificate = async ({
diff --git a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.test.ts b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.test.ts
index 36d4c7bc66..ce84ba84be 100644
--- a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.test.ts
+++ b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.test.ts
@@ -110,7 +110,16 @@ describe("processDigiCertPendingValidationRequest reissue", () => {
const { deps, cancelReissue } = buildDeps();
const dayAgo = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
- const result = await processDigiCertPendingValidationRequest(deps, buildRequest(dayAgo), buildClientCache({}));
+ const client = {
+ getOrder: vi.fn().mockResolvedValue({
+ id: ORDER_ID,
+ status: "reissue_pending",
+ certificate: { id: PREVIOUS_CERTIFICATE_ID }
+ }),
+ checkValidation: vi.fn().mockResolvedValue({ order_status: "reissue_pending", dcv_status: "pending" })
+ };
+
+ const result = await processDigiCertPendingValidationRequest(deps, buildRequest(dayAgo), buildClientCache(client));
expect(cancelReissue).toHaveBeenCalledWith({ caId: CA_ID, orderId: ORDER_ID });
expect(result.status).toBe(CertificateRequestStatus.FAILED);
@@ -120,4 +129,25 @@ describe("processDigiCertPendingValidationRequest reissue", () => {
})
);
});
+
+ test("attaches a reissue DigiCert finished after 24 hours instead of timing it out", async () => {
+ const { deps, fetchAndAttachIssuedCertificate, cancelReissue } = buildDeps();
+ const dayAgo = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
+ const client = {
+ getOrder: vi.fn().mockResolvedValue({
+ id: ORDER_ID,
+ status: "issued",
+ certificate: { id: REISSUED_CERTIFICATE_ID }
+ }),
+ checkValidation: vi.fn()
+ };
+
+ const result = await processDigiCertPendingValidationRequest(deps, buildRequest(dayAgo), buildClientCache(client));
+
+ expect(fetchAndAttachIssuedCertificate).toHaveBeenCalledWith(
+ expect.objectContaining({ digicertCertificateId: REISSUED_CERTIFICATE_ID })
+ );
+ expect(cancelReissue).not.toHaveBeenCalled();
+ expect(result.status).toBe(CertificateRequestStatus.ISSUED);
+ });
});
diff --git a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.ts b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.ts
index a8e3b8d99b..6bb784cc6f 100644
--- a/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.ts
+++ b/backend/src/services/certificate-authority/digicert/digicert-certificate-authority-processor.ts
@@ -139,28 +139,6 @@ export const processDigiCertPendingValidationRequest = async (
const parsed = parseResult.data as TDigiCertOrderMetadata;
const age = Date.now() - new Date(parsed.digicert.orderPlacedAt).getTime();
- if (age >= DIGICERT_VALIDATION_TIMEOUT_MS) {
- let errorMessage = "Validation timed out after 24h";
- if (parsed.digicert.previousCertificateId !== undefined) {
- const isReissueCanceled = await deps.digicertFns.cancelReissue({
- caId: request.caId,
- orderId: parsed.digicert.orderId
- });
- errorMessage = isReissueCanceled
- ? `DigiCert didn't finish the reissue on order ${parsed.digicert.orderId} within 24 hours, so it was canceled. Submit a new request to reissue again.`
- : `DigiCert didn't finish the reissue on order ${parsed.digicert.orderId} within 24 hours. Cancel the reissue in DigiCert CertCentral and submit a new request. Finishing it in CertCentral won't bring its certificate into Infisical.`;
- }
- await deps.certificateRequestService.updateCertificateRequestStatus({
- certificateRequestId: request.id,
- status: CertificateRequestStatus.FAILED,
- operation: parsed.digicert.isRenewal ? CertificateIssuanceOperation.RENEW : CertificateIssuanceOperation.ORDER,
- originalCertificateId: parsed.digicert.originalCertificateId,
- errorMessage
- });
- logger.info(`DigiCert validation timed out [certificateRequestId=${request.id}]`);
- return { status: CertificateRequestStatus.FAILED, orderStatus: "timeout", reason: "timeout" };
- }
-
const client = await getOrCreateClient(request, deps, clientCache);
const orderInfo = await client.getOrder(parsed.digicert.orderId);
@@ -265,6 +243,28 @@ export const processDigiCertPendingValidationRequest = async (
};
}
+ if (age >= DIGICERT_VALIDATION_TIMEOUT_MS) {
+ let errorMessage = "Validation timed out after 24h";
+ if (parsed.digicert.previousCertificateId !== undefined) {
+ const isReissueCanceled = await deps.digicertFns.cancelReissue({
+ caId: request.caId,
+ orderId: parsed.digicert.orderId
+ });
+ errorMessage = isReissueCanceled
+ ? `DigiCert didn't finish the reissue on order ${parsed.digicert.orderId} within 24 hours, so it was canceled. Submit a new request to reissue again.`
+ : `DigiCert didn't finish the reissue on order ${parsed.digicert.orderId} within 24 hours. Cancel the reissue in DigiCert CertCentral and submit a new request. Finishing it in CertCentral won't bring its certificate into Infisical.`;
+ }
+ await deps.certificateRequestService.updateCertificateRequestStatus({
+ certificateRequestId: request.id,
+ status: CertificateRequestStatus.FAILED,
+ operation: parsed.digicert.isRenewal ? CertificateIssuanceOperation.RENEW : CertificateIssuanceOperation.ORDER,
+ originalCertificateId: parsed.digicert.originalCertificateId,
+ errorMessage
+ });
+ logger.info(`DigiCert validation timed out [certificateRequestId=${request.id}]`);
+ return { status: CertificateRequestStatus.FAILED, orderStatus: "timeout", reason: "timeout" };
+ }
+
await deps.certificateRequestDAL.updateById(request.id, {
metadata: JSON.stringify({
...parsed,
diff --git a/backend/src/services/certificate-request/certificate-request-service.test.ts b/backend/src/services/certificate-request/certificate-request-service.test.ts
index bf4e72522e..e27beaf984 100644
--- a/backend/src/services/certificate-request/certificate-request-service.test.ts
+++ b/backend/src/services/certificate-request/certificate-request-service.test.ts
@@ -987,6 +987,15 @@ describe("CertificateRequestService", () => {
expect(mockDigicertFns.cancelPendingRequest).not.toHaveBeenCalled();
});
+
+ it("keeps the request open when DigiCert does not cancel the reissue", async () => {
+ mockDigicertFns.cancelPendingRequest.mockRejectedValueOnce(
+ new Error("DigiCert didn't cancel the reissue on order 7001, so the request is still open.")
+ );
+
+ await expect(cancelValidationRow(CaType.DIGICERT)).rejects.toThrow("so the request is still open");
+ expect(mockCertificateRequestDAL.transitionFromPending).not.toHaveBeenCalled();
+ });
});
it("returns cancelled:false when the worker races to a terminal status", async () => {
diff --git a/backend/src/services/certificate-request/certificate-request-service.ts b/backend/src/services/certificate-request/certificate-request-service.ts
index d4e3743557..3739c945f9 100644
--- a/backend/src/services/certificate-request/certificate-request-service.ts
+++ b/backend/src/services/certificate-request/certificate-request-service.ts
@@ -704,6 +704,16 @@ export const certificateRequestServiceFactory = ({
actorLabel = identity?.name ? `identity ${identity.name}` : "identity";
}
+ if (previousStatus === CertificateRequestStatus.PENDING_VALIDATION && certificateRequest.caId) {
+ const ca = await certificateAuthorityDAL.findByIdWithAssociatedCa(certificateRequest.caId);
+ if (ca?.externalCa?.type === CaType.DIGICERT) {
+ await digicertFns.cancelPendingRequest({
+ caId: certificateRequest.caId,
+ metadata: certificateRequest.metadata
+ });
+ }
+ }
+
const updated = await certificateRequestDAL.transitionFromPending(
certificateRequestId,
CertificateRequestStatus.FAILED,
@@ -750,16 +760,6 @@ export const certificateRequestServiceFactory = ({
);
}
- if (previousStatus === CertificateRequestStatus.PENDING_VALIDATION && certificateRequest.caId) {
- const ca = await certificateAuthorityDAL.findByIdWithAssociatedCa(certificateRequest.caId);
- if (ca?.externalCa?.type === CaType.DIGICERT) {
- await digicertFns.cancelPendingRequest({
- caId: certificateRequest.caId,
- metadata: certificateRequest.metadata
- });
- }
- }
-
return {
certificateRequest: updated,
projectId: certificateRequest.projectId,