TL;DR

While validating a finding on my own self-hosted Wazuh 5.0.0-rc1 dashboard, I found that the unauthenticated login page was serving the wazuh-wui API password in cleartext — along with other secrets sourced from the dashboard keystore. No login, no token, no clever request. Just GET /app/login and read the HTML.

The credential sits inside the page’s injected-metadata blob, in the config object for the Wazuh plugin:

1
2
3
4
injectedMetadata.uiPlugins[] → { id: "wazuhCore", config: { hosts: { default: {
  url: "https://localhost", port: 55000,
  username: "wazuh-wui", password: "••••••••••••", run_as: false
}}}}

The twist: the plugin did everything right. It declares exposeToBrowser: {} — “send none of my config to the browser.” The leak came from a regression in the OpenSearch Dashboards rendering layer underneath it, which injected each plugin’s entire server config and ignored that allowlist.

It is already fixed in 5.0.0-rc2 by wazuh-dashboard PR #1706 — but the fix was merged as a quiet refactor with no changelog entry, no security advisory, and no CVE. If you are running an early 5.0.0 pre-release, you want to read this.

Affected Wazuh dashboard 5.0.0 pre-releases built on OpenSearch Dashboards 3.6.0 before PR #1706 (e.g. 5.0.0-rc1, tagged 2026-10-05). The wazuh-wui API credential and any keystore-backed secret in a plugin’s server config are readable by any unauthenticated visitor to /app/login.

Where the credential lives (by design)

First, the boring-but-important part: Wazuh’s dashboard has to know the wazuh-wui API credential, and it stores it in cleartext on disk. That is documented and expected:

1
2
3
4
5
6
7
8
# /usr/share/wazuh-dashboard/data/wazuh/config/wazuh.yml  (a.k.a. wazuh_core.hosts)
hosts:
  - default:
      url: https://localhost
      port: 55000
      username: wazuh-wui
      password: <WAZUH_WUI_PASSWORD>
      run_as: false

The dashboard reads this once at startup to talk to the Wazuh API on port 55000. A root-readable file on the dashboard host is a reasonable place for it. The problem is not that the password is on disk — it is that the password left the server and landed in an unauthenticated HTTP response.


The security boundary: exposeToBrowser

OpenSearch Dashboards (the Kibana fork Wazuh is built on) has an explicit mechanism to decide which plugin config keys are allowed to reach the browser. A plugin declares a PluginConfigDescriptor with an exposeToBrowser map:

1
2
3
4
5
6
7
8
9
// a plugin that WANTS to expose some config
export const config: PluginConfigDescriptor = {
  schema,
  exposeToBrowser: {
    enabled: true,
    ui: true,
    // only these keys are sent to the client
  },
};

The rendering service is supposed to take only the keys a plugin opted in to and inject those into the page metadata. Everything else — database passwords, API credentials, encryption keys — stays server-side.

Wazuh’s plugins do the correct, conservative thing. On the affected box:

1
/usr/share/wazuh-dashboard/plugins/wazuh/server  →  exposeToBrowser: {}

An empty map. The plugin is explicitly saying: expose nothing to the browser. Which is exactly what you want for a plugin that holds API credentials.

So if the plugin opted out of everything, how did the password end up on the login page?


Root cause: a rendering regression that ignored the allowlist

The culprit is in the dashboard’s core rendering service. Here is the relevant branch from the shipped rendering_service.js (OSD 3.6.0), building the metadata that gets embedded into every page — including the pre-auth login page:

1
2
3
4
5
6
7
8
9
injectedMetadata: {
  version: env.packageInfo.version,
  // ...
  uiPlugins: await Promise.all([...uiPlugins.public].map(async ([id, plugin]) => ({
    id,
    plugin,
    config: /* the full plugin config, via the dynamic config service */
  }))),
}

At some point OSD added a dynamic config service to rendering. When a plugin has default configs registered, rendering started pulling each plugin’s config through that service — which returned the full config object, not the exposeToBrowser-filtered subset. The allowlist was silently bypassed for every plugin.

The result: injectedMetadata.uiPlugins[] for the Wazuh plugins contained their complete server config. For wazuhCore, that includes the hosts block above — URL, port, username, run_as, and the password. The same path leaks any other keystore-sourced secret a plugin reads server-side (opensearch.password, the AI-assistant encryptionKey, the kibanaserver password, and so on).

Why this is nasty The login page is the one page in the whole app that must render before authentication. A metadata leak anywhere else needs a valid session. Here, the leak is on the exact page an anonymous attacker is guaranteed to reach.

Check your own instance

One line, no tooling. On a vulnerable build this prints a non-zero count; on a patched build it prints 0:

1
curl -sk https://YOUR-DASHBOARD/app/login | grep -c -E 'wazuh-wui|"password"|run_as|55000'

If you want to see the structure, pull the metadata element itself:

1
2
curl -sk https://YOUR-DASHBOARD/app/login \
  | grep -oE 'injected-metadata[^>]*content="[^"]*"'

