CVE-2026-10130: FalkorDB QueryWeaver Authentication Bypass

CVE explainers 2026-07-19 9 min read

Security Research Desk Expert reviewed

Threat intelligence · Human-verified · Updated 2026-07-19

▲ Escalation ViewOne CVE, briefed at three altitudes — skim the Brief, weigh the Impact, or work the Runbook. The way a SOC actually reads it.

CISOBrief · 30-second brief

TL;DR - QueryWeaver can issue a valid session token for an existing account during signup. - Unauthenticated attackers only need a known registered email address. - Patch in source exists; fixed release version is not confirmed, so treat exposed instances as urgent.

Vulnerability at a Glance

Field	Value
CVE ID	CVE-2026-10130
CVSS score	8.2 (High)
Attack vector	Network
Auth required	No
Patch available	Yes, source-level fix commit exists; fixed release version not confirmed

CVE-2026-10130 is a high-severity authentication bypass in FalkorDB QueryWeaver. An unauthenticated attacker can obtain a valid session token for an existing account by sending a signup request that uses a victim’s known email address.

This vulnerability collapses the normal trust boundary around account creation and login. If a QueryWeaver deployment is reachable by untrusted users and attacker knowledge of registered email addresses is plausible, the bug can lead to straightforward account takeover without password guessing, MFA bypass tricks, or user interaction.

What Is This Vulnerability?

At its core, this is a logic flaw in the signup flow rather than a memory corruption bug or cryptographic break. The application reportedly creates and links a session token to an identity too early in request processing. The NVD description specifically states the issue involves a Cypher MERGE operation that unconditionally creates and associates a token with a matching identity before the application verifies whether the submitted email already belongs to an existing account.

That ordering error matters because signup logic should reject attempts to create a new account for an email address that is already registered. Instead, the vulnerable flow can mint a valid authenticated token first and only later evaluate whether the request should have been denied. In practice, that means a request intended for registration can be transformed into an authentication event for a pre-existing user.

From a defender’s perspective, this is best understood as unauthenticated account takeover via signup abuse. The attacker does not need the victim’s password, intercept email, or engage in social engineering. They need only a registered email address and a reachable vulnerable QueryWeaver instance.

Technical Notes

A simplified vulnerable flow, based on the NVD narrative, looks like this:

1. POST /signup with victim@example.com
2. Server looks up or merges identity record
3. Server creates/links session token
4. Server later checks whether email is already registered
5. Response includes usable token tied to existing account

Conceptually, the bug resembles this anti-pattern:

def signup(email):
    identity = merge_identity(email)   # unsafe if this matches existing user
    token = create_session_token(identity)
    if email_already_exists(email):
        return error("user exists"), token   # token should never have been minted
    return success(token)

AnalystImpact · assess the risk

Who Is Affected?

The affected product is FalkorDB QueryWeaver, the open-source Text-to-SQL tool in the FalkorDB/QueryWeaver repository. The exact affected version range is not explicitly confirmed in the primary-source material available here. The available data supports saying that QueryWeaver is affected and that the vulnerability was fixed in source control in commit e6a49f508191d0f1bdad0f146da43819e7849f18. It does not support naming a definitive vulnerable semver range or a first fixed tagged release.

That uncertainty matters for asset owners. If you run QueryWeaver and cannot immediately map your deployment to a release that includes commit e6a49f508191d0f1bdad0f146da43819e7849f18, the safest assumption is that your instance may be vulnerable. This is especially true for self-hosted builds, pinned container images, forks, or deployments built directly from repository snapshots.

Because the first fixed release version was not confirmed from retrieved primary sources, defenders should inventory: - deployed QueryWeaver versions or image digests, - whether local builds include commit e6a49f508191d0f1bdad0f146da43819e7849f18, - whether the signup endpoint is exposed to untrusted networks.

Technical Notes

Useful validation steps for operators:

# If deployed from git, check whether the fix commit is present
git log --oneline --decorate | grep e6a49f508191d0f1bdad0f146da43819e7849f18

# Or verify the current HEAD includes the fix commit in history
git merge-base --is-ancestor e6a49f508191d0f1bdad0f146da43819e7849f18 HEAD && echo "fix present"

