Skip to content

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

feat(kafka): update username template handling to ensure unique user generation

Dimitris Staratzisf1cdce7accdf
diff --git a/backend/src/ee/services/dynamic-secret/providers/kafka.test.ts b/backend/src/ee/services/dynamic-secret/providers/kafka.test.ts
index f08e0651bf..d6066f978a 100644
--- a/backend/src/ee/services/dynamic-secret/providers/kafka.test.ts
+++ b/backend/src/ee/services/dynamic-secret/providers/kafka.test.ts
@@ -323,31 +323,21 @@ describe("KafkaProvider.create", () => {
]);
});
- test.each(["{{identity.name}}", "lease-user"])(
- "refuses the username template %s, which has no random part",
- async (usernameTemplate) => {
- await expect(KafkaProvider().create(createArgs(baseInputs, usernameTemplate))).rejects.toThrow(
- "username template has no random part"
- );
- expect(FakeConnection.instances).toHaveLength(0);
- }
- );
+ test("adds a random suffix to the username the template generates", async () => {
+ const first = await KafkaProvider().create(createArgs(baseInputs, "{{identity.name}}"));
+ const second = await KafkaProvider().create(createArgs(baseInputs, "{{identity.name}}"));
- test.each(["{{randomUsername}}", "{{identity.name}}-{{random 8}}", "{{truncate randomUsername 12}}"])(
- "accepts the username template %s",
- async (usernameTemplate) => {
- await expect(KafkaProvider().create(createArgs(baseInputs, usernameTemplate))).resolves.toBeDefined();
- }
- );
+ expect(first.entityId).toMatch(/^tester-[0-9A-Za-z]{8}$/);
+ expect(second.entityId).not.toBe(first.entityId);
+ });
test.each([
- ["has SCRAM credentials", () => describeScramCredentials.mockResolvedValue({ results: [] } as never), undefined],
- ["has ACLs", () => describeAcls.mockResolvedValue({ resources: [{}] } as never), undefined],
- ["is the admin user", () => undefined, "admin{{random 0}}"]
- ])("refuses a username that %s without changing it", async (_case, setUp, usernameTemplate) => {
+ ["has SCRAM credentials", () => describeScramCredentials.mockResolvedValue({ results: [] } as never)],
+ ["has ACLs", () => describeAcls.mockResolvedValue({ resources: [{}] } as never)]
+ ])("refuses a username that already %s without changing it", async (_case, setUp) => {
setUp();
- await expect(KafkaProvider().create(createArgs(baseInputs, usernameTemplate))).rejects.toThrow(
+ await expect(KafkaProvider().create(createArgs())).rejects.toThrow(
"A Kafka user with the generated username already exists"
);
expect(alterScramCredentials).not.toHaveBeenCalled();
diff --git a/backend/src/ee/services/dynamic-secret/providers/kafka.ts b/backend/src/ee/services/dynamic-secret/providers/kafka.ts
index 9e8f6eebb2..94e415afc4 100644
--- a/backend/src/ee/services/dynamic-secret/providers/kafka.ts
+++ b/backend/src/ee/services/dynamic-secret/providers/kafka.ts
@@ -27,6 +27,7 @@ import { TDynamicSecrets } from "@app/db/schemas";
import { BadRequestError } from "@app/lib/errors";
import { sanitizeString } from "@app/lib/fn";
import { logger } from "@app/lib/logger";
+import { alphaNumericNanoId } from "@app/lib/nanoid";
import { getTlsServerNameOptions } from "@app/lib/tls";
import { ActorIdentityAttributes } from "../../dynamic-secret-lease/dynamic-secret-lease-types";
@@ -47,9 +48,6 @@ const SCRAM_CREDENTIALS = [
{ mechanism: ScramMechanisms.SCRAM_SHA_512, digest: "sha512", keyLength: 64 }
] as const;
-// {{randomUsername}} or {{random N}}, on its own or inside a helper such as {{truncate randomUsername 12}}
-const RANDOM_TEMPLATE_PART = /{{[^}]*\b(?:randomUsername\b|random\s+\d)/;
-
const REQUIRED_APIS = [alterUserScramCredentialsV0.api, createAclsV3.api, deleteAclsV3.api];
const generatePassword = () => {
@@ -100,7 +98,7 @@ const deleteKafkaUser = async (connection: Connection, username: string) => {
// Writing credentials for an existing user would hand the lease that user's ACLs or super user rights, and revoking
// the lease would then delete them
-const assertNewKafkaUser = async (connection: Connection, username: string, adminUsername: string) => {
+const assertNewKafkaUser = async (connection: Connection, username: string) => {
const hasScramCredentials = () =>
describeUserScramCredentialsV0.api.async(connection, [{ name: username }]).then(
() => true,
@@ -112,10 +110,9 @@ const assertNewKafkaUser = async (connection: Connection, username: string, admi
const hasAcls = async () =>
(await describeAclsV3.api.async(connection, getPrincipalAclFilter(username))).resources.length > 0;
- if (username === adminUsername || (await hasScramCredentials()) || (await hasAcls())) {
+ if ((await hasScramCredentials()) || (await hasAcls())) {
throw new BadRequestError({
- message:
- "A Kafka user with the generated username already exists. Use a username template that generates a unique name for each lease, such as one that includes {{randomUsername}}."
+ message: "A Kafka user with the generated username already exists. Create the lease again to get a new username."
});
}
};
@@ -229,21 +226,15 @@ export const KafkaProvider = (): TDynamicProviderFns => {
dynamicSecret: TDynamicSecrets;
}) => {
const { inputs, usernameTemplate, identity, dynamicSecret } = data;
- // A fixed name could match a user Infisical can't detect, such as a super user defined only in a broker's JAAS
- // configuration, and the lease would take over that user's access
- if (usernameTemplate && !RANDOM_TEMPLATE_PART.test(usernameTemplate)) {
- throw new BadRequestError({
- message:
- "This dynamic secret's username template has no random part. Edit the dynamic secret and add one, such as {{randomUsername}} or {{random 8}}, so that each lease gets a new Kafka user."
- });
- }
const providerInputs = await validateProviderInputs(inputs);
- const username = await generateUsername(usernameTemplate, {
+ // A template can produce a fixed name, which could match a user Infisical can't detect, such as a super user
+ // defined only in a broker's JAAS configuration, so every lease user also gets a random suffix
+ const username = `${await generateUsername(usernameTemplate, {
decryptedDynamicSecretInputs: inputs,
dynamicSecret,
identity
- });
+ })}-${alphaNumericNanoId(8)}`;
const password = generatePassword();
const upsertions = await Promise.all(
SCRAM_CREDENTIALS.map(async ({ mechanism, digest, keyLength }) => {
@@ -257,7 +248,7 @@ export const KafkaProvider = (): TDynamicProviderFns => {
providerInputs,
"Failed to create lease from provider",
async (connection) => {
- await assertNewKafkaUser(connection, username, providerInputs.username);
+ await assertNewKafkaUser(connection, username);
try {
// Kafka accepts one credential change per user per request
await Promise.all(
diff --git a/docs/documentation/platform/dynamic-secrets/kafka.mdx b/docs/documentation/platform/dynamic-secrets/kafka.mdx
index 133e459934..5bb523a59f 100644
--- a/docs/documentation/platform/dynamic-secrets/kafka.mdx
+++ b/docs/documentation/platform/dynamic-secrets/kafka.mdx
@@ -76,7 +76,7 @@ Lease users log in with SCRAM-SHA-256 or SCRAM-SHA-512. To learn how leases work
<DynamicSecretUsernameTemplateParamField />
<Note>
- The template must include a random part, such as `{{randomUsername}}` or `{{random 8}}` (for example, `{{identity.name}}-{{random 8}}`), so that each lease gets a new Kafka user. A fixed name could match a user that already exists, and the lease would take over that user's access.
+ Infisical adds a hyphen and 8 random characters to every username the template generates, so each lease gets a new Kafka user. For example, `{{identity.name}}` generates a username such as `jane-x7Kp2QmA`.
</Note>
<ParamField path="Enable SSL" type="boolean" default="false">
@@ -182,9 +182,6 @@ These examples show the ACLs to add in [Step 1](#step-1-create-the-dynamic-secre
<Accordion title="Invalid credentials with SASL mechanism">
The broker rejected the admin user's login. Check the **Password**, and check that the admin user has a credential for the **SASL Mechanism** you selected. For example, a user defined only in the brokers' JAAS configuration for PLAIN has no SCRAM credential.
</Accordion>
- <Accordion title="A Kafka user with the generated username already exists">
- The username template generated the name of the admin user or of a Kafka user that already has SCRAM credentials or ACLs, which can happen if the random part of the template is short. Infisical doesn't change existing users, so use a longer random part in the **Username Template**, such as `{{randomUsername}}`.
- </Accordion>
<Accordion title="On a ZooKeeper cluster, Infisical can't connect to a broker you didn't add">
With ZooKeeper, only the controller broker accepts changes to SCRAM users, so Infisical connects to the controller at the address the controller advertises. Any broker can become the controller, so make sure Infisical can reach every broker's advertised address.
</Accordion>
diff --git a/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/data-protocol-contract.test.ts b/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/data-protocol-contract.test.ts
index 4b2a2be3d8..57d4c23321 100644
--- a/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/data-protocol-contract.test.ts
+++ b/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/data-protocol-contract.test.ts
@@ -898,11 +898,6 @@ testDynamicSecretProviderContract({
inputs: { ...kafkaCreateValues.inputs, acls: [getDefaultKafkaAcl()] }
},
issuePaths: [["inputs", "acls", 0, "resourceName"]]
- },
- {
- name: "username template has no random part",
- values: { ...kafkaCreateValues, usernameTemplate: "{{identity.name}}" },
- issuePaths: [["usernameTemplate"]]
}
]
},
diff --git a/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/providerDefinitions/kafkaContract.ts b/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/providerDefinitions/kafkaContract.ts
index c3138f4ae2..e5684bf998 100644
--- a/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/providerDefinitions/kafkaContract.ts
+++ b/frontend/src/components/dynamic-secrets/DynamicSecretProviderForm/providerDefinitions/kafkaContract.ts
@@ -66,27 +66,11 @@ export const kafkaEditInputsSchema = kafkaCreateInputsSchema.extend({
export type TKafkaFormInputs = z.input<typeof kafkaCreateInputsSchema>;
export type TKafkaFormValues = TDynamicSecretProviderFormValues<TKafkaFormInputs>;
-// Same rule as the backend's lease check: a fixed name could take over a Kafka user that already exists
-const RANDOM_TEMPLATE_PART = /{{[^}]*\b(?:randomUsername\b|random\s+\d)/;
-
-const kafkaUsernameTemplateSchema = z
- .string()
- .trim()
- .nullable()
- .optional()
- .refine((template) => !template || RANDOM_TEMPLATE_PART.test(template), {
- message:
- "Include a random part, such as {{randomUsername}} or {{random 8}}, so that each lease gets a new Kafka user"
- });
-
export const kafkaCreateFormSchema = createDynamicSecretProviderFormSchema(
- kafkaCreateInputsSchema,
- {
- usernameTemplateSchema: kafkaUsernameTemplateSchema
- }
+ kafkaCreateInputsSchema
) as z.ZodType<TKafkaFormValues>;
export const kafkaEditFormSchema = editDynamicSecretProviderFormSchema(kafkaEditInputsSchema, {
- usernameTemplateSchema: kafkaUsernameTemplateSchema
+ usernameTemplateSchema: z.string().trim().nullable().optional()
}) as z.ZodType<TKafkaFormValues>;
export const getDefaultKafkaBootstrapServer = (): TKafkaFormInputs["bootstrapServers"][number] => ({