
On November 5, 2026, OpenSSH shipped emergency release 10.6p2 for a bug that reads like a riddle: on some Linux servers, a password of 257 characters or more logs you in as an account that has no password at all. No credential guessing, no exploit chain. One connection, and the door opens.
The flaw is called SSHole, tracked as CVE-2026-123158. It was reported by security researcher Özgün Kültekin of Wakefield, and it affects OpenSSH running on Linux distributions built with the musl C library — Alpine Linux first among them — when password authentication is handled without PAM. Chinese developers on the forum LINUX DO flagged it within hours of the disclosure, which makes sense: Alpine is the default base image for an enormous share of the world's Docker containers, and plenty of Chinese homelabbers run it on cheap VPS boxes and home servers. If you run Alpine anywhere, this one is worth ten minutes of your time.
Every Linux account has a password field in /etc/shadow. For accounts that should never accept a password — key-only users, service accounts, root on a modern Alpine image — that field holds a single asterisk, *: a marker meaning no password can ever match.
SSHole breaks that assumption. On an affected system, sshd checks a login attempt by hashing the supplied password with the C library's crypt() function and comparing the result against the stored field. For a account, there is no salt to hash with — a salt is the random prefix inside a real password hash, and is too short to contain one — so sshd borrows the salt from another account on the same machine that does have a real hash.
That is where musl's crypt() steps in. Musl refuses to hash passwords longer than 256 bytes, and when it refuses, it returns the string as its error signal. The comparison becomes against *. They match, and the login succeeds.
Alpine's advisory puts it plainly: an attacker who can reach your SSH port needs only the name of a * account and a machine with at least one other account holding a $5$ or $6$ hash. One user with a real password makes every password-less account on the box reachable. Accepted length: 257 to 1,024 bytes — musl's 256-byte limit below, sshd's own cap above.
The first dates to 2012. Musl's crypt() was changed so that a failed hash returns the literal string * instead of NULL, because too many programs did not check for failure. Returning an obviously unmatchable token seemed safer. It was — for fourteen years, in almost every context.
The second dates to 2016. OpenSSH fixed CVE-2016-6210, a timing flaw that let attackers enumerate valid usernames: accounts with no usable hash were verified faster than accounts with real ones, leaking which usernames existed. The fix made sshd hash the attempt anyway, borrowing a salt from another account — the behavior SSHole abuses.
The third is Alpine's packaging choice. Its standard openssh-server package is built without PAM, password authentication is on by default, and since about Alpine 3.16 root ships as root:* so key logins work without PAM. Each decision is defensible alone; together they turn a deliberately password-less account into one that accepts any sufficiently long password.
The bug has existed since 2016, according to the researcher's write-up. OpenSSH's release notes are candid: the project considers the root cause to lie outside sshd, but fixed it in sshd because that is where it can be exploited. The 10.6p2 fix makes sshd refuse a match when the stored field is shorter than four characters.
The conditions are specific. All of the following must be true:
| Condition | Detail |
|---|---|
| C library | musl — Alpine Linux, some OpenWrt builds, Buildroot, Yocto |
| SSH server | OpenSSH, built or run without PAM |
| Password auth | PasswordAuthentication yes (the OpenSSH default) |
A * account | At least one account with * in /etc/shadow |
| A real hash | At least one other account with a $5$ or $6$ hash |
Alpine says every release it checked is affected — 3.21 through 3.24 and edge, plus the older releases back to 3.16 — and fixed packages were published for all of them.
Who is not affected matters too. Debian, Ubuntu, Fedora and other glibc distributions are safe, as is any system authenticating through PAM — Alpine's openssh-server-pam package with UsePAM yes is not vulnerable. Dropbear, the lightweight SSH server many embedded distributions use, is not affected, and neither are Docker containers that do not run sshd inside them. Locked accounts, with ! instead of * in the shadow field, cannot log in at all.
Security coverage scores it CVSS 3.1 8.1 (High), on a network attack vector with no privileges or user interaction required; the NVD entry lists the same vector but has not yet published its own score. No in-the-wild exploitation had been reported at disclosure — but public reproduction labs were already referenced in the CVE record, so working exploits should be assumed to exist.
The sharpest edge of SSHole is Alpine's official cloud images. The tiny-cloud images from versions 3.18.11 through 3.24.3 ship a default user named alpine with a * password field and passwordless doas — Alpine's equivalent of sudo. The images are safe on first boot, with no $6$ hash to supply the borrowed salt. They become exploitable the moment one exists — an admin sets a console password, or user-data adds a user with a hashed password. An attacker logged in as alpine can then use doas to become root. OpenSSH's default PermitRootLogin prohibit-password blocks password logins for root itself, but that does not help when another reachable account can escalate — and on the cloud images, the alpine user can.
If you run Alpine anywhere, the check takes about a minute. These are defensive checks of your own configuration, not exploit attempts.
First, look at the shadow file for * accounts and real hashes:
sudo grep -E '^[^:]+:\*:' /etc/shadow
sudo grep -E '^[^:]+:\$[56]\$' /etc/shadow
The first lists accounts with no password; the second lists accounts with a real SHA-256 or SHA-512 hash. If both return results, the machine is in the affected configuration.
Second, check the effective sshd configuration:
sshd -T | grep -iE 'passwordauthentication|usepam|permitrootlogin'
passwordauthentication yes combined with PAM disabled is the vulnerable combination. If you see passwordauthentication no, you are already safe.
Third, check your OpenSSH version against the fixed packages: 10.6_p2-r0 (edge), 10.3_p1-r2 (3.24), 10.2_p1-r1 (3.23), 10.0_p1-r11 (3.22), 9.9_p2-r1 (3.21), with backports to 3.16.
There are two ways to close the hole, and either one is enough.
The first is to update. On Alpine:
apk upgrade -U -a
rc-service sshd restart
The restart matters. Upgrading the package does not replace the running daemon, so an unpatched sshd keeps serving logins until it is restarted — the step most likely to be forgotten in a hurry.
If you cannot update yet, disable password authentication. Make sure your SSH key login works first, and keep your current session open until you have tested a new login — locking yourself out of your own server is the classic self-inflicted follow-up to a security patch. Alpine's advisory suggests a drop-in file under /etc/ssh/sshd_config.d/ plus a sed edit of the main config, then sshd -t and a restart; confirm with sshd -T | grep -i passwordauthentication, which should print passwordauthentication no.
Longer term, the sensible default for any server you manage is key-only SSH anyway: PasswordAuthentication no plus PermitRootLogin prohibit-password, with keys as the only way in. That was already best practice before SSHole; the bug is just a vivid demonstration of why. If the patch has you rethinking a box you spun up on a free tier and never hardened, our look at the free-VPS hunt covers how to get cheap compute without cutting the same corners.
Patching closes the hole; it does not answer whether anyone walked through it first. Check /var/log/messages for sshd lines reading Accepted password for an account that has no password — alpine, root, or any key-only user. A password login for such an account should never happen legitimately, so any occurrence is evidence of compromise.
If you find one, review doas use, recently created users, files and authorized keys. If you cannot rule out a login, treat the machine as compromised: rebuild from a known-good image, rotate keys and credentials, and audit what the session touched.
SSHole is not the most severe bug of the year. What makes it worth remembering is its shape: three individually reasonable decisions, made in 2012, 2016 and in Alpine's packaging, combining into a vulnerability that sat unnoticed for a decade. The * marker had meant "no password can match this" for decades — and then, through a chain nobody designed, it became the one value that always matches.
It is also a reminder that the lightweight choices homelabbers love — musl instead of glibc, no PAM, a minimal base image — carry their own failure modes. The fix is small: update the package, restart the daemon, or turn password authentication off. If you run Alpine with sshd exposed, do it now — and check your logs for password logins to password-less accounts while you are at it.