/

CVE-2026-28431

Severity:

HIGH RISK

(7.5)

Authorization / Access Control in Misskey Server

CVE-2026-28431

Analyzed

Vulnerability type

Category:

Authorization / Access Control

CWE:

CWE-285

Impact:

Unauthorized Data Access and Potential Data Breach

Severity:

HIGH RISK

(7.5)

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

Misskey servers from version 8.45.0 up to, but not including, 2026.3.1 contain an authorization flaw that allows users to access data they should not be permitted to view.

Due to insufficient permission checks and lax input validation in certain request paths, an attacker can potentially retrieve sensitive information, leading to a significant data exposure incident even when federation is disabled.

Affected context

The vulnerability affects Misskey instances deployed on any network (public or private) running versions 8.45.0 through versions prior to 2026.3.1.

It manifests in server-side request handling where authorization decisions and input validation are incomplete or inconsistently enforced.

Any feature or endpoint that relies on these flawed checks may expose data that should only be visible to specific users, roles, or trusted parties, independent of federation settings.

Exploit preconditions

  • Attack surface: HTTP(S) API and web endpoints exposed by a Misskey server.
  • Required access: Network access to the target Misskey instance; in many cases, an authenticated user account may be sufficient if role or scope checks are incomplete.
  • Trigger point: Crafted or out-of-spec requests that take advantage of missing or incorrect authorization checks, often combined with manipulated request parameters or identifiers.
  • Why exploitation is possible: Some server-side handlers rely on incomplete permission enforcement and insufficient input validation, allowing users to reference or traverse to resources outside their intended authorization scope.

Why this happens

The underlying issue stems from insufficient authorization checks, aligning with CWE-285: Improper Authorization.

Certain backend operations trust user-supplied identifiers or context without consistently verifying whether the caller is entitled to perform the requested action or access the targeted resource.

Additionally, weak or missing input validation allows crafted parameters to bypass the expected access patterns, resulting in data being returned based on identifier presence rather than a robust permission model.

In abstract terms, the access control logic is not centralized or rigorously applied, leading to inconsistencies where some code paths skip critical permission and context checks.

Potential impact

  • Exposure of private posts, messages, or non-public profile data.
  • Unauthorized access to user-related metadata, activity, or relationship information.
  • Leakage of administrative or operational data that is not meant for regular users.
  • Broader data breach affecting multiple users or the entire instance, depending on which endpoints are reachable.
  • Potential regulatory and compliance impact due to accidental disclosure of personal or sensitive data.

General mitigation guidance

Effective mitigation focuses on hardening the authorization model and reducing trust in client-controlled input:

  • Centralize authorization decisions in a common access control layer and ensure all endpoints delegate to it.
  • Implement explicit, role- and scope-based checks for every operation involving user or tenant data, preferring deny-by-default policies.
  • Validate and constrain all identifiers and parameters used to look up resources, avoiding direct trust of client-provided IDs without context checks.
  • Adopt clear separation between public and private data paths, making non-public access require explicit, verified authentication and authorization.
  • Minimize over-privileged operations and reduce the amount of data returned to the minimum necessary for each request.

How teams detect issues like this

Detection typically combines code-level review with behavioral monitoring:

  • Use static analysis and code review checklists to flag endpoints that access user data without explicit authorization checks or that construct queries directly from client-supplied identifiers.
  • Enforce architectural rules (e.g., linters or custom checks) that disallow direct data access outside of a vetted service or repository layer with built-in permission enforcement.
  • Log authorization decisions and anomalous access patterns; monitor for users accessing unusually large volumes of records or resources they do not normally interact with.
  • Incorporate security tests in CI that exercise endpoints with manipulated identifiers to confirm that unauthorized access attempts are rejected.

Sources

SourceLink
github.comgithub.com/misskey-dev/misskey/security/advisories/GHSA-r33c-qg3g-v9cr

Frequently asked

questions

Yes. Any party with network access to a vulnerable Misskey instance can attempt to exploit the flaw through exposed web or API endpoints. In many scenarios, exploitation may be easier with an authenticated account, but configuration-dependent anonymous access cannot be ruled out.

Not necessarily. Some affected paths may be reachable by any network user, while others might require a basic user account. The core risk is that authorization checks are incomplete, enabling a user—authenticated or not—to gain access to data outside their intended permissions.

The most robust fix is to centralize and enforce strict authorization checks for every data access operation. Each endpoint should verify both the identity and the specific permission of the caller for the resource in question, combined with strong input validation on all resource identifiers.

Design the system around a consistent, well-documented access control model, enforce deny-by-default policies, and ensure all data access flows through components that apply standardized authorization and validation. Complement this with automated security testing, code reviews focused on access control, and periodic audits of endpoints handling sensitive data.

Find out what's already
exploitable in your codebase.