If you see wazuh-wui and a password field in there, treat the credential as compromised and jump to Remediation.


The fix

Wazuh fixed this in PR #1706 — “Simplify plugin config resolution in rendering”, merged 2026-10-27 into the 5.0.0 branch. The change forces rendering back to the exposeToBrowser-scoped path:

1
2
3
// before: full config via the dynamic config service (leaks everything)
// after:  always use the exposeToBrowser-scoped config
config: await this.getUiConfig(uiPlugins, id)

where getUiConfig() returns only the browser-safe config the plugin opted in to:

1
2
3
4
async getUiConfig(uiPlugins, pluginId) {
  const browserConfig = uiPlugins.browserConfigs.get(pluginId);
  return (await browserConfig?.pipe(take(1)).toPromise()) ?? {};
}

The PR’s own tests assert that wazuh_core.hosts.default.password, the AI-assistant encryption key, and the kibanaserver/opensearch passwords no longer appear anywhere in the rendered page. The author also notes the root cause came from upstream OpenSearch Dashboards, so stock OSD builds with the dynamic config service in rendering are likely affected too.

Version math:

BuildTaggedStatus
v5.0.0-rc12026-10-05Vulnerable (pre-fix)
PR #1706 merged2026-10-27Fix lands on 5.0.0 branch
v5.0.0-rc22026-10-30Fixed (contains #1706)

So the clean fix is simply: upgrade to 5.0.0-rc2 or later. But upgrading only closes the leak — it does not un-leak a credential that has already been served to the internet. Rotate.


Remediation

  1. Upgrade the wazuh-dashboard package to a build that contains PR #1706 (5.0.0-rc2+). Verify with the one-liner above — it must print 0.
  2. Rotate every secret that was in reach. At minimum the wazuh-wui API password; also any keystore-backed secret your plugins load server-side (opensearch.password, the AI-assistant encryptionKey, the kibanaserver password). Rotating the API password means updating it in the Wazuh API and in wazuh.yml, then restarting the dashboard.
  3. Keep the API off the internet. Port 55000 should not be reachable from outside your management network. Defense in depth: even a leaked credential is far less useful if the API it unlocks is not exposed.
  4. If you can’t upgrade immediately, the stopgap is to force the rendering service back onto the getUiConfig() path (the same one-line change as #1706) in src/core/server/rendering/rendering_service.js. Caveat: a package upgrade overwrites that file and silently reintroduces the leak, so re-check after every dashboard update until you are on a fixed build.
One-liner to keep in your post-upgrade checklist curl -sk https://YOUR-DASHBOARD/app/login | grep -c wazuh-wui — anything other than 0 means the leak is back. Wire it into a smoke test so a future upgrade can’t quietly undo the fix.

Disclosure, CVE, and the “silent fix” problem

Here is the part worth sitting with. Wazuh’s own security policy has a clear path for pre-release bugs:

Affects only non-GA version(s): we will manage the report privately by opening a GitHub Security Advisory (GHSA). Since the affected code has not been part of a GA release, the vulnerability is not eligible for a CVE ID… Once resolved, the GHSA will be converted into a public issue.

That is a reasonable policy. A credential leak that only ever existed in release-candidate builds is not CVE-eligible per CNA rules, and that is fine.

The gap is that, as of this writing, there is no advisory at all. The fix shipped as a refactor titled “Simplify plugin config resolution in rendering,” tagged no-changelog, with a PR body that never mentions that it was plugging a credential leak. The repository’s security-advisories list is empty. So anyone who deployed rc1, upgrades to rc2, and doesn’t know the history will carry a leaked, un-rotated API password into their “fixed” install and never know they needed to rotate.

This is the quiet failure mode of pre-release software:

  • Security fixes land as ordinary commits, because pre-release bugs aren’t “supposed” to need advisories.
  • Operators who run RCs in anything resembling production inherit real exposure with none of the usual signals (no CVE feed, no changelog, no mail).
  • The fix being public actually lowers urgency on an advisory, even though the credential exposure already happened.

None of this is unique to Wazuh — it is how most projects treat pre-GA bugs. The lesson is on us as operators: if you run release candidates, you have to read commits, not just changelogs. exposeToBrowser is a security boundary; when a refactor moves config plumbing around underneath it, “simplify rendering” and “stop leaking the API password” can be the same commit.


Takeaways

  • Don’t run release candidates on anything that holds real data or real credentials. If you must, treat every upgrade as a potential silent security change and diff accordingly.
  • Treat exposeToBrowser as the trust boundary it is. The plugins set it to {} and were still betrayed by a layer below them — allowlists only hold if every path that reads config honors them.
  • A fix is not remediation. Upgrading stops the bleeding; rotating the exposed secret is what actually closes the incident.
  • Watch the login page. It is your most-exposed pre-auth surface. Grep it after every upgrade.

Found on my own infrastructure, patched, and the credentials rotated before this was written. If you run Wazuh 5.0 pre-releases, go check your login page right now.