If you deploy with containers, confirm the image digest rather than relying on a floating tag:

docker ps --format "table {{.Names}}    {{.Image}}"
docker inspect --format='{{index .RepoDigests 0}}' <container_name>

CVSS Score Breakdown

The reported CVSS v3.x base score is 8.2, which aligns with the practical impact described by NVD: unauthenticated network exploitation leading to account compromise. The exact vector string was not returned by the available NVD tool response, so any component-by-component explanation should be treated as reasoned interpretation rather than a quoted authoritative vector.

The attack appears to be remotely exploitable over the network and requires no prior authentication. There is no indication that user interaction is needed. The attack complexity also appears low if the attacker knows or can guess a registered email address, which is often realistic in enterprise environments.

On impact, the vulnerability likely has meaningful confidentiality and integrity consequences because a valid session token for an existing account can grant direct access to application data and actions available to that user. Availability impact is less obvious from the disclosed behavior. Even without the exact vector string, the score reflects a bug that crosses from registration abuse into unauthorized authenticated access.

A practical way to interpret 8.2 for prioritization is this: if QueryWeaver is reachable by users outside a tightly controlled trust boundary, this should be handled as an urgent patching and exposure-reduction issue. If the service is internal only, the risk still remains serious because corporate email addresses are usually predictable.

Exploitation Status

At the time of the provided research note, active exploitation in the wild is not confirmed. The CVE is not listed in CISA’s Known Exploited Vulnerabilities catalog, which means there is no CISA-backed evidence of active exploitation available from that source at lookup time.

Likewise, a public proof of concept is not confirmed from the cited references. The NVD references and additional reviewed results did not establish a dedicated exploit repository or trusted public PoC specific to CVE-2026-10130. That said, the vulnerability description itself is sufficiently detailed that a capable attacker likely would not need a polished public exploit to reproduce the issue.

Defenders should avoid false comfort here. “No confirmed PoC” and “not in KEV” do not mean low risk. The bug is conceptually simple, requires no authentication, and targets a common workflow. In practical terms, if an exposed instance exists and attacker knowledge of user emails is likely, exploitation may be straightforward even without public exploit tooling.

Technical Notes

Defensive assumption in the absence of confirmed public exploitation:

Assume exploitability is moderate to high because:
- the vulnerable flow is clearly described,
- the trigger is a normal application endpoint,
- no credentials are required,
- target email addresses are often guessable.

ResponderRunbook · act now

How to Detect It

Detection should focus on signup activity involving already-registered email addresses, especially when the response path appears to create authenticated sessions or when a signup attempt is immediately followed by authenticated API access from the same source. Because this is an application-logic issue, the most useful evidence will usually come from application logs, reverse proxy logs, and authentication/session issuance telemetry.

Start by identifying the signup route used by your QueryWeaver deployment and reviewing recent requests for repeated submissions against existing user emails. A strong hunting pattern is: POST /signup followed by a successful response and then immediate access to authenticated endpoints from the same IP, user agent, or token subject. Also look for signup attempts against high-value internal accounts such as administrators, shared operations mailboxes, and known demo users.

If your logs do not currently record enough application context to tell whether the email was already registered or whether a token was issued during signup, treat that observability gap as part of the incident risk. In the absence of definitive telemetry, unusual signup bursts and near-immediate authenticated sessions should be investigated manually.

Technical Notes

Example reverse proxy or app log patterns to hunt for:

POST /signup HTTP/1.1
"email":"victim@example.com"
200 OK
Set-Cookie: session=
Authorization: Bearer

Simple grep-based triage on text logs:

grep -R 'POST /signup' /var/log/nginx /var/log/queryweaver 2>/dev/null
grep -R '"email":' /var/log/queryweaver 2>/dev/null
grep -R 'Set-Cookie: session=' /var/log/queryweaver 2>/dev/null

Example Splunk query pattern:

(index=proxy OR index=app) ("POST /signup" OR "/signup")
| rex field=_raw "\"email\":\"(?<email>[^\"]+)\""
| stats count values(status) values(src_ip) values(user_agent) by email
| sort - count

