Skip to content

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

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.ts
index 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.ts
index 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: Recor
return 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.ts
index 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 ({