November 14, 2026
One Asterisk Means No Password. It Also Means the Hash Failed. SSH Compared the Two.
Two systems agreed on a string. Only one of them meant it.

By Raj Namdev
7 min read
30-second version:_ On Alpine and other musl-based Linux, a password between 257 and 1,024 characters logs into any account whose shadow field is * β root, key-only users, the cloud image default user. I rebuilt musl 1.2.5 from source and ran sshd's actual comparison against it: at 256 bytes the hash is real and the login fails, at 257 the library returns the string *, and * is exactly what the account stores for "no password." The trick needs five conditions, all of which I read in the source. The first exploitation attempt came less than nine hours after the CVE, and CISA gave federal agencies until November 12._
The chain is one comparison:
pw_password = shadow_pw(pw); /* "*" */
encrypted_password = xcrypt(password, salt); /* musl: "*" when the key is too long */
return encrypted_password != NULL &&
strcmp(encrypted_password, pw_password) == 0;pw_password = shadow_pw(pw); /* "*" */
encrypted_password = xcrypt(password, salt); /* musl: "*" when the key is too long */
return encrypted_password != NULL &&
strcmp(encrypted_password, pw_password) == 0;Two libraries agree on a string for opposite reasons. The shadow file writes * to mean this account cannot use a password. musl returns * to mean this hash failed. A string comparison cannot tell the difference, so it says yes.
I rebuilt the comparison instead of trusting the writeups
The writeups disagree on details, so I built the thing. I compiled musl 1.2.5 from source with gcc 15.2, wrote a probe that contains sshd 10.6p1's sys_auth_passwd() logic and the 10.6p2 version side by side, and built it twice: once static against musl's own libcrypt.a, once against the host's glibc 2.43 and libxcrypt 4.5.1. Same source, same inputs, two libraries.
The borrowed setting is $6$abc$ β the shape pick_salt() hands back when it borrows a neighbor's salt.
Stored *, borrowed $6$abc$, 256 B password β crypt() returned a real $6$ hash β 10.6p1 reject, 10.6p2 reject Stored *, borrowed $6$abc$, 257 B password β crypt() returned * β 10.6p1 accept, 10.6p2 reject Stored *, borrowed $6$abc$, 300 B password β crypt() returned * β 10.6p1 accept, 10.6p2 reject Stored *, borrowed $6$abc$, 1024 B password β crypt() returned * β 10.6p1 accept, 10.6p2 reject Stored *, borrowed $5$abc$, 300 B password β crypt() returned * β 10.6p1 accept, 10.6p2 reject Stored !, borrowed $6$abc$, 300 B password β crypt() returned * β 10.6p1 reject, 10.6p2 reject Stored *LOCKED*, borrowed $6$abc$, 300 B password β crypt() returned * β 10.6p1 reject, 10.6p2 reject Stored *, borrowed ab (DES), 300 B password β crypt() returned a 13-char DES hash β 10.6p1 reject, 10.6p2 reject Real $6$ hash, borrowed itself, correct password β matches β 10.6p1 accept, 10.6p2 accept Real $6$ hash, borrowed itself, 300 B password β crypt() returned * β 10.6p1 reject, 10.6p2 reject
*The boundary is exact: 256 bytes gets a real hash, 257 gets . The cap exists because SHA-crypt slows as the password grows, so musl refuses past 256 bytes rather than let one client burn CPU. The top of the range is sshd's own MAX_PASSWORD_LEN 1024.
Notice what does not flip. ! and *LOCKED* are also "no password" markers, and they never authenticate, because the code only borrows a salt when the stored field is a single character. A DES or MD5 salt produces a real hash, so the comparison fails. An account with an actual hash is untouched: the right password still works, and a 300-byte password still fails.
On the host libc the same 300-byte password produced a real hash. At 512 bytes libxcrypt returned *0, not * β its own failure token, which can never equal the setting that produced it. That one character of difference is the entire bug.
How one string ended up doing two jobs
The * sentinel is older than SSH. It goes back to 1980, when Bill Joy put it in /etc/passwd for daemon to mark an account that no password could satisfy. Then sshd did what the era did: strcmp(crypt(typed, stored), stored). That comparison is only safe if crypt() never returns the sentinel β and on the libcs people ran for the next thirty years, it didn't.
POSIX said crypt() returns NULL on failure, and glibc did. musl didn't. In August 2012 it changed crypt() to return the literal string * on failure, on the reasoning that callers forget to check for NULL and a string can't crash them. Twenty days later it added SHA-256 and SHA-512 crypt with a 256-byte key limit. Past the limit: failure. Failure: *.
But that alone wasn't enough. sshd only borrowed a salt when the stored field was too short to be one. In 7.2p2 the fallback was the literal string xx β a DES salt. DES has no length cap, so the hash was always real and the comparison always failed. The 2016 fix for a username-enumeration timing attack (CVE-2016-6210) replaced that fixed xx with pick_salt(), and its comment is still in the tree:
/*
* If we don't have a salt we are encrypting a fake password for
* timing purposes. Pick an appropriate salt.
*/
if (salt == NULL)
salt = pick_salt();/*
* If we don't have a salt we are encrypting a fake password for
* timing purposes. Pick an appropriate salt.
*/
if (salt == NULL)
salt = pick_salt();That is the moment the two meanings meet. The fake hash now uses a real account's $6$ setting, and SHA-crypt is the scheme with the 256-byte cap. A long enough password makes the fake hash fail into *, which is exactly the string the target account stores.
Alpine made it worse in 2022: version 3.16 changed root from ! to * so key-only root logins worked again. Every Alpine image since has shipped a * account.
The five conditions, from the source
In the 10.6p1 tree, each condition is a line. The stored field loads into pw_password; if it is exactly *, the second byte is the terminator, so salt stays NULL and pick_salt() wants a neighbor's SHA-crypt setting.
musl libc β crypt() returns * on failure. If missing: glibc/libxcrypt return *0 or a real hash. PAM disabled β this function is the auth check. If missing: PAM decides, and it doesn't compare strings. PasswordAuthentication yes β sshd's default. If missing: no password path at all. **Target field is exactly *** β pw_password[1] is NUL β salt stays NULL. If missing: !, !!, *LOCKED* never match. Another account has $5$ or $6$ β pick_salt() borrows it. If missing: falls back to xx, a DES salt, and fails.
That is why the bug is narrower than the headlines. Most of the internet runs glibc or PAM. The exposure is musl plus non-PAM sshd plus password auth on plus a literal * plus one SHA-crypt account somewhere on the box. Alpine's default openssh-server is built without PAM, and any admin who set a console password created that last condition.
What it looked like when it was used
ΓzgΓΌn KΓΌltekin reported it to OpenSSH on November 3, per his own timeline. OpenSSH shipped 10.6p2 on November 5. Exploit code appeared about four hours later. Previdian counted 20 attempts from 13 addresses in 9 countries between November 6 and 8, and confirmed root on a honeypot running Alpine. GreyNoise saw six source addresses running 18 distinct chains: cloud metadata queries, /etc/shadow, root's authorized_keys. One of those chains got root and installed a Python implant called TAC Agent, which never reached its C2 at tac.vpnla[.]org.
CISA added CVE-2026β123158 to KEV on November 9 with a November 12 due date. FIRST's EPSS put it at 18.9% β the highest in that week's batch of eleven additions, higher than the Chrome zero-day. Not because it's easy to find, but because scanning for it is free and the payoff is root.
The fix is four characters of validation
The 10.6p2 change is smaller than the writeups:
- return encrypted_password != NULL &&
+ ret = encrypted_password != NULL &&
+ strlen(pw_password) >= MIN_PASSWORD_HASH_LEN &&
strcmp(encrypted_password, pw_password) == 0;- return encrypted_password != NULL &&
+ ret = encrypted_password != NULL &&
+ strlen(pw_password) >= MIN_PASSWORD_HASH_LEN &&
strcmp(encrypted_password, pw_password) == 0;MIN_PASSWORD_HASH_LEN is 4 β no real hash is shorter β so the * sentinel is rejected before crypt() is called. OpenSSH's position is that the root cause lives outside sshd: musl's failure token, or the shadow file's use of a printable character as a sentinel. It is exploitable through sshd, so sshd refuses it.
My probe confirms it: with the length check in place, the 257-byte password was rejected on every run, and the real account still authenticated. Upgrading does not clean a host that was already entered, and it does not revoke keys the attacker added.
What this bug class is worth to a hunter
The transferable lesson isn't "check Alpine." It's that the interesting bugs live where two components share a value with different meanings β a sentinel, an error code, a default. KΓΌltekin found this with a differential auth matrix across libcs and build flags, not by reading one codebase. That method is repeatable: take one authentication path, compile it against every libc and configuration you can, and feed it the same corpus. The differences are the bugs.
To check your own hosts, the audit is read-only:
ldd --version 2>&1 | head -n 1
sshd -T | grep -Ei '^(usepam|passwordauthentication|permitrootlogin) '
sudo awk -F: '$2 == "*" {print "star account:", $1}' /etc/shadow
sudo awk -F: '$2 ~ /^\$(5|6)\$/ {f=1} END {print f ? "SHA-crypt present" : "none"}' /etc/shadowldd --version 2>&1 | head -n 1
sshd -T | grep -Ei '^(usepam|passwordauthentication|permitrootlogin) '
sudo awk -F: '$2 == "*" {print "star account:", $1}' /etc/shadow
sudo awk -F: '$2 ~ /^\$(5|6)\$/ {f=1} END {print f ? "SHA-crypt present" : "none"}' /etc/shadowFour lines, no hashes printed, and it tells you whether all five conditions hold. If they do, PasswordAuthentication no plus an sshd restart closes the path. That is also what a good report contains: the five conditions, one request, and the log line.
What I did not do: boot Alpine, run sshd, and log in. My probe is the comparison, lifted from the real source, running against real libraries. That is enough to show the boundary and the fix. It is not enough to claim I owned a host, and one write-up reports the first attempt inside a live connection failing where mine accepted on the first call β a detail I did not test.
Two systems agreed on a string. Only one of them meant it.
Sources
All runtime results are from my own runs on November 14, 2026, on an Ubuntu 26.04 host with gcc 15.2: musl 1.2.5 built from source (./configure --disable-shared, musl-gcc -static -lcrypt) and a host build linking glibc 2.43 / libxcrypt 4.5.1. The probe re-types sys_auth_passwd(); it is not sshd.
- OpenSSH 10.6p2 release notes β released November 5, 2026; "avoid password authentication bypass β¦ affects some Linux systems when built and run with PAM support disabled"; reported by ΓzgΓΌn KΓΌltekin of Wakefield.
openssh.com/txt/release-10.6p2 - OpenSSH fix commit
4353fdc43eβ addsMIN_PASSWORD_HASH_LEN 4and the length check beforestrcmp(). The 10.6p1 tree also definesMAX_PASSWORD_LEN 1024, which bounds the exploitable password length. auth-passwd.catV_10_6_P1βsys_auth_passwd(): salt stays NULL whenpw_password[0]orpw_password[1]is empty; comparison isstrcmp(encrypted_password, pw_password) == 0.openbsd-compat/xcrypt.catV_10_6_P1βpick_salt()scansgetpwent()for a field starting with $ containing a second $, copies up to the last $, and falls back toxx;xcrypt()calls it when salt is NULL, with the comment about hashing "a fake password for timing purposes."- CVE-2016β6210 β the timing fix that introduced
pick_salt(); shipped in OpenSSH 7.3p1. - musl commits
b3c4cc12(failure returns *) and88bf5a8a(August 29, 2012; SHA-crypt 256-byte key limit) β timeline and commit links:github.com/oz9un/sshole/blob/main/TIMELINE.md - SecurityWeek, "OpenSSH Rushes Patches for 'SSHole'" β CVSS 8.1; five conditions; Alpine affected 3.16 through 3.24 and edge; root is * since 3.16.
- SecurityWeek, "Hackers Exploiting 'SSHole'" β Previdian: 20 attempts, 13 IPs, 9 countries, November 6β8.
- BleepingComputer, "Hackers exploit SSHole" β GreyNoise: six addresses, 18 chains, root on a honeypot, TAC Agent C2
tac.vpnla[.]org. - CISA KEV β CVE-2026β123158 added November 9, 2026. EPSS 18.9% in the November 12 snapshot listed by Daily CISO.
- oss-security thread, November 7, 2026 β measured libc comparison: musl returns * at β₯257 bytes, libxcrypt returns
*0, and the note that a failure token built to never compare equal is the real defensive property. - Alpine Linux advisory β fixed packages back to 3.16;
tiny-cloudimages 3.18.11β3.24.3 ship analpineuser with * and passwordlessdoas.