Introduction
An observability platform holds a near-complete picture of a target environment: logs, metrics, traces, alerts, and the configuration that governs them. In OpenObserve before 1.1.0, any unauthenticated attacker who knows a victim's email address and organization name could authenticate as that victim across roughly 400 protected API routes by sending an HTTP Basic header with an empty password.
OpenObserve is an open source, cloud native observability platform for logs, metrics, traces, RUM, session replay, pipelines, and related telemetry. The company was founded in 2022 and reports thousands of organizations and deployments along with tens of thousands of GitHub stars, which makes it a visible open source alternative to established observability tooling. Because these platforms aggregate sensitive operational data and privileged service identities, an authentication flaw in one has broad consequences for the environments it monitors.
Technical Information
The vulnerable logic is in the shared authentication validator at src/api/common/src/auth/validator.rs. OpenObserve supports a native salted password hash stored in password, and a plaintext external password stored in password_ext that is used for presigned URL credential derivation. The validator accepted a login if the supplied password matched either the argon2 hash or the plaintext password_ext value.
The problem is how accounts enter the system. SSO and provisioning paths in src/api/common/src/auth/jwt.rs persist an empty external password:
let updated_db_user = DBUser { email: user_email.to_owned(), first_name: first_name.to_owned(), last_name: last_name.to_owned(), password: "".to_owned(), salt: "".to_owned(), organizations, is_external: true, password_ext: Some("".to_owned()), };
create_new_user in src/core/src/users.rs repairs the empty native password with a random hash and salt, but it leaves password_ext untouched. The validator then evaluated the alternate credential like this:
let in_pass = get_hash(user_password, &user.salt); if !user.password.eq(&in_pass) && !user.password_ext.unwrap_or("".to_string()).eq(&user_password) { return Ok(TokenValidationResponse { is_valid: false, /* ... */ }); }
The critical detail is unwrap_or(""). A missing credential (None) was converted to an empty string, so both None and Some("") matched an empty supplied password. The only empty password guard ran on ingestion routes, which left the roughly 400 non-ingestion /api routes exposed.
Attack Flow
The attacker prerequisite is minimal: the victim's email address and organization name. The steps are:
- Identify an affected account. SSO provisioned external users and migration created identities such as the predictable
o2-sre-agent.org-{org}@openobserve.internalservice account can carry an empty or missingpassword_ext. - Build an HTTP Basic
Authorizationheader using the victim's email and an empty password, for example a header that decodes to[email protected]:where the trailing colon marks the empty password. - Send the request to a protected non-ingestion
/apiroute. A2xxresponse confirms the bypass, and the attacker now acts with the victim's role and permissions.
From there the impact depends on the impersonated account. A privileged account can expose or modify telemetry, alerts, streams, users, and security configuration. The advisory further describes a conditional escalation: an impersonated account with search permission can submit a DataFusion COPY ... TO statement through the search API to create or overwrite files at locations writable by the service process, turning the authentication bypass into a conditional path to pre-authentication remote code execution. This consequence depends on the permissions and the environment, and is not an automatic outcome for every deployment.
The weakness is classified as CWE-287, Improper Authentication, and the CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H for a score of 9.8.
Proof of Concept
A complete, maintainer published Proof of Concept exists in the official advisory GHSA-7w4v-2c9r-q94v, crediting Sonar researcher mokraneab. It provides a disposable Docker lab, a one time victim provisioning step, and a working curl based attack request.
The reproduction environment uses a Dex IdP (dex-config.yaml) and a compose.yaml running ghcr.io/dexidp/dex:v2.37.0 plus the OpenObserve Enterprise image, exposing OpenObserve on 127.0.0.1:5088. The operator first completes one legitimate Dex SSO login as [email protected] (lab password OpenObserve-SSO-2026!) to provision the victim Admin account. This models a pre-existing victim and is not part of the attack.
The attack primitive is a single Basic auth header containing the victim email and an empty password:
Authorization: Basic c3NvLWFkbWluQGV4YW1wbGUudGVzdDo=
That value decodes to [email protected]:, where the trailing colon indicates an empty password. The verbatim exploit request from the advisory is:
curl --silent --show-error --include \ --user '[email protected]:' \ --header 'User-Agent: OpenObserve-SSO-Empty-Password-PoC/1.0' \ 'http://127.0.0.1:5088/api/default/streams'
The observed result confirming the bypass is:
HTTP/1.1 200 OK content-type: application/json {"list":[...],"total":1}
The HTTP 200 confirms authentication as the provisioned SSO user with no IdP password, OpenObserve password, session, cookie, or token. The advisory notes that an impersonated account with search permission can then submit a DataFusion COPY ... TO statement via the search API, which extends the bypass to a conditional pre-authentication remote code execution primitive. Third party trackers such as IONIX and Rapid7 corroborate the technical details but do not add independent exploit code beyond linking the official advisory.
Patch Information
The issue is fixed in OpenObserve 1.1.0. Every version before 1.1.0 is listed as vulnerable. The fix shipped in PR #15054, squash merged as commit 46678ea8daba94c3904286471794f80c5a74ecea ("fix: tighten input validation, auth and outbound request checks") on 2026-10-08. The PR also contains an earlier, narrower commit dc5c657002d97e9e29726cefcadec49cae755e1a ("fix(auth): never accept an empty password or a missing password_ext"). NVD links both commits. One commit cited by an upstream source, ed07b6e2..., is unrelated to this CVE and only hides the Product Analytics menu behind an environment variable.
In the vulnerable validator a login succeeded if the supplied password matched either the argon2 hash or the plaintext password_ext field, with a missing value turned into an empty string:
user.password.eq(&get_hash(user_password, &user.salt)) || user.password_ext.as_deref().unwrap_or_default().eq(user_password)
The patch applies several layers of defense rather than one check:
1. Reject blank credentials before any comparison. validate_credentials now returns an invalid response immediately when the password is empty, and the old guard that only covered ingestion routes was deleted:
+ // A blank credential must never reach a comparison with a token that may be stored blank. + if user_password.is_empty() { + return Ok(TokenValidationResponse::default()); + } ... - if is_ingestion_path && user_password.is_empty() {
The same check was added to validate_user_from_db, which serves native and presigned logins.
2. Remove the plaintext password_ext fallback. The interim commit dc5c657 first tightened the comparison to .is_some_and(|ext| !ext.is_empty() && ext == user_password). The merged version deleted the alternate path completely, so Basic authentication now checks only the salted hash:
- user.password.eq(&get_hash(user_password, &user.salt)) - || user.password_ext.as_deref().unwrap_or_default().eq(user_password) + password_matches(user_password, &user.password, &user.salt) ... +fn password_matches(candidate: &str, stored_hash: &str, salt: &str) -> bool { + try_get_hash(candidate, salt).is_some_and(|hash| hash == stored_hash) +}
This also defeats the whitespace only variant, since a password of " " can only succeed if it matches the real argon2 hash.
3. Make hashing fail closed for saltless SSO users. The new try_get_passcode_hash and try_get_hash return None when the salt is shorter than 8 bytes or longer than 48, and password_matches treats None as a non match, so a saltless account cannot be authenticated by any guess and no longer panics. The password hash cache was changed to a bounded LRU keyed by a SHA-256 of salt || 0x00 || password.
4. Require a real password_ext for presigned logins. Both validate_credentials_ext and validate_user_from_db now refuse to build the credential from an empty value:
+ let Some(password_ext) = user.password_ext.as_deref().filter(|ext| !ext.is_empty()) else { + return Ok(TokenValidationResponse::default()); + };
5. Apply the same rules to gRPC. In src/api/grpc/src/handler/grpc/auth/mod.rs, check_auth_inner now rejects an empty password before comparing tokens and drops a comparison that accepted the stored hash itself as a password, replacing it with try_get_hash(...).is_some_and(|h| h == user.password).
6. Harden the secret behind password_ext. The new check_ext_auth_salt in src/migration/mod.rs makes a fresh install refuse to start unless ZO_EXT_AUTH_SALT is a random 16 to 48 byte secret (the docs suggest openssl rand -hex 24). Existing installs only receive a warning, because rotating the salt would break existing derived logins.
The patch fixes the verifier, not the stored data. The provisioning code in jwt.rs that writes password_ext: Some("") is not in the diff, so existing accounts keep their blank or NULL password_ext, but the validator can no longer reach that value from Basic auth. Regression tests including exercise_empty_password_rejected, exercise_saltless_sso_user_refused, presigned_login_refuses_a_blank_password_ext, test_empty_password_does_not_match_empty_token, and test_stored_password_hash_is_not_a_password cover the bug directly. PR #15054 is a large hardening bundle of about 11,000 changed lines, most of which addresses unrelated issues such as SSRF, gRPC internal auth scoping, and path traversal.
Detection Methods
No public Sigma, YARA, Snort, or Suricata rule exists for CVE-2026-126065 yet, but the attack travels over the normal OpenObserve HTTP API and has a recognizable shape.
1. Find HTTP Basic credentials with an empty password. The whole attack depends on one malformed credential. The advisory's example header is Authorization: Basic c3NvLWFkbWluQGV4YW1wbGUudGVzdDo=, which decodes to [email protected]: with a trailing colon and nothing after it. Every real attack uses a different email, so the Base64 string is only a lab example, not a signature. The reliable check is to decode the Basic credential at your reverse proxy, WAF, API gateway, or log pipeline and flag any request where the text after the first colon is empty or only whitespace. Real users never send that.
2. Focus on non-ingestion /api routes that return 200. Only ingestion routes reject empty passwords early, and roughly 400 protected non-ingestion /api route patterns are reachable. The highest confidence alert combines three things: a Basic auth request with an empty password, sent to a non-ingestion /api/... path, that received a 2xx response. A 401 or 403 on the same request means a failed probe or an unaffected instance. A 2xx means the bypass worked and should be treated as a compromise.
3. User-Agent from the published PoC. The advisory's curl reproduction sends User-Agent: OpenObserve-SSO-Empty-Password-PoC/1.0. Matching this can catch people running the public PoC unchanged, but attackers can trivially change it, so use it only as a supporting signal.
4. Watch the accounts that can actually be bypassed. SSO provisioned external users store password_ext as an empty string and normally sign in through the identity provider, so any Basic authentication under an SSO user's email is already unusual. Migration created service identities named o2-sre-agent.org-{org}@openobserve.internal have no password_ext and guessable names, so Basic auth from unexpected IPs or clients deserves review. The users table migration copies password_ext without normalizing it, so older accounts may also have it absent, null, or empty. If you can query the user store, list accounts where is_external is true or password_ext is null or empty and use that list as your watchlist. IONIX gives similar advice.
5. Look for signs of escalation to code execution. Inspect search API request bodies or query logs for COPY ... TO statements, especially in sessions that started with empty password Basic auth. On the host or container, watch for the OpenObserve process writing files outside its normal data directory and for unexpected child processes. A COPY ... TO query following a successful empty password request is strong evidence of an attack in progress.
6. Check exposure and verify safely. List every instance below 1.1.0, prioritizing internet facing ones. To confirm exposure, the advisory's method is a single read only GET to a protected non-ingestion endpoint such as /api/{org}/streams with an empty Basic password for a known SSO provisioned account; a 200 response means vulnerable. Only run this against systems you are authorized to test, preferably with a test account you control.
Affected Systems and Versions
All OpenObserve versions prior to 1.1.0 are affected. The issue is fixed in OpenObserve 1.1.0. The accounts practically exposed are SSO provisioned external users, migration created service identities such as o2-sre-agent.org-{org}@openobserve.internal, and accounts copied by the users table migration, all of which may carry a missing or empty password_ext. The CVSS 3.1 score is 9.8 Critical with vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H.
Vendor Security History
OpenObserve's security page describes vulnerability assessment, change review, security awareness, access controls, and incident response practices, and notes that public security fixes target the current stable release while pre release builds and development branches receive best effort attention. This is the vendor's description of its program rather than an independent audit. The available sources do not provide a comprehensive history of prior vulnerabilities or incidents, so this single CVE is not enough to establish a broad security track record.
References
- NVD: CVE-2026-126065
- CVE Record: CVE-2026-126065
- GitHub Security Advisory GHSA-7w4v-2c9r-q94v
- OSV: CVE-2026-126065
- OpenObserve PR #15054
- OpenObserve v1.1.0 Release
- Fix commit 46678ea8
- Interim fix commit dc5c657
- Advisory API JSON
- Commit 46678ea8 API JSON
- Commit dc5c657 API JSON
- Unrelated commit ed07b6e2 API JSON
- IONIX Threat Center: CVE-2026-126065
- Rapid7 Vulnerability Database: CVE-2026-126065



