/

CVE-2026-58410

Severity:

HIGH RISK

(7.1)

Broken Access Control (CWE-639) in ChurchCRM Family API

CVE-2026-58410

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-639, CWE-862

Impact:

Unauthorized Data Access and Modification

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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 familyId referencing another family's record.
  • Why exploitation is possible: The backend trusts the supplied familyId and 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.

Sources

SourceLink
github.comgithub.com/ChurchCRM/CRM/security/advisories/GHSA-jjcj-h3cm-p7x7

Frequently asked

questions

No, it does not directly allow full system takeover or code execution. It enables horizontal privilege escalation, letting a low-privileged user read and modify other families' records, which is serious from a privacy and integrity standpoint but remains within the application's data layer.

An attacker must have a valid authenticated ChurchCRM account with at least EditSelf permissions. If the same account also has Notes permission, the attacker can further create notes on other families' records.

The safest fix is to enforce object-level authorization on the server for every resource access. That means deriving "self" targets from session context, verifying that the requested familyId is associated with the current user or allowed scope, and centralizing these checks so they are consistently applied across all endpoints.

Prevention relies on designing APIs with strong server-side authorization that never trusts client-supplied identifiers alone. Adopting policy-based access control, performing regular security-focused code reviews, and adding automated tests for IDOR scenarios help ensure that each endpoint validates ownership and scope before returning or mutating data.

Find out what's already
exploitable in your codebase.