256

bytes: musl's password cap, past which hashing fails and returns the locked marker

10

years the bypass sat in shipped software, 2016 to 2026

0

CVE IDs assigned, so a CVE keyed scanner has nothing to match

5 Nov

the day OpenSSH shipped 10.6p2 to close the hole, in 2026

A locked account is a promise two programs kept differently

On 5 Nov 2026 the OpenSSH project shipped 10.6p2 and called it a critical security workaround for Linux systems that use the musl C library with PAM disabled. On those systems, which include Alpine Linux and a large share of the container images running in production today, an account whose password had been disabled would accept any password longer than 256 bytes. Root on a current Alpine install is such an account. The project says the root cause sits outside sshd. The researcher who reported it says it had been there since 2016.

A locked account is not a control. It is a convention: a single marker character stored in the password field, which every program reading that field has agreed to treat as a password that can never match. Two programs kept that promise in ways that were each sensible on their own, and the gap opened where they met. musl's password hashing returns that same marker character when it fails, so old programs that never check for failure do not crash on a null pointer. OpenSSH hashes the supplied password even for accounts that have none, so an attacker cannot separate real users from unknown ones by timing the response. Put the two together and the failed hash of a long password equals the stored marker, and the comparison says yes.

Nobody wrote a bug in the ordinary sense. Each decision was defensible. Nobody owned the seam between them. That is the pattern we keep meeting on engagements, and it is the reason we test whole systems rather than components in isolation.

The second point is operational. This bug has no CVE ID as we publish, and nothing in an sshd version banner tells a vulnerable musl build apart from a safe glibc one. A scanner keyed to identifiers has nothing to key on. The hosts most likely to be exposed, Alpine containers, OpenWrt routers, embedded Linux built with Buildroot or Yocto, are also the hosts least likely to show up in a patch dashboard at all. We made a close argument last week about the Brotli copies your scanner misses inside container images. The lesson here is harder, because the exposure is a login rather than a library.

What is the OpenSSH musl password bypass?

OpenSSH 10.6p2 was released on 5 Nov 2026. Its release notes describe a single security change: sshd avoids a password authentication bypass that is exploitable through sshd and affects some Linux systems when built and run with PAM support disabled. The notes state that the project considers the root cause to be outside sshd, but that the issue is exploitable via sshd and can be avoided there. The introduction calls it a critical security workaround that affects Linux systems using the musl libc with PAM disabled. No CVE is named.

The conditions matter, because they decide whether a given host is affected. The researcher's write-up lists them plainly. The sshd must be running on a musl based system: Alpine Linux, OpenWrt, Buildroot, Yocto, and many of the Docker images built from them. PAM must be off, which is the default in Alpine's openssh-server package, or set off with UsePAM no. Password authentication must be on, which is also a default. There must be at least one account whose stored password is the locked marker, which is the normal state of a key-only account, an LDAP account, or root on Alpine. Systems on glibc, such as Debian, Ubuntu and Fedora, and any system authenticating through PAM, are not affected.

OpenSSH password authentication bypass on musl High
  • Component //

    OpenSSH sshd, built against the musl C library
  • Affected //

    musl systems with PAM disabled and password authentication on: Alpine, OpenWrt, Buildroot, Yocto, many containers
  • Not affected //

    glibc systems (Debian, Ubuntu, Fedora) and anything authenticating through PAM
  • Fixed in //

    OpenSSH 10.6p2, released 5 Nov 2026
  • CVE //

    none assigned
  • Exploited //

    no reported exploitation; the researcher says it went unnoticed for ten years

The mechanism is a collision between two old decisions, both from 2012 on the musl side and 2016 on the OpenSSH side. In August 2012 musl changed its password hashing to return an unmatchable hash rather than a null pointer when hashing fails, with the stated reason that many callers do not check the return value and would otherwise misbehave. In the same month musl added its sha256 and sha512 password hashing with a hard cap on the key length, a limit the code comments describe as added for protection against a slow hashing request. Past that cap, hashing fails, and a failed hash returns the marker. In 2016 OpenSSH changed how it handles password authentication for accounts it cannot find or that have no usable password, hashing the input anyway so the timing of a response does not reveal which accounts exist. On glibc, through PAM, none of this lines up. On musl, with PAM out of the path, it does.

How an oversized password opens a key-only account

The chain is short, and we describe it at the level of what each step achieves rather than how to perform it. There is no payload here and none is needed to make the point.

