/

CVE-2026-48781

Severity:

CRITICAL RISK

(9.9)

Broken JWT Authorization (CWE-863) in Postiz Skool SSO

CVE-2026-48781

Deferred

Vulnerability type

Category:

Broken Authentication and Authorization

CWE:

CWE-302, CWE-345, CWE-863

Impact:

Privilege Escalation and Account Takeover

Severity:

CRITICAL RISK

(9.9)

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 broken authorization flow in Postiz's Skool integration allowed attacker-controlled JSON data to be signed into a JWT using the application's secret key.

Because the auth middleware trusted all claims in that token without reloading user state from the database, any authenticated user could forge a SUPERADMIN session and impersonate other organizations.

Affected context

This vulnerability occurs in Postiz deployments that:

  • Enable or use the Skool integration callback flow
  • Sign session-shaped JWTs directly from external or semi-trusted JSON payloads
  • Rely on JWT claims as the sole source of truth for user role, organization, and permissions
  • Do not re-validate session claims against a trusted datastore on each request

It primarily affects multi-tenant instances where users from different organizations share the same Postiz installation.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints involved in the Skool integration callback and any route protected by JWT-based middleware
  • Required access: Any valid authenticated Postiz account on the affected instance (not necessarily privileged)
  • Trigger point: Invoking the Skool callback or associated flow with a crafted JSON blob that is then signed into a JWT
  • Why exploitation is possible:
  • The application signs attacker-controlled JSON with the global JWT_SECRET
  • The auth middleware blindly trusts JWT claims (role, organization, identifiers)
  • No secondary lookup of the user or organization is performed before assigning permissions

Why this happens

The issue stems from conflating token integrity with claim authenticity and treating externally influenced data as authoritative session state.

The Skool integration took JSON input that the attacker could shape, then signed it as a JWT using the application's secret, implicitly elevating its trust level.

Downstream, the authorization middleware accepted all JWT claims at face value—such as role and organization membership—without verifying them against a canonical data source.

This aligns with:

  • CWE-863 (Incorrect Authorization): authorization checks are based on manipulable token content rather than verified user state.
  • CWE-302 (Authentication Bypass by Assumed-Immutable Data): trust placed in a token simply because it is signed, not because the embedded claims are validated.
  • CWE-345 (Insufficient Verification of Data Authenticity): failure to establish the authenticity of the JSON claims themselves, beyond signature integrity.

Potential impact

  • Any authenticated user may escalate privileges to SUPERADMIN within the instance.
  • Attackers could impersonate arbitrary organizations configured on the same Postiz instance.
  • Full access to all application features, including administrative configuration and user management, could be obtained.
  • Unauthorized posting on behalf of victim organizations' linked social media channels can occur.
  • Exposure or modification of sensitive data such as access tokens, schedules, analytics, and internal configuration is possible.
  • Long-term compromise of connected social media accounts, including brand damage from malicious posts, is possible.

General mitigation guidance

Effective mitigation centers on strict separation between transported claims and authoritative state, and on minimizing trust in externally influenced tokens.

Common defensive patterns include:

  • Treat JWTs as pointers rather than sources of truth:
  • Store only opaque identifiers or minimal, non-privileged claims in the token.
  • Resolve the user, role, and organization from a trusted datastore on each request.
  • Enforce server-side role and tenant verification:
  • Derive roles (e.g., SUPERADMIN) solely from database-backed relationships.
  • Apply explicit checks that the authenticated user belongs to the requested organization or tenant.
  • Harden integration callbacks:
  • Treat all third-party or client-provided JSON as untrusted, even if delivered over TLS.
  • Validate and normalize incoming data against strict schemas and ignore unexpected or privileged fields.
  • Constrain JWT contents and signing:
  • Avoid signing arbitrary JSON blobs; define a fixed, minimal claim set.
  • Use different secrets or signing keys for different logical purposes (session vs. integration artifacts).
  • Include audience, issuer, and expiry claims and enforce them consistently.
  • Apply least-privilege defaults:
  • Default new sessions to the lowest reasonable privilege.
  • Require additional, server-side checks for sensitive actions like organization-wide changes or posting on linked social media channels.

How teams detect issues like this

Detection efforts can focus on both code-level and behavioral indicators:

  • Static analysis and code review:
  • Search for JWT signing utilities that accept entire request bodies or third-party JSON as claim sets.
  • Flag middleware that grants roles or organization context directly from token claims without a database lookup.
  • Look for patterns where the same JWT_SECRET is reused across disparate concerns (e.g., sessions and integrations).
  • Review SSO and integration callbacks for code paths that set role, isAdmin, organizationId, or similar properties from external input.
  • Runtime and log analysis:
  • Monitor for unusual surges in administrative or SUPERADMIN actions originating from regular user accounts.
  • Detect access patterns where a single account rapidly switches between multiple organizations.
  • Inspect authentication logs for tokens that declare high-privilege roles but originate from low-privilege accounts.
  • Policy enforcement:
  • Introduce pre-merge checks requiring that high-privilege assignments are always tied to database queries.
  • Use automated security review tools or SAST linters configured with rules around JWT handling and authorization flows.

Sources

SourceLink
github.comgithub.com/gitroomhq/postiz-app/releases/tag/v2.21.8
gadvisory.orggadvisory.org/advisories/PSA-2026-2CAQ96
github.comgithub.com/gitroomhq/postiz-app/commit/23696d2973510ae1f3f48bfa41a6bfbbf9827b05
github.comgithub.com/gitroomhq/postiz-app/security/advisories/GHSA-j77w-h625-56q2

Frequently asked

questions

Yes. Any user who can reach the affected Postiz instance and obtain a normal authenticated account can exploit the issue over standard HTTP(S) endpoints, without needing local or network-level access.

No. The vulnerability can be exploited by a low-privileged, authenticated user. The flaw lies in how the Skool integration signs and trusts JWT claims, allowing escalation to SUPERADMIN without prior admin rights.

The safest pattern is to keep JWTs minimal and treat them as references:

store only stable identifiers in the token, then resolve user details, roles, and organization membership from a trusted datastore on each request.

High-privilege attributes must never be accepted directly from external or integration-provided JSON.

Adopt a defense-in-depth authorization model:

  • Separate authentication (who you are) from authorization (what you can do), with centralized, database-backed checks.
  • Avoid signing arbitrary client or third-party data into tokens.
  • Enforce strict schemas and role assignment logic in one well-reviewed layer.
  • Incorporate automated checks and security review of all SSO, integration, and token-handling code paths.
Find out what's already
exploitable in your codebase.