On this page (7 sections)

A critical flaw tracked as CVE-2026-129552 affects Tensei in versions through 0.11.5. Its authentication package, @tensei/auth, uses a hard-coded JWT signing key when the JWT_SECRET environment variable is not set. Anyone who knows that key can create login tokens the application will accept.

If you run an application built on Tensei, or maintain one for a client, check today whether JWT_SECRET is actually set in production. The GitHub advisory and the NVD record describe the same issue, and at the time of writing no patched version is listed.

What happened

According to the advisory, @tensei/auth falls back to a fixed signing key, 'auth-secret-key', whenever JWT_SECRET is unset. An unauthenticated attacker can then sign tokens containing arbitrary user ids, and the function populateContextFromToken accepts them. The result is impersonation of any user, including administrators.

The record was published to NVD and the GitHub Advisory Database on November 16, 2026. The advisory is marked unreviewed, lists no package, and gives affected and patched versions as unknown beyond the 'through 0.11.5' wording in the description. It references an upstream issue, the project repository and a VulnCheck advisory. So far only this one set of records covers the story, and the NVD entry repeats the GitHub text rather than confirming it independently.

Why a hard-coded signing key is so dangerous

A JWT (JSON Web Token) is a signed statement such as 'this request comes from user 1'. The server trusts it only because it can verify the signature with a secret key. If that key is secret and unpredictable, outsiders cannot produce valid tokens. If the key is a default value published in open source code, the signature proves nothing: anyone can read the code, learn the key and mint tokens for whichever account they like.

The advisory lists the weakness as CWE-1394. The CVSS v4 metrics in the advisory reflect the consequence: network attack vector, low complexity, no privileges and no user interaction, with high impact on confidentiality, integrity and availability of the vulnerable system. No password guessing or phishing is needed, and normal login logs may show nothing unusual.

The flaw is conditional. The description says the fallback applies when JWT_SECRET is unset. An application that sets a strong, unique JWT_SECRET is not using the default key, based on the description. Verify this per deployment rather than assuming it.

Who is exposed

  • Production, staging and demo deployments of Tensei apps at version 0.11.5 or earlier that never set JWT_SECRET.
  • Apps started from a template, tutorial or container image where the environment variable was left out or left empty.
  • Any deployment where the variable is set in one environment (say, production) but missing in another that holds real data, such as staging copies.
  • Agencies and hosts that run several client apps and may not know which ones use @tensei/auth.

Because the key is public, an exposed app should be treated as open to anyone who can reach its API, not only to skilled attackers.

How to check your exposure

First find out whether you use the package and which version. Run this from the project directory on a machine with npm installed. It lists installed copies of @tensei/auth and their versions; anything at 0.11.5 or lower is in the affected range.

List the installed @tensei/auth version (run in the project directory)Shell
npm ls @tensei/auth

Next, confirm that JWT_SECRET is defined for the running process. Check your process manager, container definition, hosting dashboard or secrets store. If you have a shell in the same environment as the app, this reports whether the variable is set and non-empty without printing its value; expect yes, and treat no as exposed.

Check whether JWT_SECRET is set and non-empty in the current shell environment (prints only yes or…Shell
[ -n "$JWT_SECRET" ] && echo yes || echo no

Also search your own code and configuration for the literal fallback value, which would show that someone copied it into a config file. This read-only search prints matching file names and lines, excluding installed dependencies; no output means no match.

Search project files for the default key string (run in the project directory)Shell
grep -rn --exclude-dir=node_modules 'auth-secret-key' .

What to do now

The sources do not name a fixed release, so the reliable fix today is configuration: make sure the app never falls back to the default key, and invalidate anything signed with it.

Caution. Changing the signing key invalidates every existing session token, so all users, including admins, will be logged out. Plan a short maintenance window and restart the app only after the new value is in place.
  1. Inventory every app that depends on @tensei/auth and note its version.
  2. Generate a long random value (at least 32 bytes from a cryptographically secure generator) and set it as JWT_SECRET in each environment, stored in a secrets manager rather than in the repository.
  3. Restart the application so it loads the new secret, then confirm that old tokens are rejected.
  4. Treat any app that ran without JWT_SECRET as potentially compromised: review admin accounts, recent role changes, API keys, content and data exports for activity you do not recognize.
  5. Rotate other credentials an admin could have reached, such as database passwords, third-party API keys and webhook secrets.
  6. Check the Tensei repository and issue 398 for a fixed release or maintainer guidance, and upgrade when one is published.
  7. If you cannot confirm a fix and cannot set the secret, restrict access to the app's API (VPN, IP allow-list or firewall rule) until you can.
Tip. Make a missing JWT_SECRET a startup failure in your own deployment scripts or entrypoint, so a misconfigured copy can never run quietly with a default key.

Detection and monitoring afterwards

Forged tokens look like valid sessions, so hunt for their effects. Look for admin actions at times when the real admin was offline, new or changed administrator accounts, unexpected password or email changes, and API calls from unfamiliar IP addresses using privileged identities. If your app logs user ids per request, compare them with known login events. If you find signs of misuse, follow our guide on what to do when a website is hacked.

For ongoing hygiene, a regular outside-in look at your public endpoints helps you spot forgotten staging copies and exposed admin paths. Webforta Scan runs read-only scans of sites you verify, and Webforta Monitor can alert you to certificate, DNS and header changes. Neither tells you whether JWT_SECRET is set inside your app, so the checks above remain necessary. For broader habits, see small business website security.

What we do not know yet

  • No fixed version is named in the sources reviewed.
  • The GitHub advisory is unreviewed and lists no package.
  • No source reports active exploitation, but that is not evidence it is not happening, given how simple the weakness is.
  • Only one set of records covers the issue so far, so details may change as the maintainers or other researchers respond.

We will treat the 'through 0.11.5' range as the working boundary until the maintainers say otherwise.

Sources

This article is based on the public sources below. Details can change as vendors and researchers publish more; check the original advisories before acting on version numbers.

  1. CVE-2026-129552 - GitHub Advisory Databasegithub.com
  2. CVE-2026-129552: Tensei through 0.11.5 contains an authentication bypass vulnerability in @tensei/auth that falls back to the hard-coded JWT signing key 'auth-secret-key' when…nvd.nist.gov ·
  • CVE-2026-129552
  • Tensei
  • JWT
  • authentication bypass
  • hard-coded secret