Skip to content

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

improvement(pki): pkcs12 password policy

bernie-g3493c85ce93d
diff --git a/backend/src/lib/api-docs/constants.ts b/backend/src/lib/api-docs/constants.ts
index d8f014b536..690a51981c 100644
--- a/backend/src/lib/api-docs/constants.ts
+++ b/backend/src/lib/api-docs/constants.ts
@@ -2343,6 +2343,13 @@ export const CERTIFICATES = {
serialNumberRes: "The serial number of the certificate.",
privateKey: "The private key of the certificate."
},
+ EXPORT_PKCS12: {
+ password:
+ "Password to protect the PKCS#12 keystore with. Must be 14 to 100 characters and contain a letter, a number and a special character.",
+ alias: "Friendly name for the certificate inside the keystore.",
+ keystore:
+ "The PKCS#12 keystore (.p12) as binary data, containing the certificate, its chain and its private key, encrypted with the given password."
+ },
IMPORT: {
projectSlug: "Slug of the project to import the certificate into.",
certificatePem: "The PEM-encoded leaf certificate.",
diff --git a/backend/src/lib/validator/password-policy.test.ts b/backend/src/lib/validator/password-policy.test.ts
index b207fbf5b0..3c6a7a78bb 100644
--- a/backend/src/lib/validator/password-policy.test.ts
+++ b/backend/src/lib/validator/password-policy.test.ts
@@ -4,7 +4,9 @@ import {
doesPasswordMeetRequirement,
PASSWORD_POLICY,
PasswordPolicyConfigSchema,
- PasswordPolicySchema
+ PasswordPolicySchema,
+ PKCS12_PASSWORD_POLICY,
+ Pkcs12PasswordSchema
} from "./password-policy";
describe("PasswordPolicySchema", () => {
@@ -88,3 +90,34 @@ describe("PasswordPolicySchema", () => {
expect(PasswordPolicyConfigSchema.parse(serializedPolicy)).toEqual(PASSWORD_POLICY);
});
});
+
+describe("Pkcs12PasswordSchema", () => {
+ test.each(["Horse-Battery-7", "Keystore#Pass9x", "密码安全密码安全密码安全-7"])(
+ "accepts a strong password: %s",
+ (password) => {
+ expect(Pkcs12PasswordSchema.safeParse(password).success).toBe(true);
+ }
+ );
+
+ test.each([
+ ["too short", "Short-7"],
+ ["no number", "Horse-Battery-Staple"],
+ ["no special character", "HorseBattery7Staple"],
+ ["no letter", "1234567890123!"],
+ ["whitespace is not a special character", "Horse Battery 7"],
+ ["repeated characters", "Horse-Batttttery-7"]
+ ])("rejects a password with %s", (_, password) => {
+ expect(Pkcs12PasswordSchema.safeParse(password).success).toBe(false);
+ });
+
+ test("is stricter than the user password policy", () => {
+ expect(PasswordPolicySchema.safeParse("HorseBattery7Staple").success).toBe(true);
+ expect(Pkcs12PasswordSchema.safeParse("HorseBattery7Staple").success).toBe(false);
+ });
+
+ test("exports a serializable policy contract", () => {
+ const serializedPolicy: unknown = JSON.parse(JSON.stringify(PKCS12_PASSWORD_POLICY));
+
+ expect(PasswordPolicyConfigSchema.parse(serializedPolicy)).toEqual(PKCS12_PASSWORD_POLICY);
+ });
+});
diff --git a/backend/src/lib/validator/password-policy.ts b/backend/src/lib/validator/password-policy.ts
index 5eaa8ea287..ef861b67fa 100644
--- a/backend/src/lib/validator/password-policy.ts
+++ b/backend/src/lib/validator/password-policy.ts
@@ -19,61 +19,101 @@ export const PasswordPolicyConfigSchema = z.object({
export type TPasswordPolicyRequirement = z.infer<typeof PasswordPolicyRequirementSchema>;
export type TPasswordPolicyConfig = z.infer<typeof PasswordPolicyConfigSchema>;
+const MINIMUM_LENGTH_REQUIREMENT = {
+ code: "minimumLength",
+ patterns: [String.raw`^[\s\S]{14,}$`],
+ flags: "u",
+ shouldMatch: true,
+ message: "At least 14 characters",
+ validationMessage: "Password must contain at least 14 characters",
+ isPrimary: true
+} as const satisfies TPasswordPolicyRequirement;
+
+const MAXIMUM_LENGTH_REQUIREMENT = {
+ code: "maximumLength",
+ patterns: [String.raw`^[\s\S]{0,100}$`],
+ flags: "u",
+ shouldMatch: true,
+ message: "At most 100 characters",
+ validationMessage: "Password must contain at most 100 characters",
+ isPrimary: false
+} as const satisfies TPasswordPolicyRequirement;
+
+const LETTER_REQUIREMENT = {
+ code: "letter",
+ patterns: [String.raw`\p{L}`],
+ flags: "u",
+ shouldMatch: true,
+ message: "At least 1 letter",
+ validationMessage: "Password must contain at least 1 letter",
+ isPrimary: true
+} as const satisfies TPasswordPolicyRequirement;
+
+const NUMBER_OR_SPECIAL_REQUIREMENT = {
+ code: "numberOrSpecial",
+ patterns: [String.raw`[\d!@#$%^&*(),.?":{}|<>]|[^\p{L}\p{N}\s]`],
+ flags: "u",
+ shouldMatch: true,
+ message: "At least 1 number or special character",
+ validationMessage: "Password must contain at least 1 number or special character",
+ isPrimary: true
+} as const satisfies TPasswordPolicyRequirement;
+
+const REPEATED_CHARACTERS_REQUIREMENT = {
+ code: "repeatedCharacters",
+ patterns: [String.raw`\s{4,}`],
+ maxConsecutiveCharacters: 3,
+ shouldMatch: false,
+ message: "No more than 3 repeated consecutive characters",
+ validationMessage: "Password cannot contain more than 3 repeated consecutive characters",
+ isPrimary: false
+} as const satisfies TPasswordPolicyRequirement;
+
+const ESCAPE_CHARACTERS_REQUIREMENT = {
+ code: "escapeCharacters",
+ patterns: [String.raw`[\n\t\r\\]`],
+ shouldMatch: false,
+ message: "No escape characters",
+ validationMessage: "Password cannot contain escape characters",
+ isPrimary: false
+} as const satisfies TPasswordPolicyRequirement;
+
export const PASSWORD_POLICY = {
requirements: [
+ MINIMUM_LENGTH_REQUIREMENT,
+ MAXIMUM_LENGTH_REQUIREMENT,
+ LETTER_REQUIREMENT,
+ NUMBER_OR_SPECIAL_REQUIREMENT,
+ REPEATED_CHARACTERS_REQUIREMENT,
+ ESCAPE_CHARACTERS_REQUIREMENT
+ ]
+} as const satisfies TPasswordPolicyConfig;
+
+export const PKCS12_PASSWORD_POLICY = {
+ requirements: [
+ MINIMUM_LENGTH_REQUIREMENT,
+ MAXIMUM_LENGTH_REQUIREMENT,
+ LETTER_REQUIREMENT,
{
- code: "minimumLength",
- patterns: [String.raw`^[\s\S]{14,}$`],
- flags: "u",
- shouldMatch: true,
- message: "At least 14 characters",
- validationMessage: "Password must contain at least 14 characters",
- isPrimary: true
- },
- {
- code: "maximumLength",
- patterns: [String.raw`^[\s\S]{0,100}$`],
- flags: "u",
- shouldMatch: true,
- message: "At most 100 characters",
- validationMessage: "Password must contain at most 100 characters",
- isPrimary: false
- },
- {
- code: "letter",
- patterns: [String.raw`\p{L}`],
+ code: "number",
+ patterns: [String.raw`\p{N}`],
flags: "u",
shouldMatch: true,
- message: "At least 1 letter",
- validationMessage: "Password must contain at least 1 letter",
+ message: "At least 1 number",
+ validationMessage: "Password must contain at least 1 number",
isPrimary: true
},
{
- code: "numberOrSpecial",
- patterns: [String.raw`[\d!@#$%^&*(),.?":{}|<>]|[^\p{L}\p{N}\s]`],
+ code: "special",
+ patterns: [String.raw`[^\p{L}\p{N}\s]`],
flags: "u",
shouldMatch: true,
- message: "At least 1 number or special character",
- validationMessage: "Password must contain at least 1 number or special character",
+ message: "At least 1 special character",
+ validationMessage: "Password must contain at least 1 special character",
isPrimary: true
},
- {
- code: "repeatedCharacters",
- patterns: [String.raw`\s{4,}`],
- maxConsecutiveCharacters: 3,
- shouldMatch: false,
- message: "No more than 3 repeated consecutive characters",
- validationMessage: "Password cannot contain more than 3 repeated consecutive characters",
- isPrimary: false
- },
- {
- code: "escapeCharacters",
- patterns: [String.raw`[\n\t\r\\]`],
- shouldMatch: false,
- message: "No escape characters",
- validationMessage: "Password cannot contain escape characters",
- isPrimary: false
- }
+ REPEATED_CHARACTERS_REQUIREMENT,
+ ESCAPE_CHARACTERS_REQUIREMENT
]
} as const satisfies TPasswordPolicyConfig;
@@ -102,13 +142,18 @@ export const doesPasswordMeetRequirement = (password: string, requirement: TPass
return matches === requirement.shouldMatch;
};
-export const PasswordPolicySchema = z.string().superRefine((password, context) => {
- PASSWORD_POLICY.requirements.forEach((requirement) => {
- if (!doesPasswordMeetRequirement(password, requirement)) {
- context.addIssue({
- code: z.ZodIssueCode.custom,
- message: requirement.validationMessage
- });
- }
+export const createPasswordPolicySchema = (policy: TPasswordPolicyConfig) =>
+ z.string().superRefine((password, context) => {
+ policy.requirements.forEach((requirement) => {
+ if (!doesPasswordMeetRequirement(password, requirement)) {
+ context.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: requirement.validationMessage
+ });
+ }
+ });
});
-});
+
+export const PasswordPolicySchema = createPasswordPolicySchema(PASSWORD_POLICY);
+
+export const Pkcs12PasswordSchema = createPasswordPolicySchema(PKCS12_PASSWORD_POLICY);
diff --git a/backend/src/server/routes/v1/admin-router.ts b/backend/src/server/routes/v1/admin-router.ts
index dcdc5ef77b..2f6e13115d 100644
--- a/backend/src/server/routes/v1/admin-router.ts
+++ b/backend/src/server/routes/v1/admin-router.ts
@@ -15,7 +15,12 @@ import { getConfig, overridableKeys } from "@app/lib/config/env";
import { crypto } from "@app/lib/crypto/cryptography";
import { BadRequestError } from "@app/lib/errors";
import { AllowedEmailDomainsSchema } from "@app/lib/validator";
-import { PASSWORD_POLICY, PasswordPolicyConfigSchema, PasswordPolicySchema } from "@app/lib/validator/password-policy";
+import {
+ PASSWORD_POLICY,
+ PasswordPolicyConfigSchema,
+ PasswordPolicySchema,
+ PKCS12_PASSWORD_POLICY
+} from "@app/lib/validator/password-policy";
import { invalidateCacheLimit, readLimit, writeLimit } from "@app/server/config/rateLimiter";
import { addAuthOriginDomainCookie } from "@app/server/lib/cookie";
import { GenericResourceNameSchema } from "@app/server/lib/schemas";
@@ -63,7 +68,8 @@ const SanitizedSuperAdminSchema = z.object({
defaultAuthOrgSlug: z.string().nullable(),
defaultAuthOrgAuthEnforced: z.boolean().nullish(),
defaultAuthOrgAuthMethod: z.string().nullish(),
- passwordPolicy: PasswordPolicyConfigSchema
+ passwordPolicy: PasswordPolicyConfigSchema,
+ pkcs12PasswordPolicy: PasswordPolicyConfigSchema
});
export const registerAdminRouter = async (server: FastifyZodProvider) => {
@@ -110,6 +116,7 @@ export const registerAdminRouter = async (server: FastifyZodProvider) => {
defaultAuthOrgAuthMethod: config.defaultAuthOrgAuthMethod,
enabledLoginMethods: config.enabledLoginMethods,
passwordPolicy: PASSWORD_POLICY,
+ pkcs12PasswordPolicy: PKCS12_PASSWORD_POLICY,
authConsentContent: config.authConsentContent,
pageFrameContent: config.pageFrameContent,
isPublicSecretSharingDisabled: serverEnvs.DISABLE_PUBLIC_SECRET_SHARING,
@@ -123,6 +130,7 @@ export const registerAdminRouter = async (server: FastifyZodProvider) => {
config: {
...config,
passwordPolicy: PASSWORD_POLICY,
+ pkcs12PasswordPolicy: PKCS12_PASSWORD_POLICY,
fipsEnabled: crypto.isFipsModeEnabled(),
isMigrationModeOn: serverEnvs.MAINTENANCE_MODE,
isSecretScanningDisabled: serverEnvs.DISABLE_SECRET_SCANNING,
@@ -199,7 +207,13 @@ export const registerAdminRouter = async (server: FastifyZodProvider) => {
},
handler: async (req) => {
const config = await server.services.superAdmin.updateServerCfg(req.body, req.permission.id);
- return { config: { ...config, passwordPolicy: PASSWORD_POLICY } };
+ return {
+ config: {
+ ...config,
+ passwordPolicy: PASSWORD_POLICY,
+ pkcs12PasswordPolicy: PKCS12_PASSWORD_POLICY
+ }
+ };
}
});
diff --git a/backend/src/server/routes/v1/certificate-router.ts b/backend/src/server/routes/v1/certificate-router.ts
index 7841c667ec..a92c0a09a1 100644
--- a/backend/src/server/routes/v1/certificate-router.ts
+++ b/backend/src/server/routes/v1/certificate-router.ts
@@ -8,6 +8,7 @@ import { ApiDocsTags, CERTIFICATES } from "@app/lib/api-docs";
import { BadRequestError } from "@app/lib/errors";
import { ms } from "@app/lib/ms";
import { isUuidV4 } from "@app/lib/validator";
+import { Pkcs12PasswordSchema } from "@app/lib/validator/password-policy";
import { readLimit, writeLimit } from "@app/server/config/rateLimiter";
import { addNoCacheHeaders } from "@app/server/lib/caching";
import { openApiHidden } from "@app/server/lib/schemas";
@@ -2072,24 +2073,26 @@ export const registerCertificateRouter = async (server: FastifyZodProvider) => {
config: {
rateLimit: writeLimit
},
- onRequest: verifyAuth([AuthMode.JWT]),
+ onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN, AuthMode.OAUTH]),
schema: {
- hide: true,
+ hide: false,
operationId: "exportCertificatePkcs12",
tags: [ApiDocsTags.PkiCertificates],
description: "Download certificate in PKCS12 format",
+ produces: ["application/octet-stream"],
params: z.object({
id: z.string().trim().uuid().describe(CERTIFICATES.GET.id)
}),
body: z.object({
- password: z
- .string()
- .min(6, "Password must be at least 6 characters long")
- .describe("Password for the keystore (minimum 6 characters)"),
- alias: z.string().min(1, "Alias is required").describe("Alias for the certificate in the keystore")
+ password: Pkcs12PasswordSchema.describe(CERTIFICATES.EXPORT_PKCS12.password),
+ alias: z.string().trim().min(1, "Alias is required").max(255).describe(CERTIFICATES.EXPORT_PKCS12.alias)
}),
response: {
- 200: z.any().describe("PKCS12 keystore as binary data")
+ 200: z
+ .any()
+ .describe(
+ JSON.stringify({ type: "string", format: "binary", description: CERTIFICATES.EXPORT_PKCS12.keystore })
+ )
}
},
handler: async (req, reply) => {
diff --git a/backend/src/server/routes/v1/deprecated-certificate-router.ts b/backend/src/server/routes/v1/deprecated-certificate-router.ts
index 20d843a1d8..3c66035410 100644
--- a/backend/src/server/routes/v1/deprecated-certificate-router.ts
+++ b/backend/src/server/routes/v1/deprecated-certificate-router.ts
@@ -6,6 +6,7 @@ import { EventType } from "@app/ee/services/audit-log/audit-log-types";
import { CertificateSource } from "@app/ee/services/pki-discovery/pki-discovery-types";
import { ApiDocsTags, CERTIFICATE_AUTHORITIES, CERTIFICATES } from "@app/lib/api-docs";
import { ms } from "@app/lib/ms";
+import { Pkcs12PasswordSchema } from "@app/lib/validator/password-policy";
import { readLimit, writeLimit } from "@app/server/config/rateLimiter";
import { addNoCacheHeaders } from "@app/server/lib/caching";
import { getTelemetryDistinctId } from "@app/server/lib/telemetry";
@@ -655,10 +656,7 @@ export const registerDeprecatedCertRouter = async (server: FastifyZodProvider) =
serialNumber: z.string().trim().describe(CERTIFICATES.GET.serialNumber)
}),
body: z.object({
- password: z
- .string()
- .min(6, "Password must be at least 6 characters long")
- .describe("Password for the keystore (minimum 6 characters)"),
+ password: Pkcs12PasswordSchema.describe(CERTIFICATES.EXPORT_PKCS12.password),
alias: z.string().min(1, "Alias is required").describe("Alias for the certificate in the keystore")
}),
response: {
diff --git a/backend/src/services/certificate/certificate-service.ts b/backend/src/services/certificate/certificate-service.ts
index 6a619d4ce2..9ff346b2fa 100644
--- a/backend/src/services/certificate/certificate-service.ts
+++ b/backend/src/services/certificate/certificate-service.ts
@@ -21,6 +21,7 @@ import { TKeyStoreFactory } from "@app/keystore/keystore";
import { crypto } from "@app/lib/crypto/cryptography";
import { BadRequestError, DatabaseError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
import { logger } from "@app/lib/logger";
+import { Pkcs12PasswordSchema } from "@app/lib/validator/password-policy";
import {
CertificateApplicationAlertEvent,
TCertificateAlertEventEmitter
@@ -1631,13 +1632,10 @@ export const certificateServiceFactory = ({
actor,
actorOrgId
}: TGetCertPkcs12DTO) => {
- if (!password || password.trim() === "") {
- throw new BadRequestError({ message: "Password is required for PKCS12 keystore generation" });
- }
-
- if (password.length < 6) {
+ const passwordCheck = Pkcs12PasswordSchema.safeParse(password);
+ if (!passwordCheck.success) {
throw new BadRequestError({
- message: "Password must be at least 6 characters long for PKCS12 keystore security"
+ message: `Invalid keystore password: ${passwordCheck.error.issues.map((issue) => issue.message).join(", ")}`
});
}
diff --git a/docs/api-reference/endpoints/certificates/pkcs12.mdx b/docs/api-reference/endpoints/certificates/pkcs12.mdx
new file mode 100644
index 0000000000..c7ace2840d
--- /dev/null
+++ b/docs/api-reference/endpoints/certificates/pkcs12.mdx
@@ -0,0 +1,8 @@
+---
+title: "Export certificate as PKCS12"
+openapi: "POST /api/v1/cert-manager/certificates/{id}/pkcs12"
+---
+
+<Note>
+ You must have the certificate `read-private-key` permission in order to call this endpoint.
+</Note>
diff --git a/docs/docs.json b/docs/docs.json
index 5e9034ea94..fc3aac0e68 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -3986,6 +3986,7 @@
"api-reference/endpoints/certificates/delete",
"api-reference/endpoints/certificates/cert-body",
"api-reference/endpoints/certificates/bundle",
+ "api-reference/endpoints/certificates/pkcs12",
"api-reference/endpoints/certificates/private-key",
"api-reference/endpoints/certificates/import-certificate"
]
diff --git a/frontend/src/components/auth/PasswordField.tsx b/frontend/src/components/auth/PasswordField.tsx
index 0f86847102..c5469b53fc 100644
--- a/frontend/src/components/auth/PasswordField.tsx
+++ b/frontend/src/components/auth/PasswordField.tsx
@@ -29,6 +29,7 @@ type PasswordFieldProps = {
error?: ReactHookFormFieldError;
submitCount: number;
variant?: InputGroupProps["variant"];
+ isRequired?: boolean;
};
export const PasswordField = ({
@@ -41,7 +42,8 @@ export const PasswordField = ({
placeholder,
error,
submitCount,
- variant = "default"
+ variant = "default",
+ isRequired = false
}: PasswordFieldProps) => {
const [isFocused, setIsFocused] = useState(false);
const [showPassword, setShowPassword] = useState(false);
@@ -53,7 +55,14 @@ export const PasswordField = ({
return (
<Field data-invalid={Boolean(error)}>
- <FieldLabel htmlFor={id}>{label}</FieldLabel>
+ <FieldLabel htmlFor={id}>
+ {label}
+ {isRequired && (
+ <span aria-hidden className="text-danger">
+ *
+ </span>
+ )}
+ </FieldLabel>
<InputGroup variant={variant}>
<InputGroupInput
{...registration}
@@ -62,6 +71,7 @@ export const PasswordField = ({
placeholder={placeholder}
autoComplete="new-password"
aria-invalid={Boolean(error)}
+ aria-required={isRequired || undefined}
aria-describedby={showRequirements ? requirementsId : undefined}
onFocus={() => setIsFocused(true)}
onBlur={(event) => {
diff --git a/frontend/src/hooks/api/admin/types.ts b/frontend/src/hooks/api/admin/types.ts
index 11797a9517..fed7232e28 100644
--- a/frontend/src/hooks/api/admin/types.ts
+++ b/frontend/src/hooks/api/admin/types.ts
@@ -80,6 +80,7 @@ export type TServerConfig = {
defaultAuthOrgAuthEnforced?: boolean | null;
enabledLoginMethods: LoginMethod[] | null;
passwordPolicy: TPasswordPolicy;
+ pkcs12PasswordPolicy: TPasswordPolicy;
authConsentContent?: string;
pageFrameContent?: string;
invalidatingCache: boolean;
diff --git a/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateExportModal.tsx b/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateExportModal.tsx
index a144b31a7e..2159a620af 100644
--- a/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateExportModal.tsx
+++ b/frontend/src/pages/cert-manager/CertificatesPage/components/CertificateExportModal.tsx
@@ -1,9 +1,11 @@
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
import { Controller, useForm } from "react-hook-form";
import { zodResolver } from "@hookform/resolvers/zod";
import { DownloadIcon } from "lucide-react";
import { z } from "zod";
+import { PasswordField } from "@app/components/auth/PasswordField";
+import { createPasswordSchema } from "@app/components/utilities/checks/password/passwordPolicy";
import {
Button,
Dialog,
@@ -24,6 +26,8 @@ import {
SelectTrigger,
SelectValue
} from "@app/components/v3";
+import { useServerConfig } from "@app/context";
+import { TPasswordPolicy } from "@app/hooks/api/admin/types";
import { UsePopUpState } from "@app/hooks/usePopUp";
type Props = {
@@ -54,62 +58,38 @@ export type ExportOptions = {
};
};
-const exportFormSchema = z
- .object({
- format: z.enum(["pem", "pkcs12"]),
- pkcs12Password: z.string().optional(),
- pkcs12Alias: z.string().optional()
- })
- .refine(
- (data) => {
- if (data.format === "pkcs12") {
- return data.pkcs12Password && data.pkcs12Alias && data.pkcs12Alias.trim() !== "";
- }
- return true;
- },
- {
- message: "PKCS12 password and alias are required when using PKCS12 format",
- path: ["pkcs12Password"]
- }
- )
- .refine(
- (data) => {
- if (data.format === "pkcs12") {
- return data.pkcs12Password && data.pkcs12Password.length >= 6;
- }
- return true;
- },
- {
- message: "PKCS12 password must be 6 characters or longer",
- path: ["pkcs12Password"]
- }
- )
- .refine(
- (data) => {
- if (data.format === "pkcs12" && data.pkcs12Password) {
- return data.pkcs12Password.length >= 6;
+const createExportFormSchema = (pkcs12PasswordPolicy: TPasswordPolicy) => {
+ const pkcs12PasswordSchema = createPasswordSchema(pkcs12PasswordPolicy);
+
+ return z
+ .object({
+ format: z.enum(["pem", "pkcs12"]),
+ pkcs12Password: z.string().optional(),
+ pkcs12Alias: z.string().optional()
+ })
+ .superRefine((data, context) => {
+ if (data.format !== "pkcs12") return;
+
+ const passwordCheck = pkcs12PasswordSchema.safeParse(data.pkcs12Password ?? "");
+ if (!passwordCheck.success) {
+ context.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: passwordCheck.error.issues[0]?.message ?? "Invalid keystore password",
+ path: ["pkcs12Password"]
+ });
}
- return true;
- },
- {
- message: "Password must be at least 6 characters long",
- path: ["pkcs12Password"]
- }
- )
- .refine(
- (data) => {
- if (data.format === "pkcs12") {
- return data.pkcs12Alias && data.pkcs12Alias.trim() !== "";
+
+ if (!data.pkcs12Alias?.trim()) {
+ context.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: "Certificate alias is required",
+ path: ["pkcs12Alias"]
+ });
}
- return true;
- },
- {
- message: "Certificate alias is required",
- path: ["pkcs12Alias"]
- }
- );
+ });
+};
-type ExportFormData = z.infer<typeof exportFormSchema>;
+type ExportFormData = z.infer<ReturnType<typeof createExportFormSchema>>;
export const CertificateExportModal = ({ popUp, handlePopUpToggle, onFormatSelected }: Props) => {
const { certificateId, serialNumber } =
@@ -118,12 +98,19 @@ export const CertificateExportModal = ({ popUp, handlePopUpToggle, onFormatSelec
serialNumber: string;
}) || {};
+ const { config } = useServerConfig();
+ const exportFormSchema = useMemo(
+ () => createExportFormSchema(config.pkcs12PasswordPolicy),
+ [config.pkcs12PasswordPolicy]
+ );
+
const {
control,
+ register,
handleSubmit,
reset,
watch,
- formState: { isSubmitting }
+ formState: { isSubmitting, errors, submitCount }
} = useForm<ExportFormData>({
resolver: zodResolver(exportFormSchema),
defaultValues: {
@@ -134,6 +121,7 @@ export const CertificateExportModal = ({ popUp, handlePopUpToggle, onFormatSelec
});
const selectedFormat = watch("format");
+ const pkcs12Password = watch("pkcs12Password") ?? "";
// Reset form whenever the modal opens
useEffect(() => {
@@ -213,34 +201,18 @@ export const CertificateExportModal = ({ popUp, handlePopUpToggle, onFormatSelec
{selectedFormat === "pkcs12" && (
<>
- <Controller
- control={control}
- name="pkcs12Password"
- render={({ field, fieldState: { error } }) => (
- <Field data-invalid={Boolean(error)}>
- <FieldLabel htmlFor="certificate-export-pkcs12-password">
- Keystore Password
- <span aria-hidden className="text-danger">
- *
- </span>
- </FieldLabel>
- <Input
- {...field}
- id="certificate-export-pkcs12-password"
- type="password"
- placeholder="Enter keystore password"
- autoComplete="new-password"
- aria-required
- isError={Boolean(error)}
- />
- <FieldDescription>
- Password to protect the PKCS12 keystore (minimum 6 characters)
- </FieldDescription>
- <FieldError>{error?.message}</FieldError>
- </Field>
- )}
+ <PasswordField
+ id="certificate-export-pkcs12-password"
+ label="Keystore Password"
+ placeholder="Enter keystore password"
+ value={pkcs12Password}
+ policy={config.pkcs12PasswordPolicy}
+ breachStatus="idle"
+ registration={register("pkcs12Password")}
+ error={errors.pkcs12Password}
+ submitCount={submitCount}
+ isRequired
/>
-
<Controller
control={control}
name="pkcs12Alias"