The condition stack first, because that is what you need, then the archaeology, because it is the part that will keep you up.

What makes a box vulnerable

All six, from the disclosure page built by the reporter:

  • sshd is running on musl — Alpine, OpenWrt, Buildroot, Yocto, and anything else on that libc.
  • PAM is disabled — Alpine's openssh-server does not use it by default; other musl builds often have no PAM at all.
  • Password logins are on — they are by default.
  • An account has exactly * in its shadow field — key-only users, LDAP users, and on Alpine, root: since Alpine 3.16, root's entry is a bare star.
  • Some other account has a real password hash — that account's salt is what sshd borrows.
  • And it needs a wrong try: a * in shadow only matches if the computed value fails into it. A fresh box with no real-password accounts is not affected, because there is no salt to borrow.

Meet all of that and the * account logs in with any password between 257 and 1024 bytes — the tested working range. On Alpine's official AWS and Azure images, the account in question is the default alpine user, and it holds passwordless doas. That is root.

Who is not affected: anything on glibc — Debian, Ubuntu, Fedora — because libxcrypt returns *0 on failure and *0 does not match *. Anything going through PAM, because PAM never even calls crypt() for a star field. Dropbear does not do this. OpenBSD does not do this.

Where the star came from

In 1980, Bill Joy put the character * into /etc/passwd for the account called daemon — the 3BSD receipt is still browsable, complete with "The devil himself" as the real name. The convention means: no password will ever match this field, because nothing hashes to it. Unix has carried it forward into /etc/shadow ever since.

In 2012, musl looked at the mess around crypt() and NULL. The Single UNIX Specification says crypt() returns a null pointer on failure — but lots of programs never check for NULL, compare a null pointer against a stored hash, and segfault. So musl changed the contract: commit b3c4cc12, August 2012 makes crypt() return an unmatchable string on failure instead of NULL — programs stop crashing and just see a wrong password. The unmatchable string they picked is the same character: *.

Twenty days later, musl added sha256 and sha512 crypt, and capped the key at 256 bytes for DoS protection — sha512crypt gets slower the longer the password is, so a giant password means a busy server. if (i > KEY_MAX) return 0; — failure — and on failure crypt now says *. Anything longer than 256 bytes, hashed by musl, produces exactly the character shadow uses to mean no login possible.

2016: sshd starts hashing against it

CVE-2016-6210 was a user-enumeration timing leak: ask sshd about a user that does not exist and it answered instantly, because there was nothing to hash — the ms of difference told you who exists. The fix is the kind of thing that reads like over-engineering until the day it matters: for accounts with no hash to check, sshd grabs some other account's salt and computes the hash anyway, just to burn the same time. Still a no. A slower no.

Except the computation is now real. On musl, feeding that path a password longer than 256 bytes yields *. And if the account you are actually trying to enter has * in its field, the comparison is * == *. Login.

Alpine spent the rest of the decade putting stars into perfect positions. CVE-2019-5021 — the 2019 discovery that Alpine's Docker images shipped root with an empty password field — got fixed by locking root with !. But without PAM, ! also kills SSH key logins for that account, and cloud images log in with keys. So in 2022, Alpine 3.16 switched root from ! to * — the commit message even says it: this still forbids password login but allows logins via ssh keys with pam disabled. It forbids password login, plus one more thing nobody had a name for yet.

The near-misses

The parts around this bug came as close as literature does to naming it:

  • 2013–2019. A Debian developer asked glibc to adopt musl's * scheme — libc-alpha thread, Debian #714219. glibc's libxcrypt eventually shipped *0 on failure. One character of difference. Every glibc box is fine because of one character.
  • December 2024. The musl mailing list discussed busybox passwd crashing on a 257-character password — same *, same 256-byte cap. The thread is about passwd. Nobody wrote sshd.
  • October 30, 2026. A security review inside OpenSSH fixed fake-salt generation for bcrypt hashes — the pick_salt() function. The bug sits four lines below it. Four days of head start, unused.

How it was actually found

Özgün Kültekin of Wakefield built sshd every way the flag matrix allows — glibc/musl × PAM on/off × shadow/no-shadow, twelve builds — and threw roughly 17,600 crafted logins at the matrix: weird hashes, broken accounts, passwords far too long. Every build agreed on every login. Except musl without PAM, which agreed with things it should have refused. The disclosure page says the testing ran with agent swarms doing the enumeration; the human wrote the hypothesis that was worth agent-hours: the boring libc boundary is where people don't look, because they look at crypto.

The report reached OpenSSH November 4. Damien Miller's public warning that day was to turn password-based login off immediately on affected systems — his own words are turn it off or disable sshd — and Alpine posted the same warning. OpenSSH released 10.6p2 on November 5 with the workaround, and Alpine shipped the patched package the same day. The release notes are careful in a way worth reading: the project considers the root cause to be outside sshd — this is a workaround, portable OpenSSH refuses to let sshd be the path in.

