/

CVE-2026-25808

Severity:

HIGH RISK

(7.5)

Missing Authorization in Hollo Federated Microblogging

CVE-2026-25808

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Exposure of Sensitive Private Messages and Restricted Posts

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

Hollo exposed direct messages (DMs) and followers-only posts through its ActivityPub outbox endpoint without enforcing proper authorization checks.

An attacker who can query the outbox endpoint may be able to retrieve private content that should only be visible to the sender, recipient, or approved followers.

Affected context

This vulnerability affects Hollo deployments that are federated via ActivityPub and expose an ActivityPub outbox endpoint.

It occurs in scenarios where private content such as DMs and followers-only posts is stored alongside public posts and then serialized to ActivityPub without a permission check tied to the requesting principal.

The risk is most pronounced in publicly reachable instances or those participating actively in the broader ActivityPub federation, where external actors can interact with the outbox.

Exploit preconditions

  • Attack surface: Network-accessible ActivityPub outbox endpoint of a Hollo instance.
  • Required access: Ability to send HTTP requests to the outbox URL (e.g., as an unauthenticated or federated remote actor).
  • Trigger point: A request to the outbox or related ActivityPub delivery mechanism that returns items without verifying the caller's authorization to view each object.
  • Why exploitation is possible: The outbox handler returns objects representing DMs and followers-only posts without checking whether the requester is the intended recipient or an authorized follower, resulting in missing authorization (CWE-862).

Why this happens

The underlying issue is a missing authorization check on the ActivityPub outbox endpoint when assembling and returning items.

Instead of filtering content based on the requesting user's identity and relationship to the author (e.g., follower status or DM recipient), the implementation treated the outbox as a generic list of activities.

This maps to CWE-862: Missing Authorization, where the system fails to verify that a requester is permitted to access specific resources before returning them.

In effect, access control logic was either absent, incomplete, or not applied at the relevant enforcement point in the outbox serialization path.

Potential impact

  • Unauthorized reading of direct messages between users.
  • Exposure of followers-only or restricted posts to arbitrary remote or local callers.
  • Leakage of sensitive personal information shared via DMs or limited-audience posts.
  • Breakdown of user trust in privacy guarantees of the platform.
  • Potential correlation and profiling of users' social graphs, relationships, and private interactions.

General mitigation guidance

Mitigation should focus on enforcing robust, context-aware authorization on all ActivityPub-facing endpoints and internal data flows.

Common defensive patterns include:

  • Applying per-object authorization checks before including any activity in an outbox response, ensuring only content appropriate for the requesting principal is returned.
  • Explicitly modelling visibility levels (public, followers-only, direct/DM) in the data layer and enforcing these rules consistently in read APIs and federation handlers.
  • Implementing a central access-control layer or middleware so that authorization is not re-implemented ad hoc in each endpoint.
  • Adopting a deny-by-default approach for private content: treat all non-public activities as sensitive unless the caller is positively verified as an authorized recipient or follower.
  • Minimizing the amount of user metadata exposed through federation protocols, and carefully limiting fields returned in public vs. authenticated/federated contexts.

These patterns help ensure that even as federation features evolve, private content remains protected by consistent access-control rules.

How teams detect issues like this

Detection efforts can combine code-centric and behavior-centric approaches:

  • Static analysis and code review: Look for ActivityPub outbox or inbox handlers that build queries without explicit authorization filters or that bypass centralized access-control helpers.
  • Policy enforcement: Define architectural rules (e.g., "all queries for activities must pass through an authorization service") and flag code that directly queries posts or messages for network-facing endpoints.
  • Automated tests: Add regression tests that attempt to fetch DMs and followers-only posts via outbox endpoints as unauthenticated or unauthorized users and ensure these attempts fail.
  • Runtime monitoring: Inspect server logs or federation traces for anomalous access patterns where the same private object is being served to multiple unrelated remote actors.

Tooling such as generic web application scanners or custom ActivityPub protocol fuzzers can assist in discovering authorization gaps in federated endpoints.

Sources

SourceLink
github.comgithub.com/fedify-dev/hollo/commit/329969c502ef092d5c3f9c2c20421c34f4ff0f0e
github.comgithub.com/fedify-dev/hollo/releases/tag/0.6.20
github.comgithub.com/fedify-dev/hollo/releases/tag/0.7.2
github.comgithub.com/fedify-dev/hollo/security/advisories/GHSA-6r2w-3pcj-v4v5

Frequently asked

questions

Yes, in typical deployments it is remotely exploitable by any party that can reach the ActivityPub outbox endpoint, including remote federated instances or unauthenticated network clients, depending on the instance configuration.

An attacker generally only needs network access to the Hollo instance's ActivityPub outbox endpoint. They do not need to be a follower, DM participant, or even an authenticated local user if the endpoint is exposed without additional protection.

The safest pattern is to enforce consistent, centralized authorization on all outbox responses: for each activity, verify that the requesting principal is allowed to view it based on its visibility (public, followers-only, direct) and the relationship between requester and author. Non-public content should be excluded unless explicitly authorized.

Prevention relies on designing access control as a first-class, shared concern: define clear visibility models; centralize authorization checks; use deny-by-default for any non-public data; and add automated tests and code review checklists specifically targeting privacy boundaries in ActivityPub or other federation endpoints.

Find out what's already
exploitable in your codebase.