Severity:

CRITICAL RISK

(9.8)

Improper Access Control in parisneo/lollms Session

CVE-2026-1114

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-284

Impact:

Authentication Bypass and Privilege Escalation

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.0

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

parisneo/lollms 2.1.0 uses a weak secret key to sign JSON Web Tokens (JWT), allowing attackers to brute-force the signing key offline.

With the recovered key, an attacker can forge administrative tokens, leading to privilege escalation, administrator impersonation, and access to restricted endpoints.

Affected context

This vulnerability appears in deployments of parisneo/lollms version 2.1.0 that rely on JWTs for session management and authorization.

It becomes relevant when:

  • The application uses a weak or predictable secret to sign JWTs
  • JWTs can be observed or captured by an attacker (e.g., from network traffic, logs, or browser storage)
  • Server-side validation trusts any token that is correctly signed, without additional contextual checks

Under these conditions, an attacker can mount offline attacks against the JWT signing secret and later interact with the application using forged tokens.

Exploit preconditions

  • Attack surface: Application endpoints that accept JWTs for authentication and authorization (e.g., API routes, admin endpoints).
  • Required access: Ability to obtain at least one valid JWT (e.g., via own account, traffic interception, or leaked logs); no prior administrative access is required.
  • Trigger point: The vulnerable logic is the JWT verification process, which accepts tokens signed with the weak secret without detecting forgery.
  • Why exploitation is possible: The signing secret lacks sufficient entropy, enabling an attacker to perform an offline brute-force or dictionary attack against captured JWTs until the correct secret is found. Once known, the attacker can generate arbitrary tokens with escalated roles or identities.

Why this happens

The root cause is the use of an insufficiently strong secret key for JWT signing and verification, combined with trusting the token's claims solely on the basis of a valid signature.

This maps to CWE-284: Improper Access Control, because authorization decisions are effectively delegated to a secret that can be feasibly guessed.

At an abstract level, the pattern is:

  • Security relies on a cryptographic secret that is short, low entropy, hard-coded, or otherwise guessable.
  • Tokens embed authorization claims (e.g., roles, user IDs) that are not independently validated server-side.
  • The server accepts any claims if the signature matches, allowing forged claims once the key is recovered.

The weakness is not in JWT as a mechanism, but in key management and access control design that assumes the signing key cannot be brute-forced.

Potential impact

  • Attackers can forge administrative JWTs and gain full access to administrative interfaces.
  • Non-privileged users can escalate privileges to those of an administrator or other high-value accounts.
  • Impersonation of arbitrary users, including takeover of existing sessions at the application level.
  • Unauthorized access to restricted API endpoints and sensitive data.
  • Ability to perform destructive operations (e.g., configuration changes, data modification, or user management) under an administrator identity.
  • Potential pivot to other integrated services if tokens grant access beyond the core application.

General mitigation guidance

Mitigation focuses on strengthening key management and hardening authorization logic around JWT usage.

General defensive patterns include:

  • Use long, high-entropy, randomly generated secrets specifically for JWT signing; avoid human-memorable or hard-coded keys.
  • Store signing secrets in secure configuration mechanisms (e.g., environment variables, secret managers) rather than in source code or client-accessible places.
  • Prefer strong signature algorithms with asymmetric keys (e.g., RS256/ES256) where operationally feasible to separate signing and verification responsibilities.
  • Avoid embedding unrestricted role or privilege claims in tokens without server-side verification against a trusted data source.
  • Enforce least privilege by validating user permissions on every sensitive operation, not just at login or token issuance time.
  • Regularly rotate JWT signing keys and invalidate tokens when key rotation or compromise is suspected.

These measures reduce the risk that a compromised or guessed secret leads to long-term and unbounded privilege escalation.

How teams detect issues like this

Organizations can detect this class of issue using a combination of review and automated checks:

  • Code review signals:
  • Short or hard-coded JWT secrets in configuration files or source code.
  • Use of simple strings or environment defaults as secrets without documented entropy requirements.
  • Authorization decisions that rely solely on roles encoded in the JWT without database or policy checks.
  • Static analysis patterns:
  • Rules that flag hard-coded authentication secrets, low-entropy keys, or insecure JWT configuration.
  • Identification of JWT libraries configured with weak keys or algorithms without key size validation.
  • Policy and runtime monitoring:
  • Enforcing minimum entropy and rotation policies for cryptographic keys through configuration management.
  • Monitoring access logs for anomalous appearance of new administrative tokens from unexpected IPs, agents, or accounts.
  • Automatic checks in CI/CD pipelines to prevent insecure secret defaults from being introduced.

Security tooling and automated code scanning can help surface these misconfigurations early in development and during security assessments.

Sources

SourceLink
github.comgithub.com/parisneo/lollms/commit/a3b2b82b84d537a9da63e63a370a6a8ad55fed34
huntr.comhuntr.com/bounties/608b2a3b-2225-438e-9e61-ffbfdec2ed89

Frequently asked

questions

Yes. If an attacker can obtain at least one valid JWT and the secret is weak, they can perform an offline brute-force attack from anywhere and then use forged tokens against exposed endpoints over the network.

Often, the attacker needs some way to capture a valid JWT, which may come from an existing low-privilege account, intercepted traffic, or leaked logs. However, they do not need administrative access; a basic user token is typically sufficient to recover the signing secret.

Use strong, high-entropy secrets (or asymmetric key pairs) for JWT signing and manage them through secure secret storage with regular rotation. Combine this with robust server-side authorization checks that do not solely trust claims embedded in tokens.

Establish organization-wide standards for key length and entropy, prohibit hard-coded secrets through static analysis and code review, and design authorization so that privileged actions are always validated against a trusted backend store or policy engine rather than relying only on token claims.

Find out what's already
exploitable in your codebase.