GreyNoise has opened a live activity page monitoring scanning and exploitation attempts for this bug, which means they are tracking whether the door is being walked through. No public exploitation statistics existed at this site's publish time — and the question now has a certified answer: see the November 11 addendum at the end of this post.

The operator checklist

```sh

what am I running?

ssh -V # on the box itself; musl shows up via ldd $(which sshd) | grep musl ```

  • Alpine, patched: apk upgrade openssh — the fix is in.
  • Any musl box not yet patched, or unpatchable: turn password logins off until you can:

sh echo "PasswordAuthentication no" > /etc/ssh/sshd_config.d/00-no-passwords.conf rc-service sshd restart

That mitigation works everywhere, on every version, forever. Keys-only sshd should be your end state anyway; this bug is the strongest argument your key-only policy ever had.

  • Hunt: a *-field account writing an auth success line is the signature. The oz9un/sshole repository carries the grep patterns. On an Alpine cloud image, that means looking for the alpine user and root in your auth logs going back as far as you keep them.
  • Containers: most Alpine containers do not run sshd at all — but the base image is everywhere, and appliance builds that add openssh-server inherit musl and no-PAM defaults without anyone revisiting them. Inventory the appliances you built once and forgot. That class of device is this entire story.

The honest column

  • [Correction, November 11:] A CVE identifier has been assigned since this post was written — CVE-2026-123158, CVSS 8.1, high, KEV-listed on November 9 with evidence of active exploitation and a November 12 federal deadline. See the November 11 KEV-batch post for the verified sequence. The release notes' "critical security workaround" language was accurate about root cause; this site's refusal to mint a number turned out not to be the catalog's.
  • Which older portable OpenSSH releases carry the same behavior is not established — the tested builds were the current 10.6p1 line. The ingredients date to 2012 and 2016, so treat any musl + no-PAM sshd as in scope until your vendor says otherwise. The password-off mitigation covers all of them regardless.
  • Whether the musl maintainers consider this musl's bug is not settled in public. The 2012 commit even shows musl guarding one self-match — crypt_des returns x when the requested setting is * — which means the collision risk between failure markers and shadow conventions was in the room twelve years ago. musl changed NULL semantics to stop crashes; a program that does not check for the sentinel marker was always the open end of that trade. OpenSSH is doing the fixing because sshd is where the path in is.

The cadence note

Buried in the 10.6p2 release notes is a policy change that outlives this bug: OpenSSH says it has received a large volume of AI-assisted security reports, that some of those bugs get independently discovered without disclosure, and that for now the project will ship fixes more frequently rather than batching them into scheduled releases.

Read that against the ledger this site keeps: a zero-click root exploit written against a fifteen-year-old kernel race by a research model in October, WordPress's October fixes carrying Anthropic's name on multiple reports, and now a twelve-build fuzz matrix pointed straight at the code nobody reads. The finding half-life on old, quiet, load-bearing code is collapsing. Projects that notice are changing their release cadence to match — and the advisory naming the real bug landed months late, the changed shape was the warning itself: if OpenSSH is saying smaller, faster batches, the quiet assumption that last month's minor release was the settled state of your sshd is gone.

The Alpine rebuild story from three weeks ago was about catching a fix your package manager had not shipped yet. This one is simpler and worse: the fix is shipped, the warning is public, and the affected box is the one you provisioned from a cloud image in 2022 and stopped thinking about in 2022. Go check it tonight.

The addendum, November 11

Twenty-four hours after this post went up, CISA minted the catalog entry it had been building toward: CVE-2026-123158 — "OpenBSD OpenSSH on Linux contains an unexpected status code or return value vulnerability" — CVSS 8.1, high, added to the Known Exploited Catalog on November 9 with evidence of active exploitation and a November 12 deadline for federal agencies. The two statements in this post that the calendar then falsified are corrected inline above: the bug has a number now, and GreyNoise's open question has a certified answer — someone is walking through the door, or has.

Two details worth noticing in the catalog entry itself:

  • It is scoped as OpenSSH on Linux. The glibc world is safe by one character; the catalog's scoping agrees with this post's architecture analysis.
  • The title is the mechanism, not the story: an unexpected status code is musl's star. The naming survives the translation from workaround to catalog row.

The November 11 KEV-batch post carries the full sequence, the three-day deadline context, and the assume-compromise homework. The checklist above is unchanged. If this post made you check one appliance, the addendum is the deadline that makes it non-optional.

A correction like this one is the cheapest thing on this site: the post from Tuesday was wrong about the catalog by Wednesday, the edit says so, and the link points at the evidence. That is the entire audit model — and it is the same model CISA uses, just faster and with a smaller audience.