Example correlation query for suspicious signup followed by authenticated activity:

(index=proxy OR index=app) ("/signup" OR "Authorization: Bearer" OR "Set-Cookie: session=")
| transaction src_ip maxspan=5m
| search _raw="POST /signup" (_raw="Authorization: Bearer" OR _raw="Set-Cookie: session=")

A generic Sigma-style idea for web telemetry:

title: Suspicious Signup Followed by Session Issuance
logsource:
  category: webserver
detection:
  selection_signup:
    cs-method: POST
    cs-uri-stem|contains: "/signup"
  selection_session:
    sc-status: 200
  condition: selection_signup and selection_session
level: medium

Mitigation and Patching

A fix is confirmed to exist in source control at commit e6a49f508191d0f1bdad0f146da43819e7849f18. However, the specific fixed release version is not confirmed from the retrieved primary sources. Because the task requirement calls for the fixed version number and the source material does not provide one, the accurate statement is: fixed release version unknown from currently available primary references.

If you maintain QueryWeaver from source, update to a revision that includes commit e6a49f508191d0f1bdad0f146da43819e7849f18. If you consume packaged releases or container images, check the release notes, tags, or image changelog from FalkorDB to identify the first build containing that commit before redeploying. Do not assume the latest tag is already deployed in your environment.

As an interim mitigation, reduce exposure of the signup route. If public self-service signup is not business-critical, disable it or restrict access at the reverse proxy, API gateway, or network layer. Also consider restricting QueryWeaver to trusted identity providers or internal networks only until you can verify the code-level fix is present. Because the bug can mint session tokens for existing users, rotating active sessions after remediation is also prudent if suspicious signup activity is found.

Technical Notes

If deployed from a git checkout, update to a revision containing the fix commit:

git fetch origin
git checkout main
git pull --ff-only
git log --oneline --decorate -n 20 | grep e6a49f508191d0f1bdad0f146da43819e7849f18

If you need to pin directly to the fixed commit until a tagged release is verified:

git fetch origin
git checkout e6a49f508191d0f1bdad0f146da43819e7849f18

Reverse proxy workaround example to temporarily block signup exposure:

location /signup {
    allow 10.0.0.0/8;
    deny all;
    return 403;
}

If your deployment supports an application configuration toggle for registration, disable self-service signup. If such a documented toggle is not available, use network controls to restrict the route until an updated build is deployed.

After patching, invalidate or rotate sessions if compromise is suspected. A generic container redeploy flow might look like:

docker compose pull
docker compose up -d --force-recreate

Before calling remediation complete, verify: 1. the deployed build includes commit e6a49f508191d0f1bdad0f146da43819e7849f18, 2. signup for an existing email is rejected before any token is issued, 3. logs confirm no session cookie or bearer token is returned on duplicate-email signup attempts.

References

The primary authoritative source for the vulnerability description is the NVD record for CVE-2026-10130, which states that QueryWeaver contains an authentication bypass allowing unauthenticated attackers to obtain valid session tokens for existing accounts via signup requests using a known victim email address.

The main remediation reference available from the provided research is the FalkorDB QueryWeaver fix commit, e6a49f508191d0f1bdad0f146da43819e7849f18. That commit confirms that a code fix exists even though the first fixed release version was not established from the retrieved sources.

NVD CVE record: https://nvd.nist.gov/vuln/detail/CVE-2026-10130
FalkorDB QueryWeaver repository: https://github.com/FalkorDB/QueryWeaver
Fix commit: https://github.com/FalkorDB/QueryWeaver/commit/e6a49f508191d0f1bdad0f146da43819e7849f18
FalkorDB QueryWeaver documentation: https://docs.falkordb.com/genai-tools/queryweaver.html
CISA KEV catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog
Third-party advisory referenced by NVD: https://www.vulncheck.com/advisories/queryweaver-authentication-bypass-via-email-signup-token-issuance-for-existing-accounts

For more information on vulnerability management, check out our guides on mitigating risks in enterprise AI factories and understanding third-party risk management (TPRM).

This article may contain affiliate links. We earn a commission on qualifying purchases at no extra cost to you.