Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
fix templated permissions
Thiago Araujo da Silva3ef61212a0a7
diff --git a/backend/src/ee/services/permission/actor-grant-abilities.test.ts b/backend/src/ee/services/permission/actor-grant-abilities.test.tsindex 78dc696a0f..b462448830 100644--- a/backend/src/ee/services/permission/actor-grant-abilities.test.ts+++ b/backend/src/ee/services/permission/actor-grant-abilities.test.ts@@ -1,11 +1,12 @@import { packRules } from "@casl/ability/extra";import { vi } from "vitest";-import { AccessScope, OrgMembershipRole } from "@app/db/schemas";+import { AccessScope, OrgMembershipRole, ProjectMembershipRole, ProjectType } from "@app/db/schemas";import { ActorType } from "@app/services/auth/auth-type";import { OrgPermissionIdentityActions, OrgPermissionSubjects } from "./org-permission";import { permissionServiceFactory } from "./permission-service";+import { ProjectPermissionActions, ProjectPermissionSub } from "./project-permission";// Privilege boundaries compare the actor against every grant the target holds. An additional// privilege carries a raw permission blob and no role slug, so a resolver that walked only@@ -16,17 +17,17 @@ const ELEVATED_PRIVILEGE = packRules([{ subject: OrgPermissionSubjects.Identity, action: [OrgPermissionIdentityActions.EditAuth] }]);-const createService = (memberships: unknown[]) => {+const createService = (memberships: unknown[], customRoles: unknown[] = []) => {const permissionDAL = { getPermission: vi.fn().mockResolvedValue(memberships) };const service = permissionServiceFactory({permissionDAL,- roleDAL: { find: vi.fn().mockResolvedValue([]) },- projectDAL: {} as never,+ roleDAL: { find: vi.fn().mockResolvedValue(customRoles) },+ projectDAL: { findById: vi.fn().mockResolvedValue({ id: "project-1", type: ProjectType.SecretManager }) },serviceTokenDAL: {} as never,keyStore: {} as never,userDAL: {} as never,- identityDAL: {} as never,+ identityDAL: { findById: vi.fn().mockResolvedValue({ id: "identity-1", name: "target-identity" }) },additionalPrivilegeDAL: {} as never,groupDAL: {} as never,secretFolderDAL: {} as never@@ -36,6 +37,10 @@ const createService = (memberships: unknown[]) => {};const orgScope = { scope: AccessScope.Organization, orgId: "org-1" } as const;+const projectScope = { scope: AccessScope.Project, orgId: "org-1", projectId: "project-1" } as const;++const secretReadConditions = (grants: { permission: { rules: { conditions?: unknown }[] } }[]) =>+ grants.flatMap((grant) => grant.permission.rules.map((rule) => rule.conditions).filter(Boolean));describe("getActorGrantAbilities", () => {test("returns one ability per role the target holds", async () => {@@ -117,3 +122,107 @@ describe("getActorGrantAbilities", () => {expect(grants).toHaveLength(1);});});++// The boundary these grants feed measures them against a caller whose own rules getProjectPermission+// already rendered. A target left on its raw template is compared as the literal string+// "{{identity.id}}", so two principals holding the very same role read as unrelated and the caller is+// refused. `identity.auth` is the one context that stays raw: it lives on the credential the target+// authenticates with, and rendering it against nothing would empty the condition out.++const TEAM_SCOPED_READ = packRules([+ {+ subject: ProjectPermissionSub.Secrets,+ action: [ProjectPermissionActions.Read],+ conditions: { secretPath: { $glob: "/{{identity.metadata.team}}/**" }, environment: "{{identity.username}}" }+ }+]);++const AUTH_SCOPED_READ = packRules([+ {+ subject: ProjectPermissionSub.Secrets,+ action: [ProjectPermissionActions.Read],+ conditions: { secretPath: { $glob: "/{{identity.auth.kubernetes.namespace}}/**" } }+ }+]);++describe("getActorGrantAbilities identity templates", () => {+ test("a role's templates are rendered from the target's own context", async () => {+ const { service } = createService(+ [+ {+ roles: [{ role: ProjectMembershipRole.Custom, customRoleSlug: "team-scoped" }],+ additionalPrivileges: [],+ metadata: [{ id: "m1", key: "team", value: "backend" }]+ }+ ],+ [{ slug: "team-scoped", name: "team-scoped", permissions: TEAM_SCOPED_READ }]+ );++ const grants = await service.getActorGrantAbilities({+ scopeData: projectScope,+ actorId: "identity-1",+ actorType: ActorType.IDENTITY+ });++ expect(secretReadConditions(grants)).toContainEqual({+ secretPath: { $glob: "/backend/**" },+ environment: "target-identity"+ });+ });++ test("an additional privilege's templates are rendered too", async () => {+ const { service } = createService([+ {+ roles: [],+ additionalPrivileges: [{ permissions: TEAM_SCOPED_READ }],+ metadata: [{ id: "m1", key: "team", value: "backend" }]+ }+ ]);++ const grants = await service.getActorGrantAbilities({+ scopeData: projectScope,+ actorId: "identity-1",+ actorType: ActorType.IDENTITY+ });++ expect(secretReadConditions(grants)).toContainEqual({+ secretPath: { $glob: "/backend/**" },+ environment: "target-identity"+ });+ });++ test("a metadata key the target does not carry stays a template", async () => {+ const { service } = createService(+ [{ roles: [{ role: ProjectMembershipRole.Custom, customRoleSlug: "team-scoped" }], additionalPrivileges: [] }],+ [{ slug: "team-scoped", name: "team-scoped", permissions: TEAM_SCOPED_READ }]+ );++ const grants = await service.getActorGrantAbilities({+ scopeData: projectScope,+ actorId: "identity-1",+ actorType: ActorType.IDENTITY+ });++ expect(secretReadConditions(grants)).toContainEqual({+ secretPath: { $glob: "/{{identity.metadata.team}}/**" },+ environment: "target-identity"+ });+ });++ test("an identity.auth template is left unrendered", async () => {+ const { service } = createService(+ [{ roles: [{ role: ProjectMembershipRole.Custom, customRoleSlug: "auth-scoped" }], additionalPrivileges: [] }],+ [{ slug: "auth-scoped", name: "auth-scoped", permissions: AUTH_SCOPED_READ }]+ );++ const grants = await service.getActorGrantAbilities({+ scopeData: projectScope,+ actorId: "identity-1",+ actorType: ActorType.IDENTITY+ });++ expect(secretReadConditions(grants)).toContainEqual({+ secretPath: { $glob: "/{{identity.auth.kubernetes.namespace}}/**" }+ });+ });+});diff --git a/backend/src/ee/services/permission/permission-fns.ts b/backend/src/ee/services/permission/permission-fns.tsindex 0ed01138c9..269667a7da 100644--- a/backend/src/ee/services/permission/permission-fns.ts+++ b/backend/src/ee/services/permission/permission-fns.ts@@ -666,6 +666,24 @@ export const interpolatePermissionRules = <T>(rules: T[], identityContext: Recorreturn JSON.parse(templatedRules(identityContext, { data: false })) as T[];};+// `identity.auth.*` is read off the credential an identity authenticates with, so it is knowable only+// for the actor of the live request. Rendered against a context that lacks it, the mustache collapses to+// an empty string, and the condition it guarded turns into one nothing satisfies, which reads to a+// privilege boundary as a grant anybody outranks. Rules that reference it keep their mustaches instead,+// so they stay unsatisfiable on both sides of the comparison.+const AUTH_TEMPLATE_PATH = "identity.auth";++export const interpolateStoredIdentityRules = <T>(rules: T[], identityContext: Record<string, unknown>): T[] => {+ const serializedRules = JSON.stringify(rules);++ if (!serializedRules.includes("{{")) return rules;+ if (!serializedRules.includes(AUTH_TEMPLATE_PATH)) return interpolatePermissionRules(rules, identityContext);++ return rules.map((rule) =>+ JSON.stringify(rule).includes(AUTH_TEMPLATE_PATH) ? rule : interpolatePermissionRules([rule], identityContext)[0]+ );+};+export {assertRoleSetBoundary,constructPermissionErrorMessage,diff --git a/backend/src/ee/services/permission/permission-service.ts b/backend/src/ee/services/permission/permission-service.tsindex d0120e300b..1b52df23b0 100644--- a/backend/src/ee/services/permission/permission-service.ts+++ b/backend/src/ee/services/permission/permission-service.ts@@ -80,6 +80,7 @@ import {filterOverriddenFolderScopedDenyRules,getProjectPermissionFingerprint,interpolatePermissionRules,+ interpolateStoredIdentityRules,isActiveRole,validateOrgSSO} from "./permission-fns";@@ -1198,6 +1199,37 @@ export const permissionServiceFactory = ({return sources;};+ const $interpolateGrantsForActor = async (+ grants: MongoAbility[],+ memberships: Awaited<ReturnType<TPermissionDALFactory["getPermission"]>>,+ actorId: string,+ actorType: ActorType.USER | ActorType.IDENTITY+ ) => {+ const username =+ actorType === ActorType.USER+ ? (await requestMemoize(requestMemoKeys.userFindById(actorId), () => userDAL.findById(actorId)))?.username+ : (await requestMemoize(requestMemoKeys.identityFindById(actorId), () => identityDAL.findById(actorId)))?.name;++ const identityContext = {+ identity: {+ id: actorId,+ username: username ?? "",+ metadata: escapeHandlebarsMissingDict(+ objectify(+ memberships[0]?.metadata ?? [],+ (i) => i.key,+ (i) => i.value+ ),+ "identity.metadata"+ )+ }+ };++ return grants.map((grant) =>+ createMongoAbility(interpolateStoredIdentityRules(grant.rules, identityContext), { conditionsMatcher })+ );+ };+const getActorGrantAbilities: TPermissionServiceFactory["getActorGrantAbilities"] = async ({scopeData,actorId,@@ -1212,20 +1244,28 @@ export const permissionServiceFactory = ({: await getOrgPermissionByRoles(roleSlugs, scopeData.orgId, { ignoreUnresolvedRoles: true });const privilegePermissions = memberships.flatMap((membership) =>- (membership.additionalPrivileges ?? []).filter(isActiveRole).map(({ permissions }) => ({- permission: isProjectScope- ? createMongoAbility<ProjectPermissionSet>(- buildProjectPermissionRules([{ role: ProjectMembershipRole.Custom, permissions: permissions || [] }]),- { conditionsMatcher }- )- : createMongoAbility<OrgPermissionSet>(- buildOrgPermissionRules([{ role: OrgMembershipRole.Custom, permissions: permissions || [] }]),- { conditionsMatcher }- )- }))+ (membership.additionalPrivileges ?? [])+ .filter(isActiveRole)+ .map(({ permissions }) =>+ isProjectScope+ ? createMongoAbility<ProjectPermissionSet>(+ buildProjectPermissionRules([{ role: ProjectMembershipRole.Custom, permissions: permissions || [] }]),+ { conditionsMatcher }+ )+ : createMongoAbility<OrgPermissionSet>(+ buildOrgPermissionRules([{ role: OrgMembershipRole.Custom, permissions: permissions || [] }]),+ { conditionsMatcher }+ )+ ));- return [...rolePermissions.map(({ permission }) => ({ permission })), ...privilegePermissions];+ const grants: MongoAbility[] = [...rolePermissions.map(({ permission }) => permission), ...privilegePermissions];++ const isTemplated = grants.some((grant) => JSON.stringify(grant.rules).includes("{{"));+ if (!isTemplated) return grants.map((permission) => ({ permission }));++ const interpolatedGrants = await $interpolateGrantsForActor(grants, memberships, actorId, actorType);+ return interpolatedGrants.map((permission) => ({ permission }));};const getMembershipPermissionAudit: TPermissionServiceFactory["getMembershipPermissionAudit"] = async ({