/

CVE-2026-44547

Severity:

CRITICAL RISK

(9.6)

Broken Authentication in ChurchCRM Public User API

CVE-2026-44547

Deferred

Vulnerability type

Category:

Broken Authentication

CWE:

CWE-287, CWE-304

Impact:

Unauthorized Access and Potential Account Compromise

Severity:

CRITICAL RISK

(9.6)

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

A regression in ChurchCRM's public user API left the fix for a previous authentication vulnerability (CVE-2026-4058) effectively undone in all 7.2.x releases.

As a result, the public endpoint remains exploitable using the original proof-of-concept, allowing unauthenticated or improperly authenticated access under conditions where the route is exposed.

Affected context

The issue affects ChurchCRM deployments running versions 7.2.0 through 7.2.2 that expose the src/api/routes/public/public-user.php endpoint.

It occurs specifically where the environment assumes that the hardening for CVE-2026-4058 is present and effective, but the actual shipped code lacks the intended authentication and verification logic due to a reverted or stripped commit.

Systems that rely on this public route for onboarding, self-service, or user discovery are at heightened risk if they implicitly trust its access control.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposing the ChurchCRM public user API (public-user.php).
  • Required access: Network access to the web application; in many deployments this may be over the internet.
  • Trigger point: Issuing crafted HTTP requests that follow the same pattern as the original CVE-2026-4058 proof-of-concept.
  • Why exploitation is possible: The hardening logic intended to enforce or strengthen authentication and/or request verification was removed before release, so the vulnerable behavior from the earlier advisory persists in all 7.2.x builds.

Why this happens

The underlying problem is a broken authentication control (CWE-287) at the public user API endpoint where requests are not consistently validated against a reliable authentication or session mechanism.

Additionally, the vulnerability reflects a failure to correctly preserve security-relevant state and fixes across releases (CWE-304), where a hardening commit was unintentionally stripped out by a subsequent pull request.

Abstractly, this pattern occurs when an application:

  • Relies on route-level checks for access decisions, but those checks are loosely enforced or easy to bypass, and
  • Lacks robust processes to prevent regressions in security-sensitive code paths, allowing previously fixed vulnerabilities to reappear in later builds.

Potential impact

  • Unauthenticated or weakly authenticated access to functionality intended for authenticated users
  • Exposure or enumeration of user-related data that should be access-controlled
  • Potential account takeover or unauthorized account creation, depending on the original CVE-2026-4058 behavior
  • Abuse of public-facing workflows (e.g., registration, invitations, or user lookup) for fraud or privacy violations
  • Loss of trust in the integrity and confidentiality of member or congregant records managed through ChurchCRM

General mitigation guidance

Mitigation efforts should focus on reinforcing authentication and preventing regressions in security-sensitive routes:

  • Centralize authentication and authorization checks in reusable middleware rather than duplicating them inside individual route handlers.
  • Ensure public endpoints explicitly define which operations are allowed without authentication and fail closed by default for all others.
  • Introduce strict checks for any token, link, or one-time code associated with public user flows, including expiration and binding to specific actions.
  • Apply defense-in-depth by limiting what data and operations are exposed through public APIs, even when authentication appears to succeed.
  • Adopt secure development practices that prevent accidental removal of security fixes, such as protected branches, mandatory security reviews, and regression tests covering known vulnerabilities.

How teams detect issues like this

Organizations can look for this class of issue using several complementary approaches:

  • Static analysis: Search for routes or controllers under public or similar namespaces that lack authentication middleware or session checks while performing sensitive operations.
  • Code review: During pull requests, verify that security hardening changes (especially those referencing prior CVEs) are not modified, reverted, or bypassed by new logic.
  • Security regression testing: Maintain automated tests that replay proof-of-concept scenarios from previous advisories to ensure fixes remain effective in future releases.
  • Runtime monitoring: Inspect web server logs for anomalous access patterns to public APIs, such as repeated access to public user routes from unknown clients or unexpected parameter combinations.

Sources

SourceLink
github.comgithub.com/ChurchCRM/CRM/pull/8855
github.comgithub.com/ChurchCRM/CRM/security/advisories/GHSA-cwp8-rm8g-q5c9

Frequently asked

questions

Yes, in typical deployments where ChurchCRM is accessible over the network and the affected public user API endpoint is exposed, an attacker can exploit the issue remotely by crafting HTTP requests similar to the original PoC.

The attacker generally needs only network-level access to the ChurchCRM instance. No prior authentication is required if the public endpoint is reachable and not protected by an external control such as a VPN, WAF, or reverse proxy ACL.

The safest pattern is to enforce robust, centralized authentication and authorization on all routes that handle user-related actions or data, and to ensure that security fixes are not route-local or easily bypassed. Additionally, embed regression tests and branch protection policies so that security hardening commits cannot be silently removed by later changes.

Prevention typically involves institutionalizing secure development practices: track CVE-related changes explicitly, require security-focused review for code touching authentication or public endpoints, maintain a regression test suite for historical vulnerabilities, and use automated tools to flag any route that exposes sensitive operations without explicit authentication and authorization checks.

Find out what's already
exploitable in your codebase.