/

CVE-2026-41660

Severity:

HIGH RISK

(7.1)

Authorization Logic Error in Admidio User Management

CVE-2026-41660

Deferred

Vulnerability type

Category:

Authorization Logic Error

CWE:

CWE-863

Impact:

Privilege Abuse / 2FA Downgrade and Account Hardening Bypass

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

Admidio versions prior to 5.0.9 contain an authorization logic error in the two-factor authentication (2FA/TOTP) reset feature that inverts the intended permission check.

While non-admin users cannot remove their own TOTP configuration, they can remove other users' TOTP, including administrators, allowing weaker accounts to strip 2FA protection from higher-privileged profiles under certain conditions.

Affected context

The vulnerability appears in Admidio's two-factor authentication reset functionality in multi-user deployments where group leaders or users have profile edit rights on other accounts.

It is most relevant in environments where:

  • 2FA (TOTP) is used to protect administrator or high-privilege accounts
  • Non-admin users can edit or manage profiles of other users (e.g., group leaders)
  • The application relies on 2FA as a critical second factor for administrative access

Exploit preconditions

  • Attack surface: Web application interface (Admidio UI / HTTP endpoints handling 2FA reset).
  • Required access: A valid non-admin account with permissions to edit another user's profile (e.g., a group leader with profile edit rights on an admin account).
  • Trigger point: Using the 2FA reset functionality on another user's account.
  • Why exploitation is possible: The authorization check that should restrict 2FA reset to appropriate actors is logically inverted or misapplied, so users are blocked from resetting their own TOTP but can reset TOTP for other accounts they can edit, including more privileged users.

Why this happens

This issue stems from an authorization logic error, aligning with CWE-863: Incorrect Authorization.

Instead of validating that the actor is allowed to remove a given user's 2FA configuration in a least-privilege manner (for example, limiting self-service actions to the account owner or restricting admin-level operations to true administrators), the code path inverts or misorders the checks.

As a result, the access control decision is effectively reversed: self-service removal is denied while cross-account removal is permitted.

This reflects a common pattern where business logic for permission checks is subtly wrong—using the wrong subject, object, or condition in the check—rather than outright missing, making it easy to overlook during implementation.

Potential impact

  • A group leader or similarly privileged non-admin could remove 2FA from administrator accounts they can edit.
  • Downgrade of security posture for high-value accounts by stripping their second factor protection.
  • Increased susceptibility of administrator accounts to credential-based attacks if their passwords are known, weak, or reused.
  • Undermining of organizational policies that rely on 2FA as a requirement for administrative access.
  • Erosion of auditability and accountability if 2FA removal is not tightly controlled or logged.

General mitigation guidance

Effective mitigation generally involves tightening and simplifying authorization logic around sensitive account operations such as 2FA reset:

  • Re-architect 2FA reset flows so that self-service actions are explicitly scoped to the currently authenticated user, and cross-account operations are either disallowed or restricted strictly to well-defined admin roles.
  • Apply a clear separation of duties: configuration changes that weaken account security (like removing 2FA) should require higher privilege than routine profile edits.
  • Introduce explicit checks that compare the acting user, target user, and their roles, and treat privilege reductions (e.g., removing 2FA) as high-sensitivity operations.
  • Consider requiring step-up authentication (re-enter password, use current 2FA) for disabling 2FA, even for administrators.
  • Design defaults so that failure in authorization logic is safe (deny) rather than permissive (allow), with conservative assumptions about who may perform a 2FA reset.

How teams detect issues like this

Identifying and preventing this type of issue is largely about recognizing flawed business logic around authorization:

  • Static analysis / policy checks: Look for endpoints and code paths that modify authentication factors or account security settings and verify they consistently apply role and identity checks based on both the acting and target user.
  • Code review: During review of authentication and account management features, require reviewers to trace "who can do what to whom," especially for operations that reduce security (e.g., disabling 2FA, changing passwords, altering roles).
  • Access control modeling: Maintain a simple, centralized authorization model (e.g., policy or guard layer) so that sensitive operations like 2FA resets are uniformly guarded, instead of scattering checks throughout the codebase.
  • Logging and monitoring: Log all 2FA reset operations with actor, target, and context, and monitor for patterns where non-admins frequently change security settings of more privileged accounts; use this data to validate that implemented policy matches expected behavior.

Sources

SourceLink
github.comgithub.com/Admidio/admidio/releases/tag/v5.0.9
github.comgithub.com/Admidio/admidio/security/advisories/GHSA-rh3w-4ccx-prf9

Frequently asked

questions

It can be exploitable wherever the Admidio web interface is exposed and reachable, but the attacker must already hold a valid account with sufficient rights to edit other users' profiles. It is not exploitable by completely unauthenticated users.

An attacker must be a logged-in non-admin user with permissions to edit profiles of other users, such as a group leader with edit rights on an administrator's account. Plain membership without such rights is typically not enough.

The safest pattern is to centralize and tighten authorization checks for all account security operations: ensure that 2FA removal is restricted either to the account owner through a self-service flow with step-up verification, or to clearly defined administrative roles, and verify that checks always compare the acting and target identities correctly.

Prevention involves designing a clear authorization model up front, implementing it via centralized policy or guard layers, and subjecting all sensitive business logic—especially around authentication factors, password resets, and role changes—to focused security review and testing, including negative tests for cross-account actions.

Find out what's already
exploitable in your codebase.