#056
2026-11-06

An Ultra-Long Password Gets You In Without One: Alpine's Decade-Old *sshole Flaw

📰 Want to read more?
Browse the full news list

On November 5, security researcher Özgün Kültekin disclosed a flaw in the SSH password-authentication path of Alpine Linux, naming it *sshole — his explainer site sshhole.com leads with a string of “Yes. Yes, I know. Yes.” The scenario is plain: if a machine has an account with no password set, an attacker who types a password of more than 256 characters over SSH logs straight in as that account — no knowledge of any password needed, success on the first connection, no retries, no lockout. OpenSSH shipped 10.6p2 the same day, and Alpine Linux pushed updated packages for every branch. As of publication, the OpenSSH team had received no reports of in-the-wild exploitation.

The trigger conditions look strict, but the blast radius is wider than it seems. Everything must hold at once: a musl libc system (Alpine, OpenWrt, Buildroot, Yocto — the musl ecosystem), PAM disabled (Alpine's openssh-server package does not include PAM by default), PasswordAuthentication yes (the OpenSSH default), at least one account with * in its password field (meaning no password set — Alpine's root has been root:* in the base images since 3.16), and at least one local account with a real $5$ or $6$ password hash. That last condition is the killer: as long as one account on the machine has a password set, every no-password account is exposed, and an attacker needs to know just one account name to get in. Official testing found all versions from Alpine 3.16 through 3.24, plus edge, affected. To make it worse, the official tiny-cloud images (3.18.11 through 3.24.3) ship with a built-in alpine account — no password, and holding passwordless doas privileges. Once an admin sets a console password, or a user with a hash is added via user-data, the machine is fully opened: the attacker logs in as alpine and escalates all the way to root through doas.

One more question many people ask: does this have anything to do with Docker? The answer is two layers: the Docker engine itself (the host side) is usually a glibc system and is not affected at all — the real target is “containers built on an Alpine base image”. Alpine is one of the most popular lightweight base images in the Docker ecosystem, so dev containers, jump hosts, and service containers built on Alpine all fall inside the risk zone. But even that is not enough: the container must also be running sshd with password login enabled, and many containers never expose SSH at all (they use docker exec or the application API), so they are fine. The profile most likely to be hit: Alpine base + openssh-server installed + someone has set a root password + there are also passwordless service accounts created with adduser -D. The test is simple: is your image Alpine-based, and does it expose SSH password login? Two more high-risk scenarios are unrelated to Docker but come from the same musl ecosystem: cloud tiny-cloud images and OpenWrt routers — the OpenWrt gateway at home, the tiny-cloud images from your cloud vendor — make sure they are not left out of your check.

Why did this bug sit for nearly a decade without being found? Kültekin offered his own explanations: fresh installs with no passwords set are not affected; an account whose shadow entry is * needs one failed attempt to trigger; OpenSSH is tested on OpenBSD and glibc systems, and the musl path simply is not in the test scope; most distributions use PAM, and PAM never calls crypt on a * field. It has narrowly escaped detection more than once: in 2013 a Debian developer asked glibc to copy musl's asterisk behavior; six years later Debian switched to libxcrypt, which returns *0 — one character away from closing the bug; at the end of December 2024 the musl mailing list discussed busybox's passwd failing on 257-character passwords — the same limit, the same asterisk, but nobody connected it to sshd. The closest call was October 30, 2026: an OpenSSH security review fixed an issue in pick_salt(), and this flaw sat four lines below that function — four days later, he found it.

The fix, and the pitfall: OpenSSH 10.6p2 makes sshd refuse to compare whenever the password field is shorter than four characters. The project calls it a workaround, because the root cause actually lives outside sshd — musl's crypt() error handling interacting with a side effect of OpenSSH's earlier fix for username enumeration. The easiest trap to step into: updating the package does not restart the sshd that is already running — you must separately run rc-service sshd restart. If you cannot update immediately, set PasswordAuthentication no to disable password logins, and confirm with sshd -T that the setting took effect. To check for exploitation: look in /var/log/messages for Accepted password for entries that correspond to a no-password account; the official advice is blunt — if you cannot rule out that a login happened, treat the machine as compromised.

Worth recording: the discovery process itself is an AI story. Kültekin built sshd test environments across multiple combinations — glibc, musl, with and without PAM, with and without shadow — and fired roughly 17,600 deliberately crafted login tests at them, covering abnormal hash values, corrupted accounts, and ultra-long passwords. On his page he added: “Sorry for saying ‘I’ — what was running was a fleet of AI agents.” The OpenSSH team's posture is a signal too: project member Damien Miller said they have recently been receiving a flood of vulnerability reports produced by or with the help of AI models, and the team has moved to a more frequent release cadence to get fixes to users as fast as possible — because AI agents have already independently reproduced the same flaw within hours, long-term secrecy favors the attackers.

For operators, this is one of the quietest risks: the trigger conditions are strict, but they land exactly where you never think to look — the base images inside your containers, cloud vendors' tiny-cloud images, OpenWrt gateways on the network edge. The fix itself is routine three-step work: update the package, restart sshd, verify the sshd -T output and audit the login logs. The real cost is on the other side: the base images in your registry that were built years ago and nobody remembers to refresh are where a flaw like this actually lives. When AI agents compress the “flaw gets found” cycle to days, patching can no longer mean “wait for the next maintenance window.”

💡 LAFA Perspective

*sshole is a case study: the weakest link is always the account nobody is managing. LAFA's 24/7 AI operations turns patch verification, sshd restart, configuration checks and login-log audit into a single flow, and continuously scans container base images and cloud images for unpatched Alpine — in the AI vulnerability era, patch deadlines should be measured in hours, not months.