Skip to content

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

Address PR comments

Carlos Monastyrski97edaa51629c
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 53762fd902..d6c9ce38f7 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
@@ -4,7 +4,8 @@ import { DigiCertCertificateAuthorityFns } from "./digicert-certificate-authorit
const client = {
getOrder: vi.fn(),
reissueOrder: vi.fn(),
- downloadCertificatePem: vi.fn()
+ downloadCertificatePem: vi.fn(),
+ cancelOrderReissue: vi.fn()
};
vi.mock("@app/lib/logger", () => ({ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() } }));
@@ -89,3 +90,39 @@ describe("DigiCert reissueCertificate", () => {
expect(client.reissueOrder).not.toHaveBeenCalled();
});
});
+
+const ORDER_METADATA = {
+ orderId: ORDER_ID,
+ productNameId: "ssl_basic",
+ organizationId: 777,
+ orderPlacedAt: "2026-11-01T00:00:00.000Z"
+};
+
+describe("DigiCert cancelPendingRequest", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ client.cancelOrderReissue.mockResolvedValue(undefined);
+ });
+
+ 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);
+ 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);
+ 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);
+ expect(client.cancelOrderReissue).not.toHaveBeenCalled();
+ });
+});
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 9d658e0bca..c1a03a4844 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
@@ -39,7 +39,7 @@ import {
DigiCertOrderStatus,
DigiCertPollOutcome
} from "./digicert-certificate-authority-enums";
-import { DigiCertCaPurpose } from "./digicert-certificate-authority-schemas";
+import { DigiCertCaPurpose, DigiCertCertificateRequestMetadataSchema } from "./digicert-certificate-authority-schemas";
import {
castDbEntryToDigiCertCertificateAuthority,
extractLeafAndChain,
@@ -641,6 +641,28 @@ export const DigiCertCertificateAuthorityFns = ({
}
};
+ const cancelPendingRequest = async ({
+ caId,
+ metadata
+ }: {
+ caId: string;
+ metadata: string | null | undefined;
+ }): Promise<boolean> => {
+ if (!metadata) return false;
+
+ let parsedMetadata: unknown;
+ try {
+ parsedMetadata = JSON.parse(metadata);
+ } catch {
+ return false;
+ }
+
+ const parsed = DigiCertCertificateRequestMetadataSchema.safeParse(parsedMetadata);
+ if (!parsed.success || parsed.data.digicert.previousCertificateId === undefined) return false;
+
+ return cancelReissue({ caId, orderId: parsed.data.digicert.orderId });
+ };
+
const fetchAndAttachIssuedCertificate = async ({
caId,
certificateRequest,
@@ -929,6 +951,7 @@ export const DigiCertCertificateAuthorityFns = ({
orderCertificate,
reissueCertificate,
cancelReissue,
+ cancelPendingRequest,
fetchAndAttachIssuedCertificate,
pollOrderForCertificate,
revokeCertificate,
diff --git a/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.test.ts b/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.test.ts
index 537a359608..6f726ddc57 100644
--- a/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.test.ts
+++ b/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.test.ts
@@ -35,7 +35,7 @@ const RSA_ALG: RsaHashedKeyGenParams = {
};
const REVOKED_AT = new Date("2026-10-28T09:02:41.000Z");
-const replacedCertificate = (id: string) => ({
+const activeCertificate = (id: string) => ({
id,
commonName: "example.com",
serialNumber: id,
@@ -76,18 +76,18 @@ beforeAll(async () => {
});
const runSync = async ({
- replaced,
+ active,
revokedOrderCertificates = [],
storedBody = certificateBody
}: {
- replaced: (ReturnType<typeof replacedCertificate> & { externalMetadata?: unknown })[];
- revokedOrderCertificates?: ReturnType<typeof replacedCertificate>[];
+ active: (ReturnType<typeof activeCertificate> & { externalMetadata?: unknown })[];
+ revokedOrderCertificates?: ReturnType<typeof activeCertificate>[];
storedBody?: typeof certificateBody | null;
}) => {
let handler: (() => Promise<void>) | undefined;
const certificateDAL = {
findActiveDigiCertCertsByOrderIds: vi.fn().mockResolvedValue(revokedOrderCertificates),
- findActiveDigiCertCertsReplacedOnOrder: vi.fn().mockResolvedValue(replaced),
+ findActiveDigiCertCertsByCaId: vi.fn().mockResolvedValue(active),
updateById: vi.fn()
};
listOrderStatusChanges.mockResolvedValue({
@@ -116,15 +116,15 @@ const runSync = async ({
return certificateDAL;
};
-describe("DigiCert revocation sync, certificates replaced on their order", () => {
+describe("DigiCert revocation sync, OCSP check of active certificates", () => {
beforeEach(() => {
vi.clearAllMocks();
});
- test("marks a replaced certificate revoked when OCSP reports it revoked", async () => {
+ test("marks a certificate revoked when OCSP reports it revoked", async () => {
getCertificateOcspStatus.mockResolvedValue({ status: OcspCertStatus.Revoked, revokedAt: REVOKED_AT });
- const certificateDAL = await runSync({ replaced: [replacedCertificate("cert-1")] });
+ const certificateDAL = await runSync({ active: [activeCertificate("cert-1")] });
expect(certificateDAL.updateById).toHaveBeenCalledWith(
"cert-1",
@@ -132,10 +132,10 @@ describe("DigiCert revocation sync, certificates replaced on their order", () =>
);
});
- test("leaves a replaced certificate active when OCSP reports it good", async () => {
+ test("leaves a certificate active when OCSP reports it good", async () => {
getCertificateOcspStatus.mockResolvedValue({ status: OcspCertStatus.Good });
- const certificateDAL = await runSync({ replaced: [replacedCertificate("cert-1")] });
+ const certificateDAL = await runSync({ active: [activeCertificate("cert-1")] });
expect(certificateDAL.updateById).not.toHaveBeenCalled();
});
@@ -146,7 +146,7 @@ describe("DigiCert revocation sync, certificates replaced on their order", () =>
.mockResolvedValueOnce({ status: OcspCertStatus.Revoked, revokedAt: REVOKED_AT });
const certificateDAL = await runSync({
- replaced: [replacedCertificate("cert-1"), replacedCertificate("cert-2")]
+ active: [activeCertificate("cert-1"), activeCertificate("cert-2")]
});
expect(certificateDAL.updateById).toHaveBeenCalledTimes(1);
@@ -155,8 +155,8 @@ describe("DigiCert revocation sync, certificates replaced on their order", () =>
test("skips certificates already revoked with their order", async () => {
const certificateDAL = await runSync({
- replaced: [replacedCertificate("cert-1")],
- revokedOrderCertificates: [replacedCertificate("cert-1")]
+ active: [activeCertificate("cert-1")],
+ revokedOrderCertificates: [activeCertificate("cert-1")]
});
expect(getCertificateOcspStatus).not.toHaveBeenCalled();
@@ -168,9 +168,9 @@ describe("DigiCert revocation sync, certificates replaced on their order", () =>
getCertificateOcspStatus.mockResolvedValue({ status: OcspCertStatus.Revoked, revokedAt: REVOKED_AT });
const certificateDAL = await runSync({
- replaced: [
+ active: [
{
- ...replacedCertificate("cert-1"),
+ ...activeCertificate("cert-1"),
externalMetadata: { type: "digicert", orderId: 7001, certificateId: 50001 }
}
],
diff --git a/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.ts b/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.ts
index 37d430aa55..5f6e36f68f 100644
--- a/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.ts
+++ b/backend/src/services/certificate-authority/digicert/digicert-revocation-sync-queue.ts
@@ -1,5 +1,6 @@
/* eslint-disable no-await-in-loop */
import * as x509 from "@peculiar/x509";
+import pLimit from "p-limit";
import { TableName } from "@app/db/schemas";
import { EventType, TAuditLogServiceFactory } from "@app/ee/services/audit-log/audit-log-types";
@@ -39,13 +40,14 @@ const REVOCATION_SYNC_CRON_SCHEDULE = "0 3 * * *";
const REVOCATION_LOOKBACK_SECONDS = 6 * 24 * 60 * 60;
const ORDER_ID_LOOKUP_CHUNK_SIZE = 500;
const HANDLER_TIMEOUT_MS = 30 * 60 * 1000;
+const OCSP_CHECK_CONCURRENCY = 4;
type TDigiCertRevocationSyncQueueFactoryDep = {
cronJob: TCronJobFactory;
certificateAuthorityDAL: Pick<TCertificateAuthorityDALFactory, "findWithAssociatedCa">;
certificateDAL: Pick<
TCertificateDALFactory,
- "findActiveDigiCertCertsByOrderIds" | "findActiveDigiCertCertsReplacedOnOrder" | "updateById"
+ "findActiveDigiCertCertsByOrderIds" | "findActiveDigiCertCertsByCaId" | "updateById"
>;
certificateBodyDAL: Pick<TCertificateBodyDALFactory, "findOne">;
projectDAL: Pick<TProjectDALFactory, "findOne" | "updateById" | "transaction">;
@@ -153,12 +155,12 @@ export const digicertRevocationSyncQueueFactory = ({
return issuer ? { certificate, issuer } : null;
};
- const syncReplacedCertificateRevocations = async (
+ const syncCertificateRevocationsFromOcsp = async (
caId: string,
digicertClient: TDigiCertApiClient,
alreadyRevokedIds: Set<string>
) => {
- const replacedCertificates = await certificateDAL.findActiveDigiCertCertsReplacedOnOrder(caId);
+ const activeCertificates = await certificateDAL.findActiveDigiCertCertsByCaId(caId);
const kmsDecryptorsByProjectId = new Map<string, (args: { cipherTextBlob: Buffer }) => Promise<Buffer>>();
const getKmsDecryptor = async (projectId: string) => {
@@ -170,29 +172,34 @@ export const digicertRevocationSyncQueueFactory = ({
return kmsDecryptor;
};
- let revokedCount = 0;
- for (const cert of replacedCertificates.filter(({ id }) => !alreadyRevokedIds.has(id))) {
- try {
- const certificateAndIssuer = await loadCertificateAndIssuer(cert, digicertClient, getKmsDecryptor);
- if (!certificateAndIssuer) {
- throw new Error("No issuer certificate stored for the certificate");
- }
+ const certificatesToCheck = activeCertificates.filter(({ id }) => !alreadyRevokedIds.has(id));
+ const ocspLimit = pLimit(OCSP_CHECK_CONCURRENCY);
+ const outcomes = await Promise.all(
+ certificatesToCheck.map((cert) =>
+ ocspLimit(async () => {
+ try {
+ const certificateAndIssuer = await loadCertificateAndIssuer(cert, digicertClient, getKmsDecryptor);
+ if (!certificateAndIssuer) return "skipped" as const;
- const { status, revokedAt } = await getCertificateOcspStatus(certificateAndIssuer);
- if (status === OcspCertStatus.Revoked) {
- await markCertificateRevokedLocally(cert, revokedAt);
- revokedCount += 1;
- logger.info(
- `digicert-revocation-sync: marked revoked from OCSP [caId=${caId}] [certId=${cert.id}] [serial=${cert.serialNumber}]`
- );
- }
- } catch (err) {
- logger.warn(err, `digicert-revocation-sync: OCSP check failed [caId=${caId}] [certId=${cert.id}]`);
- }
- }
+ const { status, revokedAt } = await getCertificateOcspStatus(certificateAndIssuer);
+ if (status !== OcspCertStatus.Revoked) return "checked" as const;
+
+ await markCertificateRevokedLocally(cert, revokedAt);
+ logger.info(
+ `digicert-revocation-sync: marked revoked from OCSP [caId=${caId}] [certId=${cert.id}] [serial=${cert.serialNumber}]`
+ );
+ return "revoked" as const;
+ } catch (err) {
+ logger.warn(err, `digicert-revocation-sync: OCSP check failed [caId=${caId}] [certId=${cert.id}]`);
+ return "failed" as const;
+ }
+ })
+ )
+ );
+ const countOf = (outcome: (typeof outcomes)[number]) => outcomes.filter((value) => value === outcome).length;
logger.info(
- `digicert-revocation-sync: OCSP check done [caId=${caId}] [checked=${replacedCertificates.length}] [revoked=${revokedCount}]`
+ `digicert-revocation-sync: OCSP check done [caId=${caId}] [checked=${certificatesToCheck.length}] [revoked=${countOf("revoked")}] [failed=${countOf("failed")}] [skippedNoIssuer=${countOf("skipped")}]`
);
};
@@ -239,7 +246,7 @@ export const digicertRevocationSyncQueueFactory = ({
`digicert-revocation-sync: CA done [caId=${ca.id}] [upstreamRevoked=${upstreamRevokedOrderIds.length}] [reconciled=${reconciledCertificateIds.size}]`
);
- await syncReplacedCertificateRevocations(ca.id, digicertClient, reconciledCertificateIds);
+ return { caId: ca.id, digicertClient, reconciledCertificateIds };
};
const init = () => {
@@ -260,9 +267,10 @@ export const digicertRevocationSyncQueueFactory = ({
let succeededCaCount = 0;
let failedCaCount = 0;
+ const syncedCertificateAuthorities: Awaited<ReturnType<typeof syncRevocationsForCertificateAuthority>>[] = [];
for (const caRow of digicertCertificateAuthorities) {
try {
- await syncRevocationsForCertificateAuthority(caRow);
+ syncedCertificateAuthorities.push(await syncRevocationsForCertificateAuthority(caRow));
succeededCaCount += 1;
} catch (err) {
failedCaCount += 1;
@@ -270,6 +278,14 @@ export const digicertRevocationSyncQueueFactory = ({
}
}
+ for (const { caId, digicertClient, reconciledCertificateIds } of syncedCertificateAuthorities) {
+ try {
+ await syncCertificateRevocationsFromOcsp(caId, digicertClient, reconciledCertificateIds);
+ } catch (err) {
+ logger.error(err, `digicert-revocation-sync: OCSP check failed for CA [caId=${caId}]`);
+ }
+ }
+
logger.info(
`digicert-revocation-sync: completed [casScanned=${digicertCertificateAuthorities.length}] [succeeded=${succeededCaCount}] [failed=${failedCaCount}]`
);
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 b217492770..bf4e72522e 100644
--- a/backend/src/services/certificate-request/certificate-request-service.test.ts
+++ b/backend/src/services/certificate-request/certificate-request-service.test.ts
@@ -68,6 +68,7 @@ describe("CertificateRequestService", () => {
const mockCertificateProfileDAL = { findById: vi.fn() };
const mockCertificateAuthorityDAL = { findById: vi.fn(), findByIdWithAssociatedCa: vi.fn() };
const mockAuditLogService = { createCollapsedAuditLog: vi.fn() };
+ const mockDigicertFns = { cancelPendingRequest: vi.fn() };
beforeEach(() => {
vi.clearAllMocks();
@@ -85,7 +86,7 @@ describe("CertificateRequestService", () => {
certificateProfileDAL: mockCertificateProfileDAL as any,
certificateAuthorityDAL: mockCertificateAuthorityDAL as any,
auditLogService: mockAuditLogService,
- digicertFns: { cancelReissue: vi.fn().mockResolvedValue(true) }
+ digicertFns: mockDigicertFns
});
});
@@ -944,6 +945,50 @@ describe("CertificateRequestService", () => {
});
});
+ describe("a request waiting on CA validation", () => {
+ const caId = "550e8400-e29b-41d4-a716-446655440300";
+ const metadata = JSON.stringify({ digicert: { orderId: 7001, previousCertificateId: 50001 } });
+ const validationRow = {
+ id: requestId,
+ status: CertificateRequestStatus.PENDING_VALIDATION,
+ projectId,
+ applicationId: null,
+ altNames: null,
+ commonName: "test.example.com",
+ pendingMessage: "Awaiting CA validation",
+ caId,
+ metadata
+ };
+
+ const cancelValidationRow = async (externalCaType: CaType) => {
+ (mockCertificateRequestDAL.findById as any).mockResolvedValue(validationRow);
+ (mockPermissionService.getProjectPermission as any).mockResolvedValue(projectPermissionWithEdit);
+ (mockCertificateRequestDAL.transitionFromPending as any).mockResolvedValue({
+ ...validationRow,
+ status: CertificateRequestStatus.FAILED
+ });
+ (mockUserDAL.findById as any).mockResolvedValue({ username: "john.smith" });
+ (mockCertificateAuthorityDAL.findByIdWithAssociatedCa as any).mockResolvedValue({
+ id: caId,
+ externalCa: { type: externalCaType }
+ });
+
+ return service.cancelCertificateRequest(cancelInput);
+ };
+
+ it("hands the request to DigiCert so a pending reissue is cancelled there", async () => {
+ await cancelValidationRow(CaType.DIGICERT);
+
+ expect(mockDigicertFns.cancelPendingRequest).toHaveBeenCalledWith({ caId, metadata });
+ });
+
+ it("leaves other CAs alone", async () => {
+ await cancelValidationRow(CaType.ACME);
+
+ expect(mockDigicertFns.cancelPendingRequest).not.toHaveBeenCalled();
+ });
+ });
+
it("returns cancelled:false when the worker races to a terminal status", async () => {
const pendingRow = {
id: requestId,
diff --git a/backend/src/services/certificate-request/certificate-request-service.ts b/backend/src/services/certificate-request/certificate-request-service.ts
index af50e85c15..1e7afd4de0 100644
--- a/backend/src/services/certificate-request/certificate-request-service.ts
+++ b/backend/src/services/certificate-request/certificate-request-service.ts
@@ -19,6 +19,7 @@ import { BadRequestError, NotFoundError } from "@app/lib/errors";
import { logger } from "@app/lib/logger";
import { QueueName, TQueueServiceFactory } from "@app/queue";
import { TCertificateAuthorityDALFactory } from "@app/services/certificate-authority/certificate-authority-dal";
+import { CaType } from "@app/services/certificate-authority/certificate-authority-enums";
import {
CertificateIssuanceOperation,
domainComponentsSchema,
@@ -35,7 +36,6 @@ import { TPkiApplicationDALFactory } from "@app/services/pki-application/pki-app
import { ActorAuthMethod, ActorType } from "../auth/auth-type";
import { TDigiCertCertificateAuthorityFns } from "../certificate-authority/digicert/digicert-certificate-authority-fns";
-import { DigiCertCertificateRequestMetadataSchema } from "../certificate-authority/digicert/digicert-certificate-authority-schemas";
import { TIdentityDALFactory } from "../identity/identity-dal";
import { TResourceMetadataDALFactory } from "../resource-metadata/resource-metadata-dal";
import { TUserDALFactory } from "../user/user-dal";
@@ -64,19 +64,7 @@ type TCertificateRequestServiceFactoryDep = {
certificateProfileDAL: Pick<TCertificateProfileDALFactory, "findById">;
certificateAuthorityDAL: Pick<TCertificateAuthorityDALFactory, "findById" | "findByIdWithAssociatedCa">;
auditLogService: Pick<TAuditLogServiceFactory, "createCollapsedAuditLog">;
- digicertFns: Pick<TDigiCertCertificateAuthorityFns, "cancelReissue">;
-};
-
-const getPendingDigiCertReissueOrderId = (metadata: string | null | undefined) => {
- if (!metadata) return undefined;
- try {
- const parsed = DigiCertCertificateRequestMetadataSchema.safeParse(JSON.parse(metadata));
- return parsed.success && parsed.data.digicert.previousCertificateId !== undefined
- ? parsed.data.digicert.orderId
- : undefined;
- } catch {
- return undefined;
- }
+ digicertFns: Pick<TDigiCertCertificateAuthorityFns, "cancelPendingRequest">;
};
export type TCertificateRequestServiceFactory = ReturnType<typeof certificateRequestServiceFactory>;
@@ -762,9 +750,11 @@ export const certificateRequestServiceFactory = ({
);
}
- const reissueOrderId = getPendingDigiCertReissueOrderId(certificateRequest.metadata);
- if (previousStatus === CertificateRequestStatus.PENDING_VALIDATION && certificateRequest.caId && reissueOrderId) {
- await digicertFns.cancelReissue({ caId: certificateRequest.caId, orderId: reissueOrderId });
+ 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 {
diff --git a/backend/src/services/certificate/certificate-dal.ts b/backend/src/services/certificate/certificate-dal.ts
index 7192d28b7a..c1ba04a38f 100644
--- a/backend/src/services/certificate/certificate-dal.ts
+++ b/backend/src/services/certificate/certificate-dal.ts
@@ -132,26 +132,18 @@ export const certificateDALFactory = (db: TDbClient) => {
}
};
- const findActiveDigiCertCertsReplacedOnOrder = async (caId: string) => {
+ const findActiveDigiCertCertsByCaId = async (caId: string) => {
try {
const certs = await db
.replicaNode()(TableName.Certificate)
.where({ caId, status: CertStatus.ACTIVE })
.where("notAfter", ">", new Date())
.whereRaw(`"externalMetadata"->>'type' = ?`, ["digicert"])
- .whereExists((qb) => {
- void qb
- .select(db.raw("1"))
- .from({ newer: TableName.Certificate })
- .whereRaw(`newer."caId" = ${TableName.Certificate}."caId"`)
- .whereRaw(`newer."externalMetadata"->>'orderId' = ${TableName.Certificate}."externalMetadata"->>'orderId'`)
- .whereRaw(`newer."createdAt" > ${TableName.Certificate}."createdAt"`);
- })
.select("id", "commonName", "serialNumber", "projectId", "applicationId", "deletedAt", "externalMetadata");
return certs;
} catch (error) {
- throw new DatabaseError({ error, name: "Find active DigiCert certs replaced on their order" });
+ throw new DatabaseError({ error, name: "Find active DigiCert certificates by CA" });
}
};
@@ -1533,7 +1525,7 @@ export const certificateDALFactory = (db: TDbClient) => {
findLatestActiveCertForSubscriber,
findAllActiveCertsForSubscriber,
findActiveDigiCertCertsByOrderIds,
- findActiveDigiCertCertsReplacedOnOrder,
+ findActiveDigiCertCertsByCaId,
findExpiredSyncedCertificates,
findByThumbprintInOrg,
findActiveCertificatesByIds,
diff --git a/docs/documentation/platform/pki/applications/certificate-renewal.mdx b/docs/documentation/platform/pki/applications/certificate-renewal.mdx
index 746b603af6..de2e5b07e4 100644
--- a/docs/documentation/platform/pki/applications/certificate-renewal.mdx
+++ b/docs/documentation/platform/pki/applications/certificate-renewal.mdx
@@ -6,7 +6,7 @@ description: "Manually renew a certificate, and change its subject, names, valid
Certificates expire, and the details they carry go out of date. A manual renewal issues a replacement for a certificate you already have, and lets you correct it at the same time: add a name the service now answers to, extend the validity, or decide whether the replacement keeps the current key pair.
-This is the counterpart to automatic renewal, which reissues a certificate exactly as it is on a schedule. Reach for a manual renewal when something about the certificate needs to change, or when you want the replacement now rather than at the next renewal window.
+This is the counterpart to automatic renewal, which renews a certificate exactly as it is on a schedule. Reach for a manual renewal when something about the certificate needs to change, or when you want the replacement now rather than at the next renewal window.
<Note>
A certificate can be renewed when it was issued from a [certificate profile](/documentation/platform/pki/applications/enrollment-methods/api), is still active, and hasn't already been renewed. Certificates obtained through [ACME](/documentation/platform/pki/applications/enrollment-methods/acme), [EST](/documentation/platform/pki/applications/enrollment-methods/est), or [SCEP](/documentation/platform/pki/applications/enrollment-methods/scep) are renewed by the client that requested them, not from here.
@@ -93,6 +93,8 @@ A reissue requests the same validity as the current certificate, capped at 199 d
If you add a name that DigiCert hasn't validated yet, validate it in DigiCert CertCentral within 24 hours. Otherwise the reissue is canceled and the request fails.
+Automatic renewal always places a new order. To reissue on the existing order, renew the certificate manually.
+
<Warning>
If the reissue removes or changes a name, DigiCert revokes the previous certificate and any earlier copies on the order within 72 hours, so you also need permission to revoke the certificate.
</Warning>
@@ -194,7 +196,7 @@ Deploy the renewed certificate before the previous one expires. Renewing doesn't
If a manual renewal fails, Infisical shows the reason when you submit it and records a [`certificate-issuance-failed` audit log event](/documentation/platform/audit-logs#certificate-issuance-failures) that links to the certificate being renewed. If an automatic renewal fails, Infisical records an `automated-renew-certificate-failed` event instead, unless the renewal had already been sent to an external CA, in which case the failure is recorded as `certificate-issuance-failed`.
</Accordion>
<Accordion title="Can I renew several certificates at once?">
- Manual renewal handles one certificate at a time. To keep many certificates current without intervention, enable [automatic renewal](/documentation/platform/pki/applications/certificates) so Infisical reissues them before they expire.
+ Manual renewal handles one certificate at a time. To keep many certificates current without intervention, enable [automatic renewal](/documentation/platform/pki/applications/certificates) so they renew before they expire.
</Accordion>
</AccordionGroup>
diff --git a/frontend/src/pages/cert-manager/CertificateDetailsByIDPage/components/CertificateOverviewSection.tsx b/frontend/src/pages/cert-manager/CertificateDetailsByIDPage/components/CertificateOverviewSection.tsx
index bcdaa9f7c7..bd382f14db 100644
--- a/frontend/src/pages/cert-manager/CertificateDetailsByIDPage/components/CertificateOverviewSection.tsx
+++ b/frontend/src/pages/cert-manager/CertificateDetailsByIDPage/components/CertificateOverviewSection.tsx
@@ -52,13 +52,23 @@ const getProviderReference = (metadata?: TCertificateExternalMetadata | null) =>
case CaType.DIGICERT:
return {
provider: "DigiCert CertCentral",
- label: "Order ID",
- value: String(metadata.orderId)
+ references: [
+ { label: "Order ID", value: String(metadata.orderId) },
+ ...(metadata.certificateId !== undefined
+ ? [{ label: "DigiCert Certificate ID", value: String(metadata.certificateId) }]
+ : [])
+ ]
};
case CaType.GODADDY:
- return { provider: "GoDaddy", label: "Certificate ID", value: metadata.certificateId };
+ return {
+ provider: "GoDaddy",
+ references: [{ label: "Certificate ID", value: metadata.certificateId }]
+ };
case CaType.AWS_ACM_PUBLIC_CA:
- return { provider: "AWS ACM Public CA", label: "Certificate ARN", value: metadata.arn };
+ return {
+ provider: "AWS ACM Public CA",
+ references: [{ label: "Certificate ARN", value: metadata.arn }]
+ };
default:
return null;
}
@@ -267,10 +277,12 @@ export const CertificateOverviewSection = ({ certificateId }: Props) => {
<DetailLabel>Provider</DetailLabel>
<DetailValue>{providerReference.provider}</DetailValue>
</Detail>
- <Detail>
- <DetailLabel>{providerReference.label}</DetailLabel>
- <DetailValue className="font-mono">{providerReference.value}</DetailValue>
- </Detail>
+ {providerReference.references.map((reference) => (
+ <Detail key={reference.label}>
+ <DetailLabel>{reference.label}</DetailLabel>
+ <DetailValue className="font-mono">{reference.value}</DetailValue>
+ </Detail>
+ ))}
</>
)}
<Detail>
diff --git a/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateRenewalModal.tsx b/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateRenewalModal.tsx
index 3bf3daf32f..24ecb27c48 100644
--- a/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateRenewalModal.tsx
+++ b/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateRenewalModal.tsx
@@ -69,6 +69,7 @@ import {
buildRenewalRequestAttributes,
capTtlToDays,
getRemovedCertificateNames,
+ getRemovedCertificateNamesFromCsr,
unionUsageOptions
} from "./certificateRenewalUtils";
import { isExternalTemplateCa, rowErrorsOf } from "./certificateUtils";
@@ -382,6 +383,17 @@ const SUBJECT_ISSUER_FIELDS = new Set([
"altNames"
]);
+const NameRemovalWarning = ({ names }: { names: string[] }) => (
+ <Alert variant="warning">
+ <TriangleAlertIcon />
+ <AlertTitle>DigiCert will revoke the current certificate</AlertTitle>
+ <AlertDescription>
+ This reissue removes {names.join(", ")}. Once the new certificate is issued, DigiCert revokes
+ the current certificate and any earlier reissues and duplicates on this order within 72 hours.
+ </AlertDescription>
+ </Alert>
+);
+
export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpToggle }: Props) => {
const { currentProject } = useProject();
const { currentOrg } = useOrganization();
@@ -474,17 +486,21 @@ export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpTog
CaCapability.REISSUE_CERTIFICATES
);
const isReissuing = isReissueAvailable && watch("reissue");
- const removedNames =
- isReissuing && certificate && keySource !== CertificateRenewalKeySource.Csr
- ? getRemovedCertificateNames({
- certificate,
- formData: {
- subjectAttributes: watch("subjectAttributes"),
- subjectAltNames: watch("subjectAltNames")
- },
- constraints
- })
- : [];
+ const getReissueRemovedNames = () => {
+ if (!isReissuing || !certificate) return [];
+ if (keySource === CertificateRenewalKeySource.Csr) {
+ return getRemovedCertificateNamesFromCsr({ certificate, csr: watch("csr") });
+ }
+ return getRemovedCertificateNames({
+ certificate,
+ formData: {
+ subjectAttributes: watch("subjectAttributes"),
+ subjectAltNames: watch("subjectAltNames")
+ },
+ constraints
+ });
+ };
+ const removedNames = getReissueRemovedNames();
const nameRemovalError =
removedNames.length && !canRevoke
? "Removing or changing a name on a reissue revokes the current certificate, and you don't have permission to revoke it."
@@ -642,7 +658,7 @@ export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpTog
validateStep: async (fields) => {
// Leaving a step reveals the findings on its own fields; entering it must stay quiet.
policy.reveal(fields);
- if (nameRemovalError && fields.includes("subjectAltNames")) return false;
+ if (nameRemovalError && (fields.includes("subjectAltNames") || fields.includes("csr"))) return false;
if (!(await trigger(fields as (keyof RenewalFormData)[]))) return false;
return policy.findBlockedFields(fields).length === 0;
}
@@ -807,7 +823,8 @@ export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpTog
}
if (nameRemovalError) {
- setStep(stepKeys.indexOf("subject"));
+ const namesStep = stepKeys.indexOf(keySource === CertificateRenewalKeySource.Csr ? "csr" : "subject");
+ if (namesStep >= 0) setStep(namesStep);
createNotification({ text: nameRemovalError, type: "error" });
return;
}
@@ -937,7 +954,7 @@ export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpTog
{...field}
value={value ?? ""}
spellCheck={false}
- isError={Boolean(error)}
+ isError={Boolean(error || nameRemovalError)}
placeholder="-----BEGIN CERTIFICATE REQUEST-----"
rows={12}
className="w-full font-mono text-xs"
@@ -945,10 +962,11 @@ export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpTog
<FieldDescription>
The subject, key, and extensions are taken from this CSR.
</FieldDescription>
- <FieldError errors={[error]} />
+ <FieldError errors={[error ?? (nameRemovalError ? { message: nameRemovalError } : undefined)]} />
</Field>
)}
/>
+ {removedNames.length > 0 && !nameRemovalError && <NameRemovalWarning names={removedNames} />}
<ValidityField
control={control}
label="Validity (TTL)"
@@ -997,17 +1015,7 @@ export const CertificateRenewalModal = ({ popUp, applicationName, handlePopUpTog
revealPolicyErrors={policy.isRevealed("subjectAltNames")}
/>
)}
- {removedNames.length > 0 && !nameRemovalError && (
- <Alert variant="warning">
- <TriangleAlertIcon />
- <AlertTitle>DigiCert will revoke the current certificate</AlertTitle>
- <AlertDescription>
- This reissue removes {removedNames.join(", ")}. Once the new certificate is issued,
- DigiCert revokes the current certificate and any earlier reissues and duplicates on
- this order within 72 hours.
- </AlertDescription>
- </Alert>
- )}
+ {removedNames.length > 0 && !nameRemovalError && <NameRemovalWarning names={removedNames} />}
<IssuerModifiedNotice fields={subjectIssuerChanges} />
</div>
)}
diff --git a/frontend/src/pages/cert-manager/CertificatesPage/components/certificateRenewalUtils.ts b/frontend/src/pages/cert-manager/CertificatesPage/components/certificateRenewalUtils.ts
index 1699596662..c16bd51dbc 100644
--- a/frontend/src/pages/cert-manager/CertificatesPage/components/certificateRenewalUtils.ts
+++ b/frontend/src/pages/cert-manager/CertificatesPage/components/certificateRenewalUtils.ts
@@ -1,3 +1,5 @@
+import * as x509 from "@peculiar/x509";
+
import {
certKeyAlgorithms,
SIGNATURE_ALGORITHMS_OPTIONS
@@ -306,3 +308,51 @@ export const capTtlToDays = (ttl: string, maxDays: number) => {
const days = /^(\d+)d$/.exec(ttl)?.[1];
return days && Number(days) > maxDays ? `${maxDays}d` : ttl;
};
+
+const CSR_SAN_TYPES: Record<string, CertSubjectAlternativeNameType> = {
+ dns: CertSubjectAlternativeNameType.DNS_NAME,
+ ip: CertSubjectAlternativeNameType.IP_ADDRESS,
+ email: CertSubjectAlternativeNameType.EMAIL,
+ url: CertSubjectAlternativeNameType.URI,
+ upn: CertSubjectAlternativeNameType.UPN
+};
+
+const parseCsrNames = (csrPem: string) => {
+ try {
+ const csr = new x509.Pkcs10CertificateRequest(csrPem.trim());
+ const sanExtension = csr.extensions.find(
+ (extension): extension is x509.SubjectAlternativeNameExtension =>
+ extension instanceof x509.SubjectAlternativeNameExtension
+ );
+ return {
+ commonName: csr.subjectName.getField("CN")[0],
+ altNames: (sanExtension?.names.items ?? []).flatMap((name) =>
+ CSR_SAN_TYPES[name.type] ? [{ type: CSR_SAN_TYPES[name.type], value: name.value }] : []
+ )
+ };
+ } catch {
+ return null;
+ }
+};
+
+export const getRemovedCertificateNamesFromCsr = ({
+ certificate,
+ csr
+}: {
+ certificate: Pick<TCertificate, "commonName" | "altNames">;
+ csr?: string;
+}): string[] => {
+ const csrNames = csr?.trim() ? parseCsrNames(csr) : null;
+ if (!csrNames) return [];
+
+ return getRemovedCertificateNames({
+ certificate,
+ formData: {
+ subjectAttributes: csrNames.commonName
+ ? [{ type: CertSubjectAttributeType.COMMON_NAME, value: csrNames.commonName }]
+ : [],
+ subjectAltNames: csrNames.altNames
+ },
+ constraints: { shouldShowSubjectSection: true, shouldShowSanSection: true }
+ });
+};