From 4f0007faa586a319b6afcf1c8919f81d2a62f05f Mon Sep 17 00:00:00 2001 From: Carlos Monastyrski Date: Sun, 3 Aug 2025 12:19:57 -0300 Subject: [PATCH 1/7] Add Machine Auth Templates --- backend/scripts/generate-schema-types.ts | 1 + backend/src/@types/fastify.d.ts | 2 + backend/src/@types/knex.d.ts | 10 + ...250801170240_add-identity-auth-template.ts | 36 ++ .../src/db/schemas/identity-auth-templates.ts | 24 ++ backend/src/db/schemas/identity-ldap-auths.ts | 3 +- backend/src/db/schemas/models.ts | 1 + .../ee/services/audit-log/audit-log-types.ts | 30 ++ .../services/license/__mocks__/license-fns.ts | 3 +- .../src/ee/services/license/license-fns.ts | 3 +- .../src/ee/services/license/license-types.ts | 1 + .../ee/services/permission/org-permission.ts | 48 +++ backend/src/lib/api-docs/constants.ts | 41 +- backend/src/server/routes/index.ts | 15 +- .../routes/v1/identity-ldap-auth-router.ts | 24 +- .../routes/v1/identity-template-router.ts | 381 ++++++++++++++++ backend/src/server/routes/v1/index.ts | 9 +- .../identity-auth-template-dal.ts | 69 +++ .../identity-auth-template-enums.ts | 19 + .../identity-auth-template-service.ts | 406 ++++++++++++++++++ .../identity-auth-template-types.ts | 59 +++ .../services/identity-auth-template/index.ts | 6 + .../identity-ldap-auth-service.ts | 91 +++- .../identity-ldap-auth-types.ts | 10 +- docs/docs.json | 1 + .../platform/identities/auth-templates.mdx | 98 +++++ .../auth-templates/create-template-button.png | Bin 0 -> 696497 bytes .../auth-templates/ldap-template.png | Bin 0 -> 498260 bytes .../auth-templates/template-usages-modal.png | Bin 0 -> 472169 bytes .../auth-templates/template-usages.png | Bin 0 -> 704526 bytes .../auth-templates/templates-section.png | Bin 0 -> 696693 bytes .../src/context/OrgPermissionContext/types.ts | 15 +- .../src/hooks/api/identities/mutations.tsx | 4 + frontend/src/hooks/api/identities/types.ts | 19 +- .../hooks/api/identityAuthTemplates/index.tsx | 3 + .../api/identityAuthTemplates/mutations.tsx | 97 +++++ .../api/identityAuthTemplates/queries.tsx | 90 ++++ .../hooks/api/identityAuthTemplates/types.ts | 76 ++++ frontend/src/hooks/api/index.tsx | 1 + frontend/src/hooks/api/subscriptions/types.ts | 1 + .../IdentityAuthTemplateModal.tsx | 291 +++++++++++++ .../IdentityAuthTemplatesTable.tsx | 284 ++++++++++++ .../IdentitySection/IdentityLdapAuthForm.tsx | 378 ++++++++++------ .../IdentitySection/IdentitySection.tsx | 107 ++++- .../MachineAuthTemplateUsagesModal.tsx | 245 +++++++++++ .../components/OrgRoleModifySection.utils.ts | 12 + ...rmissionMachineIdentityAuthTemplateRow.tsx | 204 +++++++++ .../RolePermissionRow.tsx | 8 +- .../RolePermissionsSection.tsx | 6 + 49 files changed, 3056 insertions(+), 176 deletions(-) create mode 100644 backend/src/db/migrations/20250801170240_add-identity-auth-template.ts create mode 100644 backend/src/db/schemas/identity-auth-templates.ts create mode 100644 backend/src/server/routes/v1/identity-template-router.ts create mode 100644 backend/src/services/identity-auth-template/identity-auth-template-dal.ts create mode 100644 backend/src/services/identity-auth-template/identity-auth-template-enums.ts create mode 100644 backend/src/services/identity-auth-template/identity-auth-template-service.ts create mode 100644 backend/src/services/identity-auth-template/identity-auth-template-types.ts create mode 100644 backend/src/services/identity-auth-template/index.ts create mode 100644 docs/documentation/platform/identities/auth-templates.mdx create mode 100644 docs/images/platform/identities/auth-templates/create-template-button.png create mode 100644 docs/images/platform/identities/auth-templates/ldap-template.png create mode 100644 docs/images/platform/identities/auth-templates/template-usages-modal.png create mode 100644 docs/images/platform/identities/auth-templates/template-usages.png create mode 100644 docs/images/platform/identities/auth-templates/templates-section.png create mode 100644 frontend/src/hooks/api/identityAuthTemplates/index.tsx create mode 100644 frontend/src/hooks/api/identityAuthTemplates/mutations.tsx create mode 100644 frontend/src/hooks/api/identityAuthTemplates/queries.tsx create mode 100644 frontend/src/hooks/api/identityAuthTemplates/types.ts create mode 100644 frontend/src/pages/organization/AccessManagementPage/components/OrgIdentityTab/components/IdentitySection/IdentityAuthTemplateModal.tsx create mode 100644 frontend/src/pages/organization/AccessManagementPage/components/OrgIdentityTab/components/IdentitySection/IdentityAuthTemplatesTable.tsx create mode 100644 frontend/src/pages/organization/AccessManagementPage/components/OrgIdentityTab/components/IdentitySection/MachineAuthTemplateUsagesModal.tsx create mode 100644 frontend/src/pages/organization/RoleByIDPage/components/RolePermissionsSection/OrgPermissionMachineIdentityAuthTemplateRow.tsx diff --git a/backend/scripts/generate-schema-types.ts b/backend/scripts/generate-schema-types.ts index c0e18a763..111f42520 100644 --- a/backend/scripts/generate-schema-types.ts +++ b/backend/scripts/generate-schema-types.ts @@ -99,6 +99,7 @@ const main = async () => { (el) => !el.tableName.includes("_migrations") && !el.tableName.includes("audit_logs_") && + !el.tableName.includes("active_locks") && el.tableName !== "intermediate_audit_logs" ); diff --git a/backend/src/@types/fastify.d.ts b/backend/src/@types/fastify.d.ts index 15e967948..c53e362fe 100644 --- a/backend/src/@types/fastify.d.ts +++ b/backend/src/@types/fastify.d.ts @@ -66,6 +66,7 @@ import { THsmServiceFactory } from "@app/services/hsm/hsm-service"; import { TIdentityServiceFactory } from "@app/services/identity/identity-service"; import { TIdentityAccessTokenServiceFactory } from "@app/services/identity-access-token/identity-access-token-service"; import { TIdentityAliCloudAuthServiceFactory } from "@app/services/identity-alicloud-auth/identity-alicloud-auth-service"; +import { TIdentityAuthTemplateServiceFactory } from "@app/services/identity-auth-template"; import { TIdentityAwsAuthServiceFactory } from "@app/services/identity-aws-auth/identity-aws-auth-service"; import { TIdentityAzureAuthServiceFactory } from "@app/services/identity-azure-auth/identity-azure-auth-service"; import { TIdentityGcpAuthServiceFactory } from "@app/services/identity-gcp-auth/identity-gcp-auth-service"; @@ -300,6 +301,7 @@ declare module "fastify" { reminder: TReminderServiceFactory; bus: TEventBusService; sse: TServerSentEventsService; + identityAuthTemplate: TIdentityAuthTemplateServiceFactory; }; // this is exclusive use for middlewares in which we need to inject data // everywhere else access using service layer diff --git a/backend/src/@types/knex.d.ts b/backend/src/@types/knex.d.ts index 185a32356..f645cb8f2 100644 --- a/backend/src/@types/knex.d.ts +++ b/backend/src/@types/knex.d.ts @@ -494,6 +494,11 @@ import { TAccessApprovalPoliciesEnvironmentsInsert, TAccessApprovalPoliciesEnvironmentsUpdate } from "@app/db/schemas/access-approval-policies-environments"; +import { + TIdentityAuthTemplates, + TIdentityAuthTemplatesInsert, + TIdentityAuthTemplatesUpdate +} from "@app/db/schemas/identity-auth-templates"; import { TIdentityLdapAuths, TIdentityLdapAuthsInsert, @@ -878,6 +883,11 @@ declare module "knex/types/tables" { TIdentityProjectAdditionalPrivilegeInsert, TIdentityProjectAdditionalPrivilegeUpdate >; + [TableName.IdentityAuthTemplate]: KnexOriginal.CompositeTableType< + TIdentityAuthTemplates, + TIdentityAuthTemplatesInsert, + TIdentityAuthTemplatesUpdate + >; [TableName.AccessApprovalPolicy]: KnexOriginal.CompositeTableType< TAccessApprovalPolicies, diff --git a/backend/src/db/migrations/20250801170240_add-identity-auth-template.ts b/backend/src/db/migrations/20250801170240_add-identity-auth-template.ts new file mode 100644 index 000000000..fff5bc40b --- /dev/null +++ b/backend/src/db/migrations/20250801170240_add-identity-auth-template.ts @@ -0,0 +1,36 @@ +import { Knex } from "knex"; + +import { TableName } from "../schemas"; +import { createOnUpdateTrigger, dropOnUpdateTrigger } from "../utils"; + +export async function up(knex: Knex): Promise { + if (!(await knex.schema.hasTable(TableName.IdentityAuthTemplate))) { + await knex.schema.createTable(TableName.IdentityAuthTemplate, (t) => { + t.uuid("id", { primaryKey: true }).defaultTo(knex.fn.uuid()); + t.binary("templateFields").notNullable(); + t.uuid("orgId").notNullable(); + t.foreign("orgId").references("id").inTable(TableName.Organization).onDelete("CASCADE"); + t.string("name", 64).notNullable(); + t.string("authMethod").notNullable(); + t.timestamps(true, true, true); + }); + await createOnUpdateTrigger(knex, TableName.IdentityAuthTemplate); + } + if (!(await knex.schema.hasColumn(TableName.IdentityLdapAuth, "templateId"))) { + await knex.schema.alterTable(TableName.IdentityLdapAuth, (t) => { + t.uuid("templateId").nullable(); + t.foreign("templateId").references("id").inTable(TableName.IdentityAuthTemplate).onDelete("SET NULL"); + }); + } +} + +export async function down(knex: Knex): Promise { + if (await knex.schema.hasColumn(TableName.IdentityLdapAuth, "template")) { + await knex.schema.alterTable(TableName.IdentityLdapAuth, (t) => { + t.dropForeign("templateId"); + t.dropColumn("templateId"); + }); + } + await knex.schema.dropTableIfExists(TableName.IdentityAuthTemplate); + await dropOnUpdateTrigger(knex, TableName.IdentityAuthTemplate); +} diff --git a/backend/src/db/schemas/identity-auth-templates.ts b/backend/src/db/schemas/identity-auth-templates.ts new file mode 100644 index 000000000..efe8ccb8c --- /dev/null +++ b/backend/src/db/schemas/identity-auth-templates.ts @@ -0,0 +1,24 @@ +// Code generated by automation script, DO NOT EDIT. +// Automated by pulling database and generating zod schema +// To update. Just run npm run generate:schema +// Written by akhilmhdh. + +import { z } from "zod"; + +import { zodBuffer } from "@app/lib/zod"; + +import { TImmutableDBKeys } from "./models"; + +export const IdentityAuthTemplatesSchema = z.object({ + id: z.string().uuid(), + templateFields: zodBuffer, + orgId: z.string().uuid(), + name: z.string(), + authMethod: z.string(), + createdAt: z.date(), + updatedAt: z.date() +}); + +export type TIdentityAuthTemplates = z.infer; +export type TIdentityAuthTemplatesInsert = Omit, TImmutableDBKeys>; +export type TIdentityAuthTemplatesUpdate = Partial, TImmutableDBKeys>>; diff --git a/backend/src/db/schemas/identity-ldap-auths.ts b/backend/src/db/schemas/identity-ldap-auths.ts index e8d0658d5..3e4d88649 100644 --- a/backend/src/db/schemas/identity-ldap-auths.ts +++ b/backend/src/db/schemas/identity-ldap-auths.ts @@ -25,7 +25,8 @@ export const IdentityLdapAuthsSchema = z.object({ allowedFields: z.unknown().nullable().optional(), createdAt: z.date(), updatedAt: z.date(), - accessTokenPeriod: z.coerce.number().default(0) + accessTokenPeriod: z.coerce.number().default(0), + templateId: z.string().uuid().nullable().optional() }); export type TIdentityLdapAuths = z.infer; diff --git a/backend/src/db/schemas/models.ts b/backend/src/db/schemas/models.ts index 55ec12faa..855934b28 100644 --- a/backend/src/db/schemas/models.ts +++ b/backend/src/db/schemas/models.ts @@ -91,6 +91,7 @@ export enum TableName { IdentityProjectMembership = "identity_project_memberships", IdentityProjectMembershipRole = "identity_project_membership_role", IdentityProjectAdditionalPrivilege = "identity_project_additional_privilege", + IdentityAuthTemplate = "identity_auth_templates", // used by both identity and users IdentityMetadata = "identity_metadata", ResourceMetadata = "resource_metadata", diff --git a/backend/src/ee/services/audit-log/audit-log-types.ts b/backend/src/ee/services/audit-log/audit-log-types.ts index 818bb1f99..a1617d57e 100644 --- a/backend/src/ee/services/audit-log/audit-log-types.ts +++ b/backend/src/ee/services/audit-log/audit-log-types.ts @@ -161,6 +161,9 @@ export enum EventType { CREATE_IDENTITY = "create-identity", UPDATE_IDENTITY = "update-identity", DELETE_IDENTITY = "delete-identity", + MACHINE_IDENTITY_AUTH_TEMPLATE_CREATE = "machine-identity-auth-template-create", + MACHINE_IDENTITY_AUTH_TEMPLATE_UPDATE = "machine-identity-auth-template-update", + MACHINE_IDENTITY_AUTH_TEMPLATE_DELETE = "machine-identity-auth-template-delete", LOGIN_IDENTITY_UNIVERSAL_AUTH = "login-identity-universal-auth", ADD_IDENTITY_UNIVERSAL_AUTH = "add-identity-universal-auth", UPDATE_IDENTITY_UNIVERSAL_AUTH = "update-identity-universal-auth", @@ -830,6 +833,30 @@ interface LoginIdentityUniversalAuthEvent { }; } +interface MachineIdentityAuthTemplateCreateEvent { + type: EventType.MACHINE_IDENTITY_AUTH_TEMPLATE_CREATE; + metadata: { + templateId: string; + name: string; + }; +} + +interface MachineIdentityAuthTemplateUpdateEvent { + type: EventType.MACHINE_IDENTITY_AUTH_TEMPLATE_UPDATE; + metadata: { + templateId: string; + name: string; + }; +} + +interface MachineIdentityAuthTemplateDeleteEvent { + type: EventType.MACHINE_IDENTITY_AUTH_TEMPLATE_DELETE; + metadata: { + templateId: string; + name: string; + }; +} + interface AddIdentityUniversalAuthEvent { type: EventType.ADD_IDENTITY_UNIVERSAL_AUTH; metadata: { @@ -3439,6 +3466,9 @@ export type Event = | UpdateIdentityEvent | DeleteIdentityEvent | LoginIdentityUniversalAuthEvent + | MachineIdentityAuthTemplateCreateEvent + | MachineIdentityAuthTemplateUpdateEvent + | MachineIdentityAuthTemplateDeleteEvent | AddIdentityUniversalAuthEvent | UpdateIdentityUniversalAuthEvent | DeleteIdentityUniversalAuthEvent diff --git a/backend/src/ee/services/license/__mocks__/license-fns.ts b/backend/src/ee/services/license/__mocks__/license-fns.ts index 5259d4616..4c42ad7a2 100644 --- a/backend/src/ee/services/license/__mocks__/license-fns.ts +++ b/backend/src/ee/services/license/__mocks__/license-fns.ts @@ -31,7 +31,8 @@ export const getDefaultOnPremFeatures = () => { caCrl: false, sshHostGroups: false, enterpriseSecretSyncs: false, - enterpriseAppConnections: false + enterpriseAppConnections: false, + machineIdentityAuthTemplates: false }; }; diff --git a/backend/src/ee/services/license/license-fns.ts b/backend/src/ee/services/license/license-fns.ts index fecba7ba7..bd3949a7e 100644 --- a/backend/src/ee/services/license/license-fns.ts +++ b/backend/src/ee/services/license/license-fns.ts @@ -60,7 +60,8 @@ export const getDefaultOnPremFeatures = (): TFeatureSet => ({ enterpriseSecretSyncs: false, enterpriseAppConnections: false, fips: false, - eventSubscriptions: false + eventSubscriptions: false, + machineIdentityAuthTemplates: false }); export const setupLicenseRequestWithStore = ( diff --git a/backend/src/ee/services/license/license-types.ts b/backend/src/ee/services/license/license-types.ts index 84a652c46..098d00feb 100644 --- a/backend/src/ee/services/license/license-types.ts +++ b/backend/src/ee/services/license/license-types.ts @@ -75,6 +75,7 @@ export type TFeatureSet = { secretScanning: false; enterpriseSecretSyncs: false; enterpriseAppConnections: false; + machineIdentityAuthTemplates: false; fips: false; eventSubscriptions: false; }; diff --git a/backend/src/ee/services/permission/org-permission.ts b/backend/src/ee/services/permission/org-permission.ts index f0fe73d71..5c818f1f1 100644 --- a/backend/src/ee/services/permission/org-permission.ts +++ b/backend/src/ee/services/permission/org-permission.ts @@ -28,6 +28,14 @@ export enum OrgPermissionKmipActions { Setup = "setup" } +export enum OrgPermissionMachineIdentityAuthTemplateActions { + ListTemplates = "list-templates", + EditTemplates = "edit-templates", + CreateTemplates = "create-templates", + DeleteTemplates = "delete-templates", + UnlinkTemplates = "unlink-templates" +} + export enum OrgPermissionAdminConsoleAction { AccessAllProjects = "access-all-projects" } @@ -88,6 +96,7 @@ export enum OrgPermissionSubjects { Identity = "identity", Kms = "kms", AdminConsole = "organization-admin-console", + MachineIdentityAuthTemplate = "machine-identity-auth-template", AuditLogs = "audit-logs", ProjectTemplates = "project-templates", AppConnections = "app-connections", @@ -126,6 +135,7 @@ export type OrgPermissionSet = ) ] | [OrgPermissionAdminConsoleAction, OrgPermissionSubjects.AdminConsole] + | [OrgPermissionMachineIdentityAuthTemplateActions, OrgPermissionSubjects.MachineIdentityAuthTemplate] | [OrgPermissionKmipActions, OrgPermissionSubjects.Kmip] | [OrgPermissionSecretShareAction, OrgPermissionSubjects.SecretShare]; @@ -237,6 +247,14 @@ export const OrgPermissionSchema = z.discriminatedUnion("subject", [ "Describe what action an entity can take." ) }), + z.object({ + subject: z + .literal(OrgPermissionSubjects.MachineIdentityAuthTemplate) + .describe("The entity this permission pertains to."), + action: CASL_ACTION_SCHEMA_NATIVE_ENUM(OrgPermissionMachineIdentityAuthTemplateActions).describe( + "Describe what action an entity can take." + ) + }), z.object({ subject: z.literal(OrgPermissionSubjects.Gateway).describe("The entity this permission pertains to."), action: CASL_ACTION_SCHEMA_NATIVE_ENUM(OrgPermissionGatewayActions).describe( @@ -350,6 +368,21 @@ const buildAdminPermission = () => { // the proxy assignment is temporary in order to prevent "more privilege" error during role assignment to MI can(OrgPermissionKmipActions.Proxy, OrgPermissionSubjects.Kmip); + can(OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, OrgPermissionSubjects.MachineIdentityAuthTemplate); + can(OrgPermissionMachineIdentityAuthTemplateActions.EditTemplates, OrgPermissionSubjects.MachineIdentityAuthTemplate); + can( + OrgPermissionMachineIdentityAuthTemplateActions.CreateTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + can( + OrgPermissionMachineIdentityAuthTemplateActions.DeleteTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + can( + OrgPermissionMachineIdentityAuthTemplateActions.UnlinkTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + can(OrgPermissionSecretShareAction.ManageSettings, OrgPermissionSubjects.SecretShare); return rules; @@ -385,6 +418,21 @@ const buildMemberPermission = () => { can(OrgPermissionGatewayActions.CreateGateways, OrgPermissionSubjects.Gateway); can(OrgPermissionGatewayActions.AttachGateways, OrgPermissionSubjects.Gateway); + can(OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, OrgPermissionSubjects.MachineIdentityAuthTemplate); + can(OrgPermissionMachineIdentityAuthTemplateActions.EditTemplates, OrgPermissionSubjects.MachineIdentityAuthTemplate); + can( + OrgPermissionMachineIdentityAuthTemplateActions.CreateTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + can( + OrgPermissionMachineIdentityAuthTemplateActions.DeleteTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + can( + OrgPermissionMachineIdentityAuthTemplateActions.UnlinkTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + return rules; }; diff --git a/backend/src/lib/api-docs/constants.ts b/backend/src/lib/api-docs/constants.ts index 72b283a0f..a0a7920fa 100644 --- a/backend/src/lib/api-docs/constants.ts +++ b/backend/src/lib/api-docs/constants.ts @@ -18,6 +18,7 @@ import { SECRET_SYNC_CONNECTION_MAP, SECRET_SYNC_NAME_MAP } from "@app/services/ export enum ApiDocsTags { Identities = "Identities", + IdentityTemplates = "Identity Templates", TokenAuth = "Token Auth", UniversalAuth = "Universal Auth", GcpAuth = "GCP Auth", @@ -147,6 +148,42 @@ export const IDENTITIES = { } } as const; +export const IDENTITY_TEMPLATES = { + CREATE: { + name: "The name of the identity template to create.", + organizationId: "The organization ID to which the identity template belongs.", + authMethod: "The auth method of the template.", + credentials: "Set of credentials to reuse by this template" + }, + UPDATE: { + identityTemplateId: "The ID of the identity to update.", + name: "The new name of the identity template.", + authMethod: "The auth method of the template." + }, + DELETE: { + identityTemplateId: "The ID of the identity template to delete." + }, + GET_BY_ID: { + identityTemplateId: "The ID of the identity template to get details.", + organizationId: "The organization ID to which the identity template belongs.", + authMethod: "The auth method of the template.", + credentials: "Set of credentials used by this template" + }, + LIST: { + orgId: "The ID of the organization to list identity templates." + }, + SEARCH: { + search: { + desc: "The filters to apply to the search.", + name: "The name of the identity template to filter by." + }, + offset: "The offset to start from. If you enter 10, it will start from the 10th identity.", + limit: "The number of identity templates to return.", + orderBy: "The column to order identity templates by.", + orderDirection: "The direction to order identity templates in." + } +}; + export const UNIVERSAL_AUTH = { LOGIN: { clientId: "Your Machine Identity Client ID.", @@ -214,6 +251,7 @@ export const LDAP_AUTH = { password: "The password of the LDAP user to login." }, ATTACH: { + templateId: "The ID of the template to attach the configuration onto.", identityId: "The ID of the identity to attach the configuration onto.", url: "The URL of the LDAP server.", allowedFields: @@ -240,7 +278,8 @@ export const LDAP_AUTH = { accessTokenTTL: "The new lifetime for an access token in seconds.", accessTokenMaxTTL: "The new maximum lifetime for an access token in seconds.", accessTokenNumUsesLimit: "The new maximum number of times that an access token can be used.", - accessTokenTrustedIps: "The new IPs or CIDR ranges that access tokens can be used from." + accessTokenTrustedIps: "The new IPs or CIDR ranges that access tokens can be used from.", + templateId: "The ID of the template to update the configuration for." }, RETRIEVE: { identityId: "The ID of the identity to retrieve the configuration for." diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts index ee0b2e0f3..c93a12ab6 100644 --- a/backend/src/server/routes/index.ts +++ b/backend/src/server/routes/index.ts @@ -179,6 +179,8 @@ import { identityAccessTokenDALFactory } from "@app/services/identity-access-tok import { identityAccessTokenServiceFactory } from "@app/services/identity-access-token/identity-access-token-service"; import { identityAliCloudAuthDALFactory } from "@app/services/identity-alicloud-auth/identity-alicloud-auth-dal"; import { identityAliCloudAuthServiceFactory } from "@app/services/identity-alicloud-auth/identity-alicloud-auth-service"; +import { identityAuthTemplateDALFactory } from "@app/services/identity-auth-template/identity-auth-template-dal"; +import { identityAuthTemplateServiceFactory } from "@app/services/identity-auth-template/identity-auth-template-service"; import { identityAwsAuthDALFactory } from "@app/services/identity-aws-auth/identity-aws-auth-dal"; import { identityAwsAuthServiceFactory } from "@app/services/identity-aws-auth/identity-aws-auth-service"; import { identityAzureAuthDALFactory } from "@app/services/identity-azure-auth/identity-azure-auth-dal"; @@ -394,6 +396,7 @@ export const registerRoutes = async ( const identityProjectDAL = identityProjectDALFactory(db); const identityProjectMembershipRoleDAL = identityProjectMembershipRoleDALFactory(db); const identityProjectAdditionalPrivilegeDAL = identityProjectAdditionalPrivilegeDALFactory(db); + const identityAuthTemplateDAL = identityAuthTemplateDALFactory(db); const identityTokenAuthDAL = identityTokenAuthDALFactory(db); const identityUaDAL = identityUaDALFactory(db); @@ -1461,6 +1464,14 @@ export const registerRoutes = async ( identityMetadataDAL }); + const identityAuthTemplateService = identityAuthTemplateServiceFactory({ + identityAuthTemplateDAL, + identityLdapAuthDAL, + permissionService, + kmsService, + licenseService + }); + const identityAccessTokenService = identityAccessTokenServiceFactory({ identityAccessTokenDAL, identityOrgMembershipDAL, @@ -1604,7 +1615,8 @@ export const registerRoutes = async ( identityAccessTokenDAL, identityOrgMembershipDAL, licenseService, - identityDAL + identityDAL, + identityAuthTemplateDAL }); const dynamicSecretProviders = buildDynamicSecretProviders({ @@ -2008,6 +2020,7 @@ export const registerRoutes = async ( webhook: webhookService, serviceToken: serviceTokenService, identity: identityService, + identityAuthTemplate: identityAuthTemplateService, identityAccessToken: identityAccessTokenService, identityProject: identityProjectService, identityTokenAuth: identityTokenAuthService, diff --git a/backend/src/server/routes/v1/identity-ldap-auth-router.ts b/backend/src/server/routes/v1/identity-ldap-auth-router.ts index 3da8a425b..c9bae9fc4 100644 --- a/backend/src/server/routes/v1/identity-ldap-auth-router.ts +++ b/backend/src/server/routes/v1/identity-ldap-auth-router.ts @@ -202,10 +202,11 @@ export const registerIdentityLdapAuthRouter = async (server: FastifyZodProvider) }), body: z .object({ - url: z.string().trim().min(1).describe(LDAP_AUTH.ATTACH.url), - bindDN: z.string().trim().min(1).describe(LDAP_AUTH.ATTACH.bindDN), - bindPass: z.string().trim().min(1).describe(LDAP_AUTH.ATTACH.bindPass), - searchBase: z.string().trim().min(1).describe(LDAP_AUTH.ATTACH.searchBase), + templateId: z.string().trim().optional().describe(LDAP_AUTH.ATTACH.templateId), + url: z.string().trim().optional().describe(LDAP_AUTH.ATTACH.url), + bindDN: z.string().trim().optional().describe(LDAP_AUTH.ATTACH.bindDN), + bindPass: z.string().trim().optional().describe(LDAP_AUTH.ATTACH.bindPass), + searchBase: z.string().trim().optional().describe(LDAP_AUTH.ATTACH.searchBase), searchFilter: z .string() .trim() @@ -242,7 +243,12 @@ export const registerIdentityLdapAuthRouter = async (server: FastifyZodProvider) .refine( (val) => val.accessTokenTTL <= val.accessTokenMaxTTL, "Access Token TTL cannot be greater than Access Token Max TTL." - ), + ) + .refine((val) => { + const hasTemplateId = !!val.templateId; + const hasManualConfig = !!(val.url && val.bindDN && val.bindPass && val.searchBase); + return hasTemplateId || hasManualConfig; + }, "Either templateId must be provided, or all of url, bindDN, bindPass, and searchBase must be provided."), response: { 200: z.object({ identityLdapAuth: IdentityLdapAuthsSchema.omit({ @@ -309,6 +315,7 @@ export const registerIdentityLdapAuthRouter = async (server: FastifyZodProvider) bindDN: z.string().trim().min(1).optional().describe(LDAP_AUTH.UPDATE.bindDN), bindPass: z.string().trim().min(1).optional().describe(LDAP_AUTH.UPDATE.bindPass), searchBase: z.string().trim().min(1).optional().describe(LDAP_AUTH.UPDATE.searchBase), + templateId: z.string().trim().optional().describe(LDAP_AUTH.UPDATE.templateId), searchFilter: z .string() .trim() @@ -411,9 +418,10 @@ export const registerIdentityLdapAuthRouter = async (server: FastifyZodProvider) encryptedBindPass: true, encryptedLdapCaCertificate: true }).extend({ - bindDN: z.string(), - bindPass: z.string(), - ldapCaCertificate: z.string().optional() + bindDN: z.string().optional(), + bindPass: z.string().optional(), + ldapCaCertificate: z.string().optional(), + templateId: z.string().optional().nullable() }) }) } diff --git a/backend/src/server/routes/v1/identity-template-router.ts b/backend/src/server/routes/v1/identity-template-router.ts new file mode 100644 index 000000000..1846e1f53 --- /dev/null +++ b/backend/src/server/routes/v1/identity-template-router.ts @@ -0,0 +1,381 @@ +import { z } from "zod"; + +import { IdentityAuthTemplatesSchema } from "@app/db/schemas/identity-auth-templates"; +import { EventType } from "@app/ee/services/audit-log/audit-log-types"; +import { readLimit, writeLimit } from "@app/server/config/rateLimiter"; +import { verifyAuth } from "@app/server/plugins/auth/verify-auth"; +import { AuthMode } from "@app/services/auth/auth-type"; +import { + IdentityAuthTemplateMethod, + TEMPLATE_SUCCESS_MESSAGES, + TEMPLATE_VALIDATION_MESSAGES +} from "@app/services/identity-auth-template/identity-auth-template-enums"; + +const ldapTemplateFieldsSchema = z.object({ + url: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.LDAP_URL_REQUIRED), + bindDN: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.BIND_DN_REQUIRED), + bindPass: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.BIND_PASSWORD_REQUIRED), + searchBase: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.SEARCH_BASE_REQUIRED) +}); + +export const registerIdentityTemplateRouter = async (server: FastifyZodProvider) => { + server.route({ + method: "POST", + url: "/", + config: { + rateLimit: writeLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Create identity auth template", + security: [ + { + bearerAuth: [] + } + ], + body: z.object({ + name: z.string().trim().min(1, TEMPLATE_VALIDATION_MESSAGES.TEMPLATE_NAME_REQUIRED), + authMethod: z.nativeEnum(IdentityAuthTemplateMethod), + templateFields: ldapTemplateFieldsSchema + }), + response: { + 200: z.object({ + message: z.string() + }) + } + }, + handler: async (req) => { + const template = await server.services.identityAuthTemplate.createTemplate({ + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId, + name: req.body.name, + authMethod: req.body.authMethod, + templateFields: req.body.templateFields + }); + + await server.services.auditLog.createAuditLog({ + ...req.auditLogInfo, + orgId: req.permission.orgId, + event: { + type: EventType.MACHINE_IDENTITY_AUTH_TEMPLATE_CREATE, + metadata: { + templateId: template.id, + name: template.name + } + } + }); + + return { message: TEMPLATE_SUCCESS_MESSAGES.CREATED }; + } + }); + + server.route({ + method: "PATCH", + url: "/:templateId", + config: { + rateLimit: writeLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Update identity auth template", + security: [ + { + bearerAuth: [] + } + ], + params: z.object({ + templateId: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.TEMPLATE_ID_REQUIRED) + }), + body: z.object({ + name: z.string().trim().optional(), + templateFields: ldapTemplateFieldsSchema.partial().optional() + }), + response: { + 200: z.object({ + message: z.string() + }) + } + }, + handler: async (req) => { + const template = await server.services.identityAuthTemplate.updateTemplate({ + templateId: req.params.templateId, + name: req.body.name, + templateFields: req.body.templateFields, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + await server.services.auditLog.createAuditLog({ + ...req.auditLogInfo, + orgId: req.permission.orgId, + event: { + type: EventType.MACHINE_IDENTITY_AUTH_TEMPLATE_UPDATE, + metadata: { + templateId: template.id, + name: template.name + } + } + }); + + return { message: TEMPLATE_SUCCESS_MESSAGES.UPDATED }; + } + }); + + server.route({ + method: "DELETE", + url: "/:templateId", + config: { + rateLimit: writeLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Delete identity auth template", + security: [ + { + bearerAuth: [] + } + ], + params: z.object({ + templateId: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.TEMPLATE_ID_REQUIRED) + }), + response: { + 200: z.object({ + message: z.string() + }) + } + }, + handler: async (req) => { + const template = await server.services.identityAuthTemplate.deleteTemplate({ + templateId: req.params.templateId, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + await server.services.auditLog.createAuditLog({ + ...req.auditLogInfo, + orgId: req.permission.orgId, + event: { + type: EventType.MACHINE_IDENTITY_AUTH_TEMPLATE_DELETE, + metadata: { + templateId: template.id, + name: template.name + } + } + }); + + return { message: TEMPLATE_SUCCESS_MESSAGES.DELETED }; + } + }); + + server.route({ + method: "GET", + url: "/:templateId", + config: { + rateLimit: readLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Get identity auth template by ID", + security: [ + { + bearerAuth: [] + } + ], + params: z.object({ + templateId: z.string().min(1, TEMPLATE_VALIDATION_MESSAGES.TEMPLATE_ID_REQUIRED) + }), + response: { + 200: z.object({ + template: IdentityAuthTemplatesSchema.extend({ + templateFields: ldapTemplateFieldsSchema + }) + }) + } + }, + handler: async (req) => { + const template = await server.services.identityAuthTemplate.getTemplate({ + templateId: req.params.templateId, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + return { template }; + } + }); + + server.route({ + method: "GET", + url: "/search", + config: { + rateLimit: readLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "List identity auth templates", + security: [ + { + bearerAuth: [] + } + ], + querystring: z.object({ + limit: z.coerce.number().positive().max(100).default(5).optional(), + offset: z.coerce.number().min(0).default(0).optional() + }), + response: { + 200: z.object({ + templates: IdentityAuthTemplatesSchema.extend({ + templateFields: ldapTemplateFieldsSchema + }).array(), + totalCount: z.number() + }) + } + }, + handler: async (req) => { + const { templates, totalCount } = await server.services.identityAuthTemplate.listTemplates({ + limit: req.query.limit, + offset: req.query.offset, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + return { templates, totalCount }; + } + }); + + server.route({ + method: "GET", + url: "/", + config: { + rateLimit: readLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Get identity auth templates by authentication method", + security: [ + { + bearerAuth: [] + } + ], + querystring: z.object({ + authMethod: z.nativeEnum(IdentityAuthTemplateMethod) + }), + response: { + 200: IdentityAuthTemplatesSchema.extend({ + templateFields: ldapTemplateFieldsSchema + }).array() + } + }, + handler: async (req) => { + const templates = await server.services.identityAuthTemplate.getTemplatesByAuthMethod({ + authMethod: req.query.authMethod, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + return templates; + } + }); + + server.route({ + method: "GET", + url: "/:templateId/usage", + config: { + rateLimit: readLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Get identity auth templates by authentication method", + security: [ + { + bearerAuth: [] + } + ], + params: z.object({ + templateId: z.string() + }), + response: { + 200: z + .object({ + identityId: z.string(), + identityName: z.string() + }) + .array() + } + }, + handler: async (req) => { + const templates = await server.services.identityAuthTemplate.findTemplateUsages({ + templateId: req.params.templateId, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + return templates; + } + }); + + server.route({ + method: "POST", + url: "/:templateId/usage", + config: { + rateLimit: readLimit + }, + onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]), + schema: { + hide: false, + description: "Unlink identity auth template usage", + security: [ + { + bearerAuth: [] + } + ], + params: z.object({ + templateId: z.string() + }), + body: z.object({ + identityIds: z.string().array() + }), + response: { + 200: z + .object({ + authId: z.string(), + identityId: z.string(), + identityName: z.string() + }) + .array() + } + }, + handler: async (req) => { + const templates = await server.services.identityAuthTemplate.unlinkTemplateUsage({ + templateId: req.params.templateId, + identityIds: req.body.identityIds, + actor: req.permission.type, + actorId: req.permission.id, + actorAuthMethod: req.permission.authMethod, + actorOrgId: req.permission.orgId + }); + + return templates; + } + }); +}; diff --git a/backend/src/server/routes/v1/index.ts b/backend/src/server/routes/v1/index.ts index 458efd194..3d0e721c4 100644 --- a/backend/src/server/routes/v1/index.ts +++ b/backend/src/server/routes/v1/index.ts @@ -26,6 +26,7 @@ import { registerIdentityLdapAuthRouter } from "./identity-ldap-auth-router"; import { registerIdentityOciAuthRouter } from "./identity-oci-auth-router"; import { registerIdentityOidcAuthRouter } from "./identity-oidc-auth-router"; import { registerIdentityRouter } from "./identity-router"; +import { registerIdentityTemplateRouter } from "./identity-template-router"; import { registerIdentityTlsCertAuthRouter } from "./identity-tls-cert-auth-router"; import { registerIdentityTokenAuthRouter } from "./identity-token-auth-router"; import { registerIdentityUaRouter } from "./identity-universal-auth-router"; @@ -134,7 +135,13 @@ export const registerV1Routes = async (server: FastifyZodProvider) => { await server.register(registerIntegrationRouter, { prefix: "/integration" }); await server.register(registerIntegrationAuthRouter, { prefix: "/integration-auth" }); await server.register(registerWebhookRouter, { prefix: "/webhooks" }); - await server.register(registerIdentityRouter, { prefix: "/identities" }); + await server.register( + async (identitiesRouter) => { + await identitiesRouter.register(registerIdentityRouter); + await identitiesRouter.register(registerIdentityTemplateRouter, { prefix: "/templates" }); + }, + { prefix: "/identities" } + ); await server.register( async (secretSharingRouter) => { diff --git a/backend/src/services/identity-auth-template/identity-auth-template-dal.ts b/backend/src/services/identity-auth-template/identity-auth-template-dal.ts new file mode 100644 index 000000000..cbcd1581b --- /dev/null +++ b/backend/src/services/identity-auth-template/identity-auth-template-dal.ts @@ -0,0 +1,69 @@ +/* eslint-disable no-case-declarations */ +import { Knex } from "knex"; + +import { TDbClient } from "@app/db"; +import { TableName } from "@app/db/schemas"; +import { buildFindFilter, ormify } from "@app/lib/knex"; + +import { IdentityAuthTemplateMethod } from "./identity-auth-template-enums"; + +export type TIdentityAuthTemplateDALFactory = ReturnType; + +export const identityAuthTemplateDALFactory = (db: TDbClient) => { + const identityAuthTemplateOrm = ormify(db, TableName.IdentityAuthTemplate); + + const findByOrgId = async ( + orgId: string, + { limit, offset, tx }: { limit?: number; offset?: number; tx?: Knex } = {} + ) => { + let query = (tx || db.replicaNode())(TableName.IdentityAuthTemplate).where({ orgId }).orderBy("createdAt", "desc"); + + if (limit !== undefined) { + query = query.limit(limit); + } + if (offset !== undefined) { + query = query.offset(offset); + } + + const docs = await query; + + const [{ count }] = (await (tx || db.replicaNode())(TableName.IdentityAuthTemplate) + .where({ orgId }) + .count("* as count")) as [{ count: string | number }]; + + return { docs, totalCount: Number(count) }; + }; + + const findByAuthMethod = async (authMethod: string, orgId: string, tx?: Knex) => { + const query = (tx || db.replicaNode())(TableName.IdentityAuthTemplate) + .where({ authMethod, orgId }) + .orderBy("createdAt", "desc"); + const docs = await query; + return docs; + }; + + const findTemplateUsages = async (templateId: string, authMethod: string, tx?: Knex) => { + switch (authMethod) { + case IdentityAuthTemplateMethod.LDAP: + const query = (tx || db.replicaNode())(TableName.IdentityLdapAuth) + .join(TableName.Identity, `${TableName.IdentityLdapAuth}.identityId`, `${TableName.Identity}.id`) + // eslint-disable-next-line @typescript-eslint/no-misused-promises + .where(buildFindFilter({ templateId }, TableName.IdentityLdapAuth)) + .select( + db.ref("identityId").withSchema(TableName.IdentityLdapAuth), + db.ref("name").withSchema(TableName.Identity).as("identityName") + ); + const docs = await query; + return docs; + default: + return []; + } + }; + + return { + ...identityAuthTemplateOrm, + findByOrgId, + findByAuthMethod, + findTemplateUsages + }; +}; diff --git a/backend/src/services/identity-auth-template/identity-auth-template-enums.ts b/backend/src/services/identity-auth-template/identity-auth-template-enums.ts new file mode 100644 index 000000000..163cd8fd1 --- /dev/null +++ b/backend/src/services/identity-auth-template/identity-auth-template-enums.ts @@ -0,0 +1,19 @@ +export enum IdentityAuthTemplateMethod { + LDAP = "ldap" +} + +export const TEMPLATE_VALIDATION_MESSAGES = { + TEMPLATE_NAME_REQUIRED: "Template name is required", + AUTH_METHOD_REQUIRED: "Auth method is required", + TEMPLATE_ID_REQUIRED: "Template ID is required", + LDAP_URL_REQUIRED: "LDAP URL is required", + BIND_DN_REQUIRED: "Bind DN is required", + BIND_PASSWORD_REQUIRED: "Bind password is required", + SEARCH_BASE_REQUIRED: "Search base is required" +} as const; + +export const TEMPLATE_SUCCESS_MESSAGES = { + CREATED: "Template created successfully", + UPDATED: "Template updated successfully", + DELETED: "Template deleted successfully" +} as const; diff --git a/backend/src/services/identity-auth-template/identity-auth-template-service.ts b/backend/src/services/identity-auth-template/identity-auth-template-service.ts new file mode 100644 index 000000000..0873efc96 --- /dev/null +++ b/backend/src/services/identity-auth-template/identity-auth-template-service.ts @@ -0,0 +1,406 @@ +import { ForbiddenError } from "@casl/ability"; + +import { TLicenseServiceFactory } from "@app/ee/services/license/license-service"; +import { + OrgPermissionMachineIdentityAuthTemplateActions, + OrgPermissionSubjects +} from "@app/ee/services/permission/org-permission"; +import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types"; +import { BadRequestError, NotFoundError } from "@app/lib/errors"; +import { TOrgPermission } from "@app/lib/types"; + +import { TIdentityLdapAuthDALFactory } from "../identity-ldap-auth/identity-ldap-auth-dal"; +import { TKmsServiceFactory } from "../kms/kms-service"; +import { KmsDataKey } from "../kms/kms-types"; +import { TIdentityAuthTemplateDALFactory } from "./identity-auth-template-dal"; +import { IdentityAuthTemplateMethod } from "./identity-auth-template-enums"; +import { + TDeleteIdentityAuthTemplateDTO, + TFindTemplateUsagesDTO, + TGetIdentityAuthTemplateDTO, + TGetTemplatesByAuthMethodDTO, + TLdapTemplateFields, + TListIdentityAuthTemplatesDTO, + TUnlinkTemplateUsageDTO +} from "./identity-auth-template-types"; + +type TIdentityAuthTemplateServiceFactoryDep = { + identityAuthTemplateDAL: TIdentityAuthTemplateDALFactory; + identityLdapAuthDAL: TIdentityLdapAuthDALFactory; + permissionService: Pick; + kmsService: Pick; + licenseService: Pick; +}; + +export type TIdentityAuthTemplateServiceFactory = ReturnType; + +export const identityAuthTemplateServiceFactory = ({ + identityAuthTemplateDAL, + identityLdapAuthDAL, + permissionService, + kmsService, + licenseService +}: TIdentityAuthTemplateServiceFactoryDep) => { + // Plan check + const $checkPlan = async (orgId: string) => { + const plan = await licenseService.getPlan(orgId); + if (!plan.machineIdentityAuthTemplates) + throw new BadRequestError({ + message: + "Failed to use identity auth template due to plan restriction. Upgrade plan to access machine identity auth templates." + }); + }; + const createTemplate = async ({ + name, + authMethod, + templateFields, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: { + name: string; + authMethod: string; + templateFields: Record; + } & Omit) => { + await $checkPlan(actorOrgId); + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + actorOrgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.CreateTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const { encryptor } = await kmsService.createCipherPairWithDataKey({ + type: KmsDataKey.Organization, + orgId: actorOrgId + }); + const template = await identityAuthTemplateDAL.create({ + name, + authMethod, + templateFields: encryptor({ plainText: Buffer.from(JSON.stringify(templateFields)) }).cipherTextBlob, + orgId: actorOrgId + }); + + return template; + }; + + const updateTemplate = async ({ + templateId, + name, + templateFields, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: { + templateId: string; + name?: string; + templateFields?: Record; + } & Omit) => { + await $checkPlan(actorOrgId); + const template = await identityAuthTemplateDAL.findById(templateId); + if (!template) { + throw new NotFoundError({ message: "Template not found" }); + } + + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + template.orgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.EditTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const { encryptor } = await kmsService.createCipherPairWithDataKey({ + type: KmsDataKey.Organization, + orgId: template.orgId + }); + + const updatedTemplate = await identityAuthTemplateDAL.transaction(async (tx) => { + const authTemplate = await identityAuthTemplateDAL.updateById( + templateId, + { + name, + ...(templateFields && { + templateFields: encryptor({ plainText: Buffer.from(JSON.stringify(templateFields)) }).cipherTextBlob + }) + }, + tx + ); + + if (templateFields && template.authMethod === IdentityAuthTemplateMethod.LDAP) { + const { decryptor } = await kmsService.createCipherPairWithDataKey({ + type: KmsDataKey.Organization, + orgId: template.orgId + }); + + const currentTemplateFields = JSON.parse( + decryptor({ cipherTextBlob: template.templateFields }).toString() + ) as TLdapTemplateFields; + + const mergedTemplateFields: TLdapTemplateFields = { ...currentTemplateFields, ...templateFields }; + + const ldapUpdateData: { + url?: string; + searchBase?: string; + encryptedBindDN?: Buffer; + encryptedBindPass?: Buffer; + } = {}; + + if ("url" in templateFields) { + ldapUpdateData.url = mergedTemplateFields.url; + } + if ("searchBase" in templateFields) { + ldapUpdateData.searchBase = mergedTemplateFields.searchBase; + } + if ("bindDN" in templateFields) { + ldapUpdateData.encryptedBindDN = encryptor({ + plainText: Buffer.from(mergedTemplateFields.bindDN) + }).cipherTextBlob; + } + if ("bindPass" in templateFields) { + ldapUpdateData.encryptedBindPass = encryptor({ + plainText: Buffer.from(mergedTemplateFields.bindPass) + }).cipherTextBlob; + } + + if (Object.keys(ldapUpdateData).length > 0) { + await identityLdapAuthDAL.update({ templateId }, ldapUpdateData, tx); + } + } + + return authTemplate; + }); + + return updatedTemplate; + }; + + const deleteTemplate = async ({ + templateId, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: TDeleteIdentityAuthTemplateDTO) => { + await $checkPlan(actorOrgId); + const template = await identityAuthTemplateDAL.findById(templateId); + if (!template) { + throw new NotFoundError({ message: "Template not found" }); + } + + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + template.orgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.DeleteTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const deletedTemplate = await identityAuthTemplateDAL.transaction(async (tx) => { + // Remove template reference from identityLdapAuth records + await identityLdapAuthDAL.update({ templateId }, { templateId: null }, tx); + + // Delete the template + const [deletedTpl] = await identityAuthTemplateDAL.delete({ id: templateId }, tx); + return deletedTpl; + }); + + return deletedTemplate; + }; + + const getTemplate = async ({ + templateId, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: TGetIdentityAuthTemplateDTO) => { + await $checkPlan(actorOrgId); + const template = await identityAuthTemplateDAL.findById(templateId); + if (!template) { + throw new NotFoundError({ message: "Template not found" }); + } + + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + template.orgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const { decryptor } = await kmsService.createCipherPairWithDataKey({ + type: KmsDataKey.Organization, + orgId: actorOrgId + }); + const decryptedTemplateFields = decryptor({ cipherTextBlob: template.templateFields }).toString(); + return { + ...template, + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + templateFields: JSON.parse(decryptedTemplateFields.toString()) + }; + }; + + const listTemplates = async ({ + limit, + offset, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: TListIdentityAuthTemplatesDTO) => { + await $checkPlan(actorOrgId); + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + actorOrgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const { docs, totalCount } = await identityAuthTemplateDAL.findByOrgId(actorOrgId, { limit, offset }); + + const { decryptor } = await kmsService.createCipherPairWithDataKey({ + type: KmsDataKey.Organization, + orgId: actorOrgId + }); + return { + totalCount, + templates: docs.map((doc) => ({ + ...doc, + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + templateFields: JSON.parse(decryptor({ cipherTextBlob: doc.templateFields }).toString()) + })) + }; + }; + + const getTemplatesByAuthMethod = async ({ + authMethod, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: TGetTemplatesByAuthMethodDTO) => { + await $checkPlan(actorOrgId); + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + actorOrgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const docs = await identityAuthTemplateDAL.findByAuthMethod(authMethod, actorOrgId); + + const { decryptor } = await kmsService.createCipherPairWithDataKey({ + type: KmsDataKey.Organization, + orgId: actorOrgId + }); + return docs.map((doc) => ({ + ...doc, + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + templateFields: JSON.parse(decryptor({ cipherTextBlob: doc.templateFields }).toString()) + })); + }; + + const findTemplateUsages = async ({ + templateId, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: TFindTemplateUsagesDTO) => { + await $checkPlan(actorOrgId); + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + actorOrgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const template = await identityAuthTemplateDAL.findById(templateId); + if (!template) { + throw new NotFoundError({ message: "Template not found" }); + } + + const docs = await identityAuthTemplateDAL.findTemplateUsages(templateId, template.authMethod); + return docs; + }; + + const unlinkTemplateUsage = async ({ + templateId, + identityIds, + actorId, + actorAuthMethod, + actor, + actorOrgId + }: TUnlinkTemplateUsageDTO) => { + await $checkPlan(actorOrgId); + const { permission } = await permissionService.getOrgPermission( + actor, + actorId, + actorOrgId, + actorAuthMethod, + actorOrgId + ); + ForbiddenError.from(permission).throwUnlessCan( + OrgPermissionMachineIdentityAuthTemplateActions.ListTemplates, + OrgPermissionSubjects.MachineIdentityAuthTemplate + ); + + const template = await identityAuthTemplateDAL.findById(templateId); + if (!template) { + throw new NotFoundError({ message: "Template not found" }); + } + + switch (template.authMethod) { + case IdentityAuthTemplateMethod.LDAP: + await identityLdapAuthDAL.update({ $in: { identityId: identityIds }, templateId }, { templateId: null }); + break; + default: + break; + } + }; + + return { + createTemplate, + updateTemplate, + deleteTemplate, + getTemplate, + listTemplates, + getTemplatesByAuthMethod, + findTemplateUsages, + unlinkTemplateUsage + }; +}; diff --git a/backend/src/services/identity-auth-template/identity-auth-template-types.ts b/backend/src/services/identity-auth-template/identity-auth-template-types.ts new file mode 100644 index 000000000..2472edec6 --- /dev/null +++ b/backend/src/services/identity-auth-template/identity-auth-template-types.ts @@ -0,0 +1,59 @@ +import { TProjectPermission } from "@app/lib/types"; + +import { IdentityAuthTemplateMethod } from "./identity-auth-template-enums"; + +// Method-specific template field types +export type TLdapTemplateFields = { + url: string; + bindDN: string; + bindPass: string; + searchBase: string; +}; + +// Union type for all template field types +export type TTemplateFieldsByMethod = { + [IdentityAuthTemplateMethod.LDAP]: TLdapTemplateFields; +}; + +// Generic base types that use conditional types for type safety +export type TCreateIdentityAuthTemplateDTO = { + name: string; + authMethod: T; + templateFields: TTemplateFieldsByMethod[T]; +} & Omit; + +export type TUpdateIdentityAuthTemplateDTO = { + templateId: string; + name?: string; + templateFields?: Partial; +} & Omit; + +export type TDeleteIdentityAuthTemplateDTO = { + templateId: string; +} & Omit; + +export type TGetIdentityAuthTemplateDTO = { + templateId: string; +} & Omit; + +export type TListIdentityAuthTemplatesDTO = { + limit?: number; + offset?: number; +} & Omit; + +export type TGetTemplatesByAuthMethodDTO = { + authMethod: string; +} & Omit; + +export type TFindTemplateUsagesDTO = { + templateId: string; +} & Omit; + +export type TUnlinkTemplateUsageDTO = { + templateId: string; + identityIds: string[]; +} & Omit; + +// Specific LDAP types for convenience +export type TCreateLdapTemplateDTO = TCreateIdentityAuthTemplateDTO; +export type TUpdateLdapTemplateDTO = TUpdateIdentityAuthTemplateDTO; diff --git a/backend/src/services/identity-auth-template/index.ts b/backend/src/services/identity-auth-template/index.ts new file mode 100644 index 000000000..4358d1a27 --- /dev/null +++ b/backend/src/services/identity-auth-template/index.ts @@ -0,0 +1,6 @@ +export type { TIdentityAuthTemplateDALFactory } from "./identity-auth-template-dal"; +export { identityAuthTemplateDALFactory } from "./identity-auth-template-dal"; +export * from "./identity-auth-template-enums"; +export type { TIdentityAuthTemplateServiceFactory } from "./identity-auth-template-service"; +export { identityAuthTemplateServiceFactory } from "./identity-auth-template-service"; +export type * from "./identity-auth-template-types"; diff --git a/backend/src/services/identity-ldap-auth/identity-ldap-auth-service.ts b/backend/src/services/identity-ldap-auth/identity-ldap-auth-service.ts index 399ef7da9..ddb4a0e66 100644 --- a/backend/src/services/identity-ldap-auth/identity-ldap-auth-service.ts +++ b/backend/src/services/identity-ldap-auth/identity-ldap-auth-service.ts @@ -20,6 +20,7 @@ import { TIdentityDALFactory } from "../identity/identity-dal"; import { TIdentityOrgDALFactory } from "../identity/identity-org-dal"; import { TIdentityAccessTokenDALFactory } from "../identity-access-token/identity-access-token-dal"; import { TIdentityAccessTokenJwtPayload } from "../identity-access-token/identity-access-token-types"; +import { TIdentityAuthTemplateDALFactory } from "../identity-auth-template"; import { TKmsServiceFactory } from "../kms/kms-service"; import { KmsDataKey } from "../kms/kms-types"; import { validateIdentityUpdateForSuperAdminPrivileges } from "../super-admin/super-admin-fns"; @@ -44,6 +45,7 @@ type TIdentityLdapAuthServiceFactoryDep = { permissionService: Pick; kmsService: TKmsServiceFactory; identityDAL: TIdentityDALFactory; + identityAuthTemplateDAL: TIdentityAuthTemplateDALFactory; }; export type TIdentityLdapAuthServiceFactory = ReturnType; @@ -55,7 +57,8 @@ export const identityLdapAuthServiceFactory = ({ identityOrgMembershipDAL, licenseService, permissionService, - kmsService + kmsService, + identityAuthTemplateDAL }: TIdentityLdapAuthServiceFactoryDep) => { const getLdapConfig = async (identityId: string) => { const identity = await identityDAL.findOne({ id: identityId }); @@ -173,6 +176,7 @@ export const identityLdapAuthServiceFactory = ({ const attachLdapAuth = async ({ identityId, + templateId, url, searchBase, searchFilter, @@ -241,13 +245,36 @@ export const identityLdapAuthServiceFactory = ({ if (allowedFields) AllowedFieldsSchema.array().parse(allowedFields); const identityLdapAuth = await identityLdapAuthDAL.transaction(async (tx) => { - const { encryptor } = await kmsService.createCipherPairWithDataKey({ + const { encryptor, decryptor } = await kmsService.createCipherPairWithDataKey({ type: KmsDataKey.Organization, orgId: identityMembershipOrg.orgId }); + const template = templateId ? await identityAuthTemplateDAL.findById(templateId) : undefined; + + let ldapConfig: { bindDN: string; bindPass: string; searchBase: string; url: string }; + if (template) { + ldapConfig = JSON.parse(decryptor({ cipherTextBlob: template.templateFields }).toString()); + } else { + if (!bindDN || !bindPass || !searchBase || !url) { + throw new BadRequestError({ + message: "Invalid request. Missing bind DN, bind pass, search base, or URL." + }); + } + ldapConfig = { + bindDN, + bindPass, + searchBase, + url + }; + } + const { cipherTextBlob: encryptedBindPass } = encryptor({ - plainText: Buffer.from(bindPass) + plainText: Buffer.from(ldapConfig.bindPass) + }); + + const { cipherTextBlob: encryptedBindDN } = encryptor({ + plainText: Buffer.from(ldapConfig.bindDN) }); let encryptedLdapCaCertificate: Buffer | undefined; @@ -259,15 +286,11 @@ export const identityLdapAuthServiceFactory = ({ encryptedLdapCaCertificate = encryptedCertificate; } - const { cipherTextBlob: encryptedBindDN } = encryptor({ - plainText: Buffer.from(bindDN) - }); - const isConnected = await testLDAPConfig({ - bindDN, - bindPass, + bindDN: ldapConfig.bindDN, + bindPass: ldapConfig.bindPass, caCert: ldapCaCertificate || "", - url + url: ldapConfig.url }); if (!isConnected) { @@ -282,15 +305,16 @@ export const identityLdapAuthServiceFactory = ({ identityId: identityMembershipOrg.identityId, encryptedBindDN, encryptedBindPass, - searchBase, + searchBase: ldapConfig.searchBase, searchFilter, - url, + url: ldapConfig.url, encryptedLdapCaCertificate, accessTokenMaxTTL, accessTokenTTL, accessTokenNumUsesLimit, accessTokenTrustedIps: JSON.stringify(reformattedAccessTokenTrustedIps), - allowedFields: allowedFields ? JSON.stringify(allowedFields) : undefined + allowedFields: allowedFields ? JSON.stringify(allowedFields) : undefined, + templateId }, tx ); @@ -301,6 +325,7 @@ export const identityLdapAuthServiceFactory = ({ const updateLdapAuth = async ({ identityId, + templateId, url, searchBase, searchFilter, @@ -371,15 +396,34 @@ export const identityLdapAuthServiceFactory = ({ if (allowedFields) AllowedFieldsSchema.array().parse(allowedFields); - const { encryptor } = await kmsService.createCipherPairWithDataKey({ + const { encryptor, decryptor } = await kmsService.createCipherPairWithDataKey({ type: KmsDataKey.Organization, orgId: identityMembershipOrg.orgId }); + const template = templateId ? await identityAuthTemplateDAL.findById(templateId) : undefined; + let config: { + bindDN?: string; + bindPass?: string; + searchBase?: string; + url?: string; + }; + + if (template) { + config = JSON.parse(decryptor({ cipherTextBlob: template.templateFields }).toString()); + } else { + config = { + bindDN, + bindPass, + searchBase, + url + }; + } + let encryptedBindPass: Buffer | undefined; - if (bindPass) { + if (config.bindPass) { const { cipherTextBlob: bindPassCiphertext } = encryptor({ - plainText: Buffer.from(bindPass) + plainText: Buffer.from(config.bindPass) }); encryptedBindPass = bindPassCiphertext; @@ -395,9 +439,9 @@ export const identityLdapAuthServiceFactory = ({ } let encryptedBindDN: Buffer | undefined; - if (bindDN) { + if (config.bindDN) { const { cipherTextBlob: bindDNCiphertext } = encryptor({ - plainText: Buffer.from(bindDN) + plainText: Buffer.from(config.bindDN) }); encryptedBindDN = bindDNCiphertext; @@ -406,10 +450,10 @@ export const identityLdapAuthServiceFactory = ({ const { ldapConfig } = await getLdapConfig(identityId); const isConnected = await testLDAPConfig({ - bindDN: bindDN || ldapConfig.bindDN, - bindPass: bindPass || ldapConfig.bindPass, + bindDN: config.bindDN || ldapConfig.bindDN, + bindPass: config.bindPass || ldapConfig.bindPass, caCert: ldapCaCertificate || ldapConfig.caCert, - url: url || ldapConfig.url + url: config.url || ldapConfig.url }); if (!isConnected) { @@ -420,14 +464,15 @@ export const identityLdapAuthServiceFactory = ({ } const updatedLdapAuth = await identityLdapAuthDAL.updateById(identityLdapAuth.id, { - url, - searchBase, + url: config.url, + searchBase: config.searchBase, searchFilter, encryptedBindDN, encryptedBindPass, encryptedLdapCaCertificate, allowedFields: allowedFields ? JSON.stringify(allowedFields) : undefined, accessTokenMaxTTL, + templateId: template?.id || null, accessTokenTTL, accessTokenNumUsesLimit, accessTokenTrustedIps: reformattedAccessTokenTrustedIps diff --git a/backend/src/services/identity-ldap-auth/identity-ldap-auth-types.ts b/backend/src/services/identity-ldap-auth/identity-ldap-auth-types.ts index 0e6feb5fb..8629763bb 100644 --- a/backend/src/services/identity-ldap-auth/identity-ldap-auth-types.ts +++ b/backend/src/services/identity-ldap-auth/identity-ldap-auth-types.ts @@ -14,11 +14,12 @@ export type TAllowedFields = z.infer; export type TAttachLdapAuthDTO = { identityId: string; - url: string; - searchBase: string; + templateId?: string; + url?: string; + searchBase?: string; searchFilter: string; - bindDN: string; - bindPass: string; + bindDN?: string; + bindPass?: string; ldapCaCertificate?: string; allowedFields?: TAllowedFields[]; accessTokenTTL: number; @@ -30,6 +31,7 @@ export type TAttachLdapAuthDTO = { export type TUpdateLdapAuthDTO = { identityId: string; + templateId?: string; url?: string; searchBase?: string; searchFilter?: string; diff --git a/docs/docs.json b/docs/docs.json index 4459a67de..3d6d1daaf 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -291,6 +291,7 @@ { "group": "Machine Identities", "pages": [ + "documentation/platform/identities/auth-templates", "documentation/platform/identities/alicloud-auth", "documentation/platform/identities/aws-auth", "documentation/platform/identities/azure-auth", diff --git a/docs/documentation/platform/identities/auth-templates.mdx b/docs/documentation/platform/identities/auth-templates.mdx new file mode 100644 index 000000000..0052e524a --- /dev/null +++ b/docs/documentation/platform/identities/auth-templates.mdx @@ -0,0 +1,98 @@ +--- +title: "Machine Identity Auth Templates" +description: "Learn how to use auth templates to standardize authentication configurations for machine identities." +--- + +## Concept + +Machine Identity Auth Templates allow you to create reusable authentication configurations that can be applied across multiple machine identities. This feature helps standardize authentication setups, reduces configuration drift, and simplifies identity management at scale. + +Instead of manually configuring authentication settings for each identity, you can create templates with predefined authentication parameters and apply them to multiple identities. This ensures consistency and reduces the likelihood of configuration errors. + +Key Benefits: + +- **Standardization**: Ensure consistent authentication configurations across identities +- **Efficiency**: Reduce time spent configuring individual identities +- **Governance**: Centrally manage and update authentication parameters +- **Scalability**: Easily apply proven configurations to new identities + +## Managing Auth Templates + +Auth templates are managed in **Organization Settings > Access Control > Identities** under the **Identity Auth Templates** section. + +![Identity Auth Templates Section](/images/platform/identities/auth-templates/templates-section.png) + +### Creating a Template + + + + In your organization settings, go to **Access Control > Identities** and scroll down to the **Identity Auth Templates** section. + + + + Click **Create Template** to open the template creation modal. + + ![Create Template Button](/images/platform/identities/auth-templates/create-template-button.png) + + Select the authentication method you want to create a template for (currently supports LDAP Auth). + + + + Fill in the template configuration based on your chosen authentication method. + + + + **For LDAP Auth templates**, configure the following fields: + + ![LDAP Auth Template](/images/platform/identities/auth-templates/ldap-template.png) + + - **Template Name**: A descriptive name for your template + - **URL**: The LDAP server to connect to such as `ldap://ldap.your-org.com`, `ldaps://ldap.myorg.com:636` _(for connection over SSL/TLS)_, etc. + - **Bind DN**: The DN to bind to the LDAP server with. + - **Bind Pass**: The password to bind to the LDAP server with. + - **Search Base / DN**: Base DN under which to perform user search such as `ou=Users,dc=acme,dc=com`. + - **User Search Filter**: Template used to construct the LDAP user search filter such as `(uid={{username}})`; use literal `{{username}}` to have the given username used in the search. The default is `(uid={{username}})` which is compatible with several common directory schemas. + - **Required Attributes**: A key/value pair of attributes that must be present in the LDAP user entry for them to be authenticated. As an example, if you set key `uid` to value `user1,user2,user3`, then only users with `uid` of `user1`, `user2`, or `user3` will be able to login with this identity. Each value is a comma separated list of attributes. + - **CA Certificate**: The CA certificate to use when verifying the LDAP server certificate. This field is optional but recommended. + + + You can read more about LDAP Auth configuration in the [LDAP Auth documentation](/documentation/platform/identities/ldap-auth/general). + + + + + + +### Using Templates + +Once created, templates can be applied when configuring authentication methods for machine identities. When adding an auth method to an identity, you'll have the option to select from available templates or configure manually. + +### Managing Template Usage + +You can view which identities are using a specific template by clicking **View Usages** in the template's dropdown menu. This allows you to: + +![Template Usages](/images/platform/identities/auth-templates/template-usages.png) +![Template Usages Modal](/images/platform/identities/auth-templates/template-usages-modal.png) + +- See all identities currently using the template +- Unlink identities from the template + +## FAQ + + + + Yes, you can edit existing templates. After editing a template, changes to templates will automatically update identities that are already using them. + + + + If you delete a template that's currently being used by identities, those identities will continue to function with their existing configuration. + + + + Yes, click **View Usages** in the template's dropdown menu to see all identities currently using that template. You can also unlink identities from templates from this view. + + + + Currently, auth templates support LDAP Auth. Support for additional authentication methods will be added in future releases. + + \ No newline at end of file diff --git a/docs/images/platform/identities/auth-templates/create-template-button.png b/docs/images/platform/identities/auth-templates/create-template-button.png new file mode 100644 index 0000000000000000000000000000000000000000..859031ea3a36e2dc898516ae35f734dbe9a5ad82 GIT binary patch literal 696497 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%0A*cJd2Gwi#$-v6jcp;lDKVEgRcQcui5`|bm) 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

ttmi|v>FQ50%WVRqwS9rH^Ne|ujbE{*Sv`g2 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%0A77}Ei8Z(3p1dKe=>nU3qwE`Gbx$kAF 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�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