Skip to content

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

fix(insights): count readers who get the value through a group, with the group's access date

Dimitris Staratzis7232fbf3e406
diff --git a/backend/src/ee/services/secret-read-activity/secret-read-activity-dal.ts b/backend/src/ee/services/secret-read-activity/secret-read-activity-dal.ts
index 171c87caa1..cae7852146 100644
--- a/backend/src/ee/services/secret-read-activity/secret-read-activity-dal.ts
+++ b/backend/src/ee/services/secret-read-activity/secret-read-activity-dal.ts
@@ -135,41 +135,74 @@ export const secretReadActivityDALFactory = (db: TDbClient) => {
}
};
- // The last time each user or identity joined the project or had a role, privilege or folder grant created,
- // changed or expired, or had the rules of a custom role they hold edited. Which secrets a change opened up is
- // not recorded, so any of them restarts the window; an expired restrictive folder grant can restore access.
- // Membership updatedAt is left out because logins bump it.
+ type TAccessChange = {
+ actorUserId?: string | null;
+ actorIdentityId?: string | null;
+ groupMemberId?: string | null;
+ membershipCreatedAt?: Date | null;
+ createdAt: Date;
+ updatedAt: Date;
+ temporaryAccessEndTime?: Date | null;
+ customRoleUpdatedAt?: Date | null;
+ };
+
+ // The last time each user or identity joined the project or a group that is in it, or had a role, privilege or
+ // folder grant created, changed or expired, or had the rules of a custom role they hold edited. Which secrets a
+ // change opened up is not recorded, so any of them restarts the window; an expired restrictive folder grant can
+ // restore access. Membership updatedAt is left out because logins bump it.
const findAccessChangedAt = async (projectId: string, tx?: Knex) => {
try {
- const [roleChanges, privilegeChanges] = await Promise.all([
- (tx || db.replicaNode())(TableName.Membership)
+ const roleChanges = (qb: Knex.QueryBuilder) =>
+ qb
.join(TableName.MembershipRole, `${TableName.Membership}.id`, `${TableName.MembershipRole}.membershipId`)
.leftJoin(TableName.Role, `${TableName.MembershipRole}.customRoleId`, `${TableName.Role}.id`)
.where(`${TableName.Membership}.scope`, AccessScope.Project)
- .where(`${TableName.Membership}.scopeProjectId`, projectId)
- .select(
- db.ref("actorUserId").withSchema(TableName.Membership),
- db.ref("actorIdentityId").withSchema(TableName.Membership),
- db.ref("createdAt").withSchema(TableName.Membership).as("membershipCreatedAt"),
- db.ref("createdAt").withSchema(TableName.MembershipRole),
- db.ref("updatedAt").withSchema(TableName.MembershipRole),
- db.ref("temporaryAccessEndTime").withSchema(TableName.MembershipRole),
- db.ref("updatedAt").withSchema(TableName.Role).as("customRoleUpdatedAt")
- ),
+ .where(`${TableName.Membership}.scopeProjectId`, projectId);
+ const roleColumns = [
+ db.ref("createdAt").withSchema(TableName.MembershipRole),
+ db.ref("updatedAt").withSchema(TableName.MembershipRole),
+ db.ref("temporaryAccessEndTime").withSchema(TableName.MembershipRole),
+ db.ref("updatedAt").withSchema(TableName.Role).as("customRoleUpdatedAt")
+ ];
+ // A group's roles reach each of its members, from the day the member joined the group.
+ const groupRoleChanges = (
+ memberTable: TableName.UserGroupMembership | TableName.IdentityGroupMembership,
+ memberColumn: "userId" | "identityId"
+ ) =>
+ roleChanges(
+ (tx || db.replicaNode())(TableName.Membership).join(
+ memberTable,
+ `${TableName.Membership}.actorGroupId`,
+ `${memberTable}.groupId`
+ )
+ ).select(
+ db.ref(memberColumn).withSchema(memberTable).as("groupMemberId"),
+ db.ref("createdAt").withSchema(memberTable).as("membershipCreatedAt"),
+ ...roleColumns
+ );
+
+ const [directChanges, userGroupChanges, identityGroupChanges, privilegeChanges] = (await Promise.all([
+ roleChanges((tx || db.replicaNode())(TableName.Membership)).select(
+ db.ref("actorUserId").withSchema(TableName.Membership),
+ db.ref("actorIdentityId").withSchema(TableName.Membership),
+ db.ref("createdAt").withSchema(TableName.Membership).as("membershipCreatedAt"),
+ ...roleColumns
+ ),
+ groupRoleChanges(TableName.UserGroupMembership, "userId"),
+ groupRoleChanges(TableName.IdentityGroupMembership, "identityId"),
(tx || db.replicaNode())(TableName.AdditionalPrivilege)
.where({ projectId })
.select("actorUserId", "actorIdentityId", "createdAt", "updatedAt", "temporaryAccessEndTime")
- ]);
+ ])) as TAccessChange[][];
const now = new Date();
const changedAtByActorId = new Map<string, Date>();
- [...roleChanges, ...privilegeChanges].forEach((change) => {
- const actorId = change.actorUserId ?? change.actorIdentityId;
+ [...directChanges, ...userGroupChanges, ...identityGroupChanges, ...privilegeChanges].forEach((change) => {
+ const actorId = change.actorUserId ?? change.actorIdentityId ?? change.groupMemberId;
if (!actorId) return;
const dates = [change.createdAt, change.updatedAt];
- if ("membershipCreatedAt" in change) dates.push(change.membershipCreatedAt as Date);
- if ("customRoleUpdatedAt" in change && change.customRoleUpdatedAt)
- dates.push(change.customRoleUpdatedAt as Date);
+ if (change.membershipCreatedAt) dates.push(change.membershipCreatedAt);
+ if (change.customRoleUpdatedAt) dates.push(change.customRoleUpdatedAt);
if (change.temporaryAccessEndTime && new Date(change.temporaryAccessEndTime) <= now) {
dates.push(change.temporaryAccessEndTime);
}
diff --git a/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts b/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts
index d9ae6ed3a0..11ab6c165f 100644
--- a/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts
+++ b/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts
@@ -1,5 +1,7 @@
import { SecretType, TableName } from "@app/db/schemas";
import { DAY_IN_MS } from "@app/ee/services/audit-report/audit-report-fns";
+import { TIdentityGroupMembershipDALFactory } from "@app/ee/services/group/identity-group-membership-dal";
+import { TUserGroupMembershipDALFactory } from "@app/ee/services/group/user-group-membership-dal";
import { checkInsightsReadPermission } from "@app/ee/services/insights/insights-fns";
import {
hasSecretReadValueOrDescribePermission,
@@ -80,6 +82,8 @@ type TSecretReadActivityServiceFactoryDep = {
secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "find" | "findSecretReferencesByProjectId">;
userDAL: Pick<TUserDALFactory, "find">;
identityDAL: Pick<TIdentityDALFactory, "find">;
+ userGroupMembershipDAL: Pick<TUserGroupMembershipDALFactory, "find">;
+ identityGroupMembershipDAL: Pick<TIdentityGroupMembershipDALFactory, "find">;
kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
keyStore: Pick<TKeyStoreFactory, "setItemWithExpiry" | "getItem" | "ttl" | "acquireLock">;
};
@@ -97,6 +101,8 @@ export const secretReadActivityServiceFactory = ({
secretV2BridgeDAL,
userDAL,
identityDAL,
+ userGroupMembershipDAL,
+ identityGroupMembershipDAL,
kmsService,
keyStore
}: TSecretReadActivityServiceFactoryDep) => {
@@ -275,35 +281,71 @@ export const secretReadActivityServiceFactory = ({
// computed from those counts. In a project tracked for less than the window, the window starts when tracking
// did, so the results are preliminary.
const $loadSecretSummarizer = async (projectId: string, orgId: string, windowStart: Date) => {
- const [{ userPermissions, identityPermissions }, accessChangedAtByActorId, adminActorIds, { trackingStartedAt }] =
- await Promise.all([
- permissionService.getProjectPermissions(projectId, orgId),
- secretReadActivityDAL.findAccessChangedAt(projectId),
- secretReadActivityDAL.findAdminActorIds(projectId),
- $getProjectTrackingStartedAt(projectId)
- ]);
+ const [
+ { userPermissions, identityPermissions, groupPermissions },
+ accessChangedAtByActorId,
+ adminActorIds,
+ { trackingStartedAt }
+ ] = await Promise.all([
+ permissionService.getProjectPermissions(projectId, orgId),
+ secretReadActivityDAL.findAccessChangedAt(projectId),
+ secretReadActivityDAL.findAdminActorIds(projectId),
+ $getProjectTrackingStartedAt(projectId)
+ ]);
+ // The user and identity lists carry only direct members, so every group member is also checked with the
+ // group's permission; an actor who qualifies more than one way still counts once.
+ const groupIds = groupPermissions.map((group) => group.id);
+ const [userGroupMemberships, identityGroupMemberships] = await Promise.all([
+ groupIds.length ? userGroupMembershipDAL.find({ $in: { groupId: groupIds } }) : [],
+ groupIds.length ? identityGroupMembershipDAL.find({ $in: { groupId: groupIds } }) : []
+ ]);
+ const groupPermissionById = new Map(groupPermissions.map((group) => [group.id, group.permission]));
const judgedFrom = trackingStartedAt > windowStart ? trackingStartedAt : windowStart;
// How much of the window the reads cover, which weights the score's unused-access term and words it.
const trackedDays = (Date.now() - judgedFrom.getTime()) / DAY_IN_MS;
- const actors = [
+ type TActor = {
+ id: string;
+ name?: string;
+ actorType: TSecretReaderType;
+ permission: (typeof userPermissions)[number]["permission"];
+ };
+ const throughGroup = <T extends { groupId: string }>(
+ memberships: T[],
+ actorType: TSecretReaderType,
+ idOf: (membership: T) => string
+ ): TActor[] =>
+ memberships.flatMap((membership) => {
+ const permission = groupPermissionById.get(membership.groupId);
+ return permission ? [{ id: idOf(membership), actorType, permission }] : [];
+ });
+ const actors: TActor[] = [
...userPermissions.map((actor) => ({ ...actor, actorType: ActorType.USER as const })),
- ...identityPermissions.map((actor) => ({ ...actor, actorType: ActorType.IDENTITY as const }))
+ ...identityPermissions.map((actor) => ({ ...actor, actorType: ActorType.IDENTITY as const })),
+ ...throughGroup(userGroupMemberships, ActorType.USER, (membership) => membership.userId),
+ ...throughGroup(identityGroupMemberships, ActorType.IDENTITY, (membership) => membership.identityId)
];
// Actors with identical rules always get the same answer, so each distinct rule set is checked once.
const actorGroups = Object.values(groupBy(actors, (actor) => JSON.stringify(actor.permission.rules)));
- const actorNames = new Map(actors.map((actor) => [`${actor.actorType}:${actor.id}`, actor.name]));
+ const actorNames = new Map(
+ actors.flatMap((actor) => (actor.name ? [[`${actor.actorType}:${actor.id}`, actor.name] as const] : []))
+ );
const summarize = ({ secret, environment, secretPath, trackedSince, reads }: TSecretActivity) => {
- const entitled = actorGroups
- .filter(([{ permission }]) =>
- hasSecretReadValueOrDescribePermission(permission, ProjectPermissionSecretActions.ReadValue, {
- environment,
- secretPath,
- secretName: secret.key,
- secretTags: secret.tags?.map((tag) => tag.slug)
- })
- )
- .flat();
+ const entitled = [
+ ...new Map(
+ actorGroups
+ .filter(([{ permission }]) =>
+ hasSecretReadValueOrDescribePermission(permission, ProjectPermissionSecretActions.ReadValue, {
+ environment,
+ secretPath,
+ secretName: secret.key,
+ secretTags: secret.tags?.map((tag) => tag.slug)
+ })
+ )
+ .flat()
+ .map((actor) => [`${actor.actorType}:${actor.id}`, actor] as const)
+ ).values()
+ ];
const entitledKeys = new Set(entitled.map((actor) => `${actor.actorType}:${actor.id}`));
// Admins can read everything by design, so a secret is not exposed to them: they are left out of the counts and
// the score, though their reads still show, and a read of theirs is never a ghost's.
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 62f79851cd..592523872f 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -3536,6 +3536,8 @@ export const registerRoutes = async (
secretV2BridgeDAL,
userDAL,
identityDAL,
+ userGroupMembershipDAL,
+ identityGroupMembershipDAL,
kmsService,
keyStore
});