An operator who can reach the SSH port picks an account that exists on the host but is not meant to accept a password. On Alpine that includes root and the default user, and on many systems it includes any account that was set up for key-based login only. The operator sends a password that is longer than musl's hashing limit. sshd, following its 2016 behaviour, asks the C library to hash that input against the account. The library, following its 2012 behaviour, fails on the oversized input and returns the locked marker. sshd compares the result against the stored password, which is the same marker, finds them equal, and accepts the login. The account that was supposed to be reachable only with a key is now reachable with a long string.

Figure 01

One symbol, two meanings

  1. 01

    Reach //

    The operator reaches an sshd on a musl host with password authentication on.

  2. 02

    Target //

    They pick an account whose stored password is the locked marker, such as root on Alpine.

  3. 03

    Overflow //

    An oversized password makes the library's hashing fail, and failure returns that same marker.

  4. 04

    Match //

    sshd compares the returned marker to the stored marker and they are equal.

  5. 05

    In //

    The key-only account accepts a password login, as root where root is that account.

Result //

Two safe defaults meet at one comparison and open the door.

Each decision was reasonable alone. The login check is where they disagree.

There are real limits, and we state them as the sources do. A freshly built host with no passwords set at all is not affected: the researcher notes that the marker has to be present on the account, which is the case once a password has been disabled rather than never set. The attack needs password authentication left on, which is common but not universal. It needs the musl and no-PAM combination, which rules out mainstream server distributions. What it does not need is any knowledge of a password, any valid credential, or any user interaction. On an Alpine cloud image where the default user has passwordless privilege escalation, the researcher points out, reaching that user is reaching root.

Why a 2016 security fix hid a login bypass for ten years

The striking part is not the mechanism. It is that a login bypass sat in widely deployed software for a decade without a crash, a scanner hit or, as far as anyone knows, a single abuse report. Three things kept it hidden, and all three are ordinary.

The first is layered defaults. No single project chose this behaviour. musl chose to fail safe for careless callers. OpenSSH chose to hash uniformly to defeat timing attacks. Alpine chose to ship sshd without PAM for size. Each default is defensible in isolation, and the vulnerable state is only the sum. Review that stops at one repository never sees it.

The second is that nobody tests the seam. musl does not run the OpenSSH test suite. OpenSSH's tests run mostly on glibc and through PAM, the paths most users take, where the behaviour does not occur. The exact combination that fails, musl plus no PAM plus a locked account plus an oversized input, is a corner that neither project's tests visit. Corners like that are where we spend our time on an engagement, because they are where the owners are not looking.

The third is the absence of an identifier. For ten years there was no CVE, no advisory, no line in a feed. Vulnerability management runs on identifiers: a scanner reports a CVE, a feed marks it exploited, a patch maps to it, a version check closes the ticket. A flaw with no identifier is invisible to that entire machine. Even now, with a fix shipped, there is no CVE to scan for, and a version banner on a musl build does not distinguish vulnerable from safe. The only reliable signals are the ones a person has to go and gather: which of your hosts run musl, which run sshd without PAM, and which accounts carry the marker.

That is why we keep saying a version string is evidence, not proof. We argued it about PHP builds that report old version numbers after a backport, and about Ivanti appliances that were patched but not clean. This case is the extreme form: there is no number to report at all, and the exposure lives in a combination of defaults that no single version string captures.

How to find affected hosts and check for abuse

Because no scanner signature exists, finding affected hosts is an inventory problem first. The question is which of your systems run sshd against musl with PAM out of the path, and the places to look are the ones that rarely reach a patch program: container base images, CI runners, OpenWrt and other embedded Linux, appliances, and cloud images built on Alpine. A host is a candidate when its C library is musl, its sshd was built without PAM or configured with UsePAM no, and password authentication is enabled. The fix is simple once a host is found: upgrade to OpenSSH 10.6p2, or turn password authentication off, which closes the hole regardless of the library.

Then check whether anyone used it. On a musl host, a password login that succeeded for an account whose stored password is the locked marker is the trace to hunt. The researcher and BleepingComputer give the manual version: look in the SSH authentication log for an accepted password login, then confirm that the account in question has the marker in its password field. If an account with a disabled password shows a successful password login in the logs, treat it as a signal to investigate. For a fleet, lift the same logic into your log pipeline.

Figure 02

Accepted password login on a musl host

