Cut-paper illustration of a dark server box with a large rust asterisk on its door, while a long cream paper strip covered in small asterisks slides into the keyhole

On November 5, OpenSSH shipped version 10.6p2: not a feature release, but a one-paragraph workaround for a bug that had sat in plain sight for ten years. The bug is not in the cryptography. It is the gap between three ordinary decisions, each reasonable on its own.

The bug is CVE-2026-123158, nicknamed *sshole by its finder, Özgün Kültekin of Wakefield. On a Linux system built on musl, running sshd without PAM, a password of 257 to 1,024 bytes logs you into any account whose password field is a single asterisk. Those accounts should never accept a password: key-only users, service accounts, root on Alpine. MITRE scores it 8.1, High.

Three decisions that were each fine on their own

First, the asterisk. Since 1980, Unix has used * in the password field to mean "no password can ever match": a marker, not a hash. Alpine still uses it: since 3.16, root ships as root:*, and key-only users get the same.

Second, musl's error value. crypt() is supposed to return NULL on failure. In 2012 musl changed that: on failure it returns the single character *, so programs that never checked for NULL would not crash. Weeks later musl added SHA-256 and SHA-512 hashing with a 256-byte key limit, to stop long passwords burning CPU. Past 256 bytes, crypt() fails, and returns *.

Third, the salt borrowing. In 2016, OpenSSH fixed a timing bug, CVE-2016-6210, that let an attacker tell real usernames from fake ones by response time. The fix made sshd hash the submitted password even for accounts with no usable password, borrowing another account's salt just to waste the same amount of time.

Put them together: an attacker sends a 300-byte password for a key-only account. sshd borrows the salt from an account with a real $6$ hash, musl's crypt() gives up past 256 bytes and returns *, and sshd compares * with the stored *. They match.

On the range: musl refuses keys longer than 256 bytes, so 257 is the first length that fails, and sshd caps passwords at 1,024. The CVE record says 256 to 1,024 characters; Alpine says 257 to 1,024 bytes.

Who is actually exposed

The conditions are narrow. All five have to hold at once:

Condition Why it matters
sshd built on musl libc glibc's crypt() does not return a bare *
sshd checks passwords without PAM Alpine's default openssh-server has no PAM
PasswordAuthentication yes The OpenSSH default
One account with * in /etc/shadow root on Alpine since 3.16, key-only users, the alpine cloud user
One account with a real $5$ or $6$ hash sshd borrows its salt from there

If your Alpine runs only as a container base image and the containers never start sshd, you have nothing to patch. The exposure sits in Alpine VMs, cloud instances, jump hosts, CI runners, and appliances on port 22.

Accounts locked with ! are not affected, and neither are systems where password logins are off or go through PAM.

The surprise case is Alpine's tiny-cloud images: the official qcow2, VHD and AMI images from 3.18.11 through 3.24.3 ship an alpine user with a * password field and passwordless doas. Safe on first boot, with no real hash on the box, and exploitable the moment one appears. From there it is a shell as alpine and doas to root. Root is partly protected by the default PermitRootLogin prohibit-password, cold comfort when another account on the box can become root.

The exploitation argument, stated honestly

Previdian told Help Net Security on November 6 that its sensors saw the first attempt less than nine hours after the CVE went public: eight attempts from one Japan-based address, one reaching root on a honeypot running real Alpine.

Nobody else has corroborated that. Other November 6 write-ups report no confirmed exploitation in the wild, CISA's enrichment of the CVE record lists exploitation as proof of concept only, and the flaw is not in CISA's Known Exploited Vulnerabilities catalog as of November 7.

One firm says it watched the bug get used on its honeypot within a day; every official list still says proof of concept. Both can be true, and neither is a reason to wait. A public proof of concept exists and the fix is a package upgrade. Patch for the mechanism, not the list.

OpenSSH calls the fix a workaround and puts the root cause outside sshd, in musl's behaviour. The notes also say the project now gets many AI-assisted security reports and will ship fixes as soon as they are ready. Kültekin found it by building sshd in every combination and throwing about 17,600 unusual logins at the builds, with AI agents doing the running.

The checks that mislead

Three checks will lie to you.

First, the version banner. Alpine backported the fix into each branch, so a patched 3.24 box still reports 10.3_p1-r2. A scanner looking only for 10.6p2 will flag patched machines as vulnerable. Compare the installed package against the fixed version for its own branch: edge 10.6_p2-r0, 3.24 10.3_p1-r2, 3.23 10.2_p1-r1, 3.22 10.0_p1-r11, 3.21 9.9_p2-r1, with backports down to 3.16; older releases get no fix.

Second, the upgrade. Updating the package does not restart the running sshd; Alpine says so plainly. Upgrade, restart sshd, and keep your session open while you test a new login from a second terminal.

Third, the logs. The researcher's write-up notes a * account "needs a wrong try first": the long password lands on the second attempt in a connection, not the first. Alpine puts it from the operator's side: one connection, no retries, works every time. Look for an Accepted password for line naming an account that has no password, in /var/log/messages. If you cannot rule out such a login, treat the machine as compromised.

What to do

  1. List every place sshd actually runs on musl, including containers and images that bundle an SSH server. Package lists are not enough.
  2. On each one, check the effective config with sshd -T, not just the file: usepam, passwordauthentication, permitrootlogin.
  3. List the * accounts and the real hashes: awk -F: '$2=="*" {print $1}' /etc/shadow and awk -F: '$2 ~ /^\$[56]\$/ {print $1}' /etc/shadow.
  4. Upgrade openssh to the fixed build for the host's branch, then restart sshd. If you cannot upgrade today, set PasswordAuthentication no and restart sshd.
  5. Search the logs for password logins to * accounts, and review doas use and changes to authorized_keys.

The durable point is not about Alpine. It is about what an error value is allowed to look like. musl picked * as its failure signal in 2012 because it could never match a real password, and then the same character became the standard marker for "this account has no password." Two systems agreed, independently, that * meant "nothing here." Then sshd compared them and found a match. Anywhere a failure signal and a locked door share a value, you have the same bug under a different name.

Sources