The SSH Vulnerability That Might Break Your Off-Chain Infrastructure

A newly disclosed OpenSSH authentication bypass could expose Alpine-based infrastructure to unauthorized access. Here's how it works, who's affected, and how to protect your systems.

Editor:

Paikin

On November 5, 2026, Özgün Kültekin disclosed *sshole, a cheekily named bug whose asterisk nods to the character that makes the exploit possible. It lets attackers log into some SSH servers just by typing a password that’s too long.

It affects systems built on musl, most notably Alpine Linux, and Alpine is also used in Web3 infrastructure, including container images and custom server environments. For example, the official Docker images for Geth, op-geth, BNB Smart Chain, and LND all run on it, and Polygon ships native Alpine packages for its nodes. Using Alpine does not automatically make a system vulnerable. A custom image with OpenSSH added for debugging or an Alpine host used to operate nodes and validators may be exposed if the required conditions are present.

In an industry where a single leaked key means funds are gone for good, a critical vulnerability in OpenSSH must be addressed.

How Does the *sshole OpenSSH Vulnerability Work?

The way the vulnerability happens is kind of funny. It all started when Unix began using an * character as a hash placeholder for an account that should not be able to sign in.

A few years later, the developers of musl (a libc implementation) decided to modify crypt(), the function that is used in the login checks in Linux, to return an * when a login is invalid, instead of NULL. Also, a few weeks after that, long passwords (longer than 256 characters) were limited, to avoid overloading the server - returning an for a long password.

Finally, a few years later, a fix for a user enumeration vulnerability was introduced, and this fix uses an existing user’s salt for logins. The result was using crypt() for invalid logins, returning true and bypassing the login.

More specifically, when OpenSSH runs without PAM, it uses crypt() to check the submitted password. If the account has no usable password hash, OpenSSH uses the salt from another account with a valid password hash. On musl, a password longer than 256 bytes causes crypt() to return *. Since * is also the stored password field for an account without a password, the comparison succeeds and authentication is bypassed.

The issue was fixed in OpenSSH 10.6p2. The original Wakefield research explains the discovery and technical details.

What Does *sshole Mean for Web3 Infrastructure?

The important distinction is that using Alpine does not automatically make a node or validator vulnerable. The vulnerability affects the SSH server. For example, a container running only Geth without an SSH server is not affected. An Alpine-based host or custom container that runs OpenSSH may be, depending on its configuration.

For teams operating their own nodes and validators, the practical step is to check the actual hosts and images used for administration and debugging. Find where sshd is running and verify whether it uses musl, whether PAM is disabled, and whether password authentication is enabled.

The vulnerability does not affect consensus logic, smart contracts, or transaction processing directly. The concern is unauthorized access to the server and the systems, credentials, and services that the compromised account can reach.

So, your main question must be: Am I even affected by it, and should I even care?!

Let’s answer it with a simple checklist (adapted from the researcher’s checklist):

bool musl = is your sshd running on musl?; // (alpine, openwrt, buildroot, yocto) bool notPam = is it not using pam?; // alpine's openssh-server doesn't by default, or maybe you set UsePAM no bool hasPasswordLogins = are password logins still on?; // They are by default bool *passwordAccounts = is there an account with just * as its password?; // key-only users, ldap users, root on alpine bool unPatched = is openssh older than 10.6p2?; if (musl && notPam && hasPasswordLogins && starPasswordAccounts && unPatched){ emit Result("Vulnerable to *sshole."); } else { emit Result("You’re good"); }

If all these conditions are met, an attacker who can reach the SSH port can authenticate using a password between 257 and 1,024 bytes long.

Checking whether OpenSSH is older than 10.6p2 is not enough. Distributions may backport the fix to older package versions. Check the security advisory for your distribution to confirm whether your installed package is patched.

If you can, upgrade OpenSSH immediately. If you can’t, disable SSH password logins.

On Alpine, the official security advisory recommends updating the package and restarting sshd. Updating the package alone does not replace the running daemon. If you cannot update immediately, set PasswordAuthentication no and restart sshd.

If you suspect that an affected server has already been accessed, check SSH authentication logs for successful password logins to accounts that should not accept password authentication. The Alpine advisory also provides guidance on what to look for in the logs and how to investigate possible access.

Securing the infrastructure behind smart contracts

At Certora, we treat security as a whole-system discipline. Smart contracts are only as safe as the infrastructure that runs, signs, and relays for them, which is why we pair formal verification of on-chain logic with security reviews of off-chain components, from node deployments to key management.

That includes taking vulnerabilities like *sshole seriously. The name is a joke. Leaving it unpatched would be a bad one.

Contact us to identify security risks in the infrastructure behind your smart contracts.

Get every blog post delivered

Certora Logo
logologo
Terms of UsePrivacy Policy