Summary
Convoy's JWT decoding logic accepted JSON Web Tokens without verifying their cryptographic signatures, only checking time-based claims like exp, nbf, and iat.
In deployments using the SSO flow, an attacker who can submit a JWT could forge or tamper with token payloads (for example, the user_uuid claim) and be authenticated as any chosen user if the token's timing claims appear valid.
Affected context
This vulnerability appears in Convoy installations that:
- Use JWTs as part of the SSO authentication flow
- Rely on JWTService::decode() to validate tokens
- Expect lcobucci/jwt's configuration with HMAC-SHA256 to enforce token authenticity
The issue manifests because only time-based claims are validated and no SignedWith constraint is applied, so any token with structurally valid claims and acceptable timestamps may be treated as authentic, regardless of who created or modified it.
Exploit preconditions
- Attack surface: SSO authentication endpoint (e.g., LoginController::authorizeToken) that consumes JWTs.
- Required access: Ability to submit or influence JWT tokens presented to the Convoy panel (e.g., via a browser, API client, or compromised/forged SSO integration).
- Trigger point: Invocation of JWTService::decode() during login, where the token is parsed and its claims are trusted without verifying the signature.
- Why exploitation is possible: The validation step omits the SignedWith constraint, meaning the configured HMAC-SHA256 signer is never actually used to confirm message authenticity. As long as exp/nbf/iat are acceptable, arbitrary payloads (such as an attacker-chosen user_uuid) are accepted as valid.
Why this happens
The underlying bug is an improper verification of cryptographic signatures (CWE-347) combined with broken authentication logic (CWE-287). While lcobucci/jwt was configured to use a symmetric HMAC-SHA256 signer, the application's validation chain only enforced the StrictValidAt constraint and did not include the SignedWith constraint.
In abstract terms, the code treats JWTs as trusted containers of identity and authorization data without ensuring they are actually signed by a trusted party. This violates the core security property of JWTs—integrity and authenticity—because the presence of a signature algorithm in configuration is meaningless if verification is not enforced at validation time.
Potential impact
- An attacker could authenticate as any existing user by forging a JWT with an arbitrary user_uuid.
- Privilege escalation to administrative or reseller accounts could occur if those accounts are addressable by user_uuid.
- Unauthorized access to virtual machines, customer data, and management functions within the Convoy panel may be possible.
- Compromise of tenant isolation, enabling cross-account access and manipulation of hosted resources.
- Erosion of trust in SSO integrations, as tokens from untrusted or rogue sources can be accepted as legitimate.
General mitigation guidance
Effective mitigation focuses on treating JWTs as untrusted input until both integrity and validity are proven:
- Enforce signature verification as a first-class constraint: Ensure JWT validation chains always include a constraint equivalent to "SignedWith" or its framework-specific equivalent, tightly binding tokens to the expected algorithm and secret/key.
- Fail closed on validation: Design the decode/validate path so that any missing or failing constraint (including signature checks) results in an outright authentication failure, not partial acceptance.
- Constrain trust boundaries: Limit where JWTs are accepted from; the application should treat all incoming tokens as untrusted unless issued by a tightly controlled, known SSO provider with managed keys.
- Use high-level, opinionated helpers: Prefer well-tested library utilities or framework middleware that implement complete JWT validation flows by default, rather than hand-assembling validation chains.
- Reduce reliance on mutable claims for identity: Where possible, use stable identifiers bound server-side (e.g., mapping a short-lived token identifier to a session store) instead of trusting arbitrary claim values as the sole source of user identity.
How teams detect issues like this
Detection typically involves reviewing both code and configuration for incomplete JWT validation flows:
- Static analysis and code review:
- Search for JWT parsing/decoding calls that do not pair with explicit signature verification or a "SignedWith"-style constraint.
- Look for validation logic that checks only exp/nbf/iat or other non-cryptographic claims while implicitly trusting identity claims like sub, user_id, or user_uuid.
- Flag manual token handling paths that bypass centralized authentication middleware or framework security components.
- Security policy enforcement:
- Establish coding standards that require signature verification for all JWT usage, with automated checks in CI to flag violations.
- Use security linters or SAST tools capable of recognizing JWT validation anti-patterns and incomplete validation chains.
- Runtime and logging controls:
- Log signature validation results and anomalies (e.g., tokens accepted without signature checks) in authentication services.
- Analyze authentication logs for suspicious patterns, such as successful logins with unusual tokens, repeated logins for many accounts from the same origin, or tokens lacking expected issuer/audience characteristics.