Sigma

title: SSH accepted password on a musl based host
status: experimental
description: A successful SSH password authentication on a host built on the musl C library, where key only accounts such as root on Alpine are expected to reject passwords. Scope the log source to your musl hosts (Alpine, OpenWrt, Buildroot, Yocto). Pair each hit with a check that the account password field is the locked marker, which this rule cannot see.
logsource:
  product: linux
  service: sshd
detection:
  accepted_password:
    message|contains: 'Accepted password for'
  condition: accepted_password
fields:
  - message
  - user
  - src_ip
falsepositives:
  - Accounts that are meant to allow password login; exclude them by user
level: high
A starting point to tune against your own telemetry, not a production rule. The field names and message text follow sshd's own logging; confirm them against your build.

A hit is not proof on its own, because some accounts are meant to take a password. The value is that on a musl host the set of accounts that should never accept one, root on Alpine, key-only service accounts, LDAP users, is exactly the set this bug opens. A password login accepted for one of those is either a misconfiguration or abuse, and both deserve a ticket. If you find one, rotate the keys and credentials on that host, treat the account as compromised, and look for what the session did next.

How we test SSH on an engagement

SSH is the service clients assume is fine, because they moved to keys years ago and stopped thinking about it. On internal and cloud tests we treat that assumption as a thing to check, not a given. The first question is not which version of OpenSSH is running. It is which hosts run sshd at all, what their C library is, whether PAM is in the authentication path, and whether password authentication is still enabled under a configuration nobody has read since the image was built.

Containers and cloud images are where this one lives, and they are where we look. A base image chosen for size is often Alpine, and the sshd baked into it often has no PAM and password authentication left on by default. Those defaults travel into every service built from the image, and nobody revisits them. Our internal network first hour and cloud account first hour both start by mapping what answers us and under what configuration, before any version is considered, because the configuration is where the exposure usually is.

When we find a key-only account that accepts a password, we confirm it the careful way: we record that the login succeeded and stop there. We do not need to do anything with the session to make the finding, and on a client system we do not. A reachable sshd on musl with password authentication on, plus accounts that carry the locked marker, is the exposure, and it stands whether or not we walk through it. Our guide to proving network impact without causing damage covers how we show what a position reaches while leaving it as we found it. For the external view, our external recon method and the atarus-recon tool on our open source page find the SSH services an organisation exposes from its own ranges, which is where an internet-reachable Alpine appliance turns up.

What is still coming

Expect a CVE eventually, and expect it to lag the fix. The code is public, the write-up is detailed, and the behaviour is easy to confirm on a test host. An identifier will make the problem legible to scanners, but the hosts that carry the risk are the ones scanners reach least, so the identifier will help dashboards more than it helps the exposed routers and containers.

Expect the distribution packages to move at their own pace. OpenSSH shipped 10.6p2 on 5 Nov, and the fix reaches users when Alpine, OpenWrt and the image maintainers rebuild and when operators pull the new images. Long-lived containers and embedded devices that are built once and forgotten will carry the old behaviour for a long time. Turning password authentication off is the control that does not wait for any of that.

Expect more of this class. A bug that lives in the gap between two projects, each doing something reasonable, is not rare. It is the normal shape of a modern system assembled from parts that were tested apart and shipped together. The defence is not a better scanner. It is owning the seams: knowing which libraries your services are built against, which authentication paths are actually in use, and which of your defaults were chosen by an image maintainer rather than by you.

What to do today

  1. Turn off SSH password authentication on musl hosts you cannot patch yet. Set PasswordAuthentication no and restart sshd. This closes the hole whatever the library does, and it is the one control that does not wait for a rebuild.

  2. Inventory which hosts run sshd on musl without PAM. Containers, CI runners, OpenWrt and embedded Linux, and Alpine cloud images are the candidates. No scanner signature exists, so this is a deliberate sweep, not a feed.

  3. Upgrade affected hosts to OpenSSH 10.6p2. Rebuild and redeploy the base images, not just the long-running hosts, so new containers do not reintroduce the old behaviour.

  4. Hunt your logs for accepted password logins on key-only accounts. On musl hosts, a password login that succeeded for root or a key-only account is the trace. The Sigma rule above is a starting point.

  5. Treat image defaults as your decisions. Record, for each base image you ship, its C library, whether its sshd uses PAM, and whether password authentication is on, and change the ones you did not mean to accept.