Summary
ChurchCRM contained a broken access control issue in its family-scoped endpoints that let low-privileged users read and modify records belonging to other families.
By supplying an arbitrary familyId, an authenticated user with EditSelf and optional Notes permissions could operate outside their intended family scope and access unrelated congregation data.
Affected context
This vulnerability appears in ChurchCRM's family-related backend endpoints that are designed to enforce "EditSelf" scoping.
It becomes relevant when a user is authenticated but intended to act only on their own family record, and the API relies on a client-provided familyId parameter to select which family entity to load.
In deployments where role and scope validation is not rechecked on the server for each requested entity, the system may inadvertently expose or allow changes to unrelated family records.
Exploit preconditions
- Attack surface: ChurchCRM web application family-scoped endpoints (e.g., update, view, and notes for family records).
- Required access: Valid authenticated non-admin ChurchCRM account with at least EditSelf permissions; Notes permission further extends impact to note creation.
- Trigger point: Sending requests that include an attacker-chosen
familyIdreferencing another family's record. - Why exploitation is possible: The backend trusts the supplied
familyIdand loads the corresponding family entity purely by ID, without confirming that the family belongs to the current user or that the user's scope permits access to that specific record.
Why this happens
The underlying flaw is a classic broken access control pattern where object-level authorization is not enforced for each requested resource.
The API implements a notion of "EditSelf" but relies on client-controlled identifiers (the familyId parameter) to determine the target object, assuming the client will only submit its own family ID.
This maps primarily to CWE-639: Insecure Direct Object Reference (IDOR), because access to specific records is granted based solely on IDs without verifying ownership or scope.
It is also related to CWE-862: Missing Authorization, as no additional permission checks are performed at the point where the family entity is loaded and manipulated.
Potential impact
- Unauthorized viewing of other families' personal and contact details.
- Unauthorized modification of other families' records, including profile and membership data.
- Creation of misleading or abusive notes on another family's record, altering institutional records.
- Privacy violations affecting members of the congregation whose data is improperly exposed.
- Increased risk of data integrity issues and audit trail confusion within the system.
General mitigation guidance
Effective mitigation centers on enforcing strict, server-side authorization at the object level, independent of client-supplied identifiers.
Common secure design patterns include:
- Validating that any requested entity (e.g., family record) is actually associated with the current user's scope or role before performing read or write operations.
- Deriving the target object for "self" operations from authenticated session or user context rather than accepting arbitrary IDs from the client.
- Implementing centralized authorization checks that consistently enforce role, scope, and ownership rules across all endpoints, including notes and auxiliary resources.
- Reducing reliance on coarse-grained permissions (like generic edit rights) by introducing resource-specific policies that constrain which records a user can access.
- Applying least-privilege principles so that standard users are limited to viewing and editing only their own records and strictly bounded related entities.
How teams detect issues like this
Organizations can spot similar access control weaknesses through a combination of code, configuration, and behavioral analysis:
- Static analysis or manual code review focused on endpoints that accept object identifiers (e.g.,
familyId) and checking that ownership or scope validation occurs after lookup and before use. - Reviewing controller and service methods for patterns like "load by ID and then act" without referencing a central authorization service or policy.
- Implementing security tests that attempt to access or modify records belonging to other users or families using valid but low-privileged accounts.
- Adding logging and monitoring for abnormal cross-tenant or cross-family access patterns, such as many distinct family IDs being accessed by the same low-privileged user.
- Using automated access control testing tools that exercise IDOR scenarios across all resource endpoints in the application.

