GitHub SSH Brownout: Your RSA Key May Not Be the Problem

Before GitHub’s November 4 SSH brownout, distinguish an RSA key from an RSA/SHA-1 signature. Diagnose the client, negotiation stage and actual repository path.

Share
Orange security key approaching a cryptographic gateway beside the headline Your RSA Key May Be Fine on a charcoal background

Editorial disclosure: This is an AI-prepared, documentation-based explainer, not a personally reproduced incident. Commands and diagnostic scenarios below are illustrative and have not been executed against GitHub for this article. See the editorial policy.

The public key starts with ssh-rsa. The migration notice says ssh-rsa is going away. Replacing the key looks like the obvious fix.

That conclusion skips the important detail: a key's format and the algorithm used to sign with it are different things. An RSA key can remain usable while the client that holds it becomes incompatible. Rotate the credential without fixing that client, and you can preserve the failure with a brand-new key.

GitHub has announced an SSH brownout for November 4, 2026. This is a preparation guide written on November 3, not a report that the brownout has already occurred.

What is changing, and when

GitHub's September 22 announcement schedules temporary removal of RSA/SHA-1 signatures and diffie-hellman-group-exchange-sha256 on November 4 and December 9, followed by permanent removal on January 13, 2027. It gives dates, not precise brownout hours. Check the announcement for changes before interpreting an outage.

The separate rule requiring newly uploaded RSA keys to be at least 3072 bits took effect October 14. That upload requirement is not a statement that every existing smaller RSA key is being revoked in November. HTTPS Git remotes are outside this SSH change. GitHub lists Enterprise Server 3.25 for these removals; do not apply the cloud calendar to every self-hosted instance.

The same name describes two different things

RFC 8332 specifies RSA signatures using SHA-256 and SHA-512 while retaining the existing RSA public-key encoding. That is why a key file beginning with ssh-rsa does not establish that the connection uses SHA-1.

What you seeWhat it tells you
ssh-rsa at the start of a public-key fileThe public key is RSA; this alone does not identify the negotiated hash
ssh-rsa as a signature algorithmThe RSA signature uses SHA-1
rsa-sha2-256 or rsa-sha2-512An RSA signature uses SHA-256 or SHA-512

This is not a newly invented escape hatch. The OpenSSH 8.8 release notes, dated September 26, 2021, explain its default removal of RSA/SHA-1 and say existing RSA keys can use stronger signatures. OpenSSH has supported those signatures since 7.2. That historical compatibility floor is not a recommendation to deploy an obsolete OpenSSH release today.

The practical consequence is a different inventory question. “Which keys are RSA?” identifies credentials. “Which process actually signs with them, using which algorithm?” identifies exposure to this migration. A laptop, a CI checkout plugin and a deployment appliance may all use the same kind of key through different SSH implementations.

Find the first failed stage

SSH does more than check whether your account has a key. The peers negotiate a transport, the client checks the server's identity, and the server authenticates the user. Treating all three as “SSH authentication” makes the wrong fix look plausible.

Observed failureNext questionWhy key rotation may miss it
No matching key exchange methodWhich KEX algorithms can this client and server both use?The session has not reached user-key authentication
No matching host key type, or a host identity warningCan the client verify this server with an accepted algorithm and trusted fingerprint?The server's identity is separate from your uploaded key
Permission denied (publickey)Which identity was offered, and could it sign with an accepted algorithm?Wrong account, missing key and signature incompatibility can end at the same broad symptom
SSH identity check succeeds, repository access failsDoes that identity have access to this exact repository?Authentication success does not grant every repository permission

This table is a diagnostic interpretation, not a claim that every matching error is caused by the brownout. Keep the first relevant failure and its preceding negotiation evidence. The last line of a failed checkout is often less useful than the stage that made success impossible.

Inspect the environment that actually runs Git

Start in the checkout or deployment environment, under the same operating-system user. These commands are illustrative; substitute your actual remote alias where appropriate:

git remote -v
git config --show-origin --get core.sshCommand
ssh -V
ssh -G github.com
ssh -vvT git@github.com

Git's environment documentation describes GIT_SSH and GIT_SSH_COMMAND, which can select a different executable or command. Check those environment settings privately as well as repository configuration. A successful terminal test is weak evidence about a Java plugin that uses an embedded SSH library.

For OpenSSH, the ssh manual documents -G for evaluated configuration and -v for debugging. The configuration output helps find restrictions on KexAlgorithms, HostKeyAlgorithms and PubkeyAcceptedAlgorithms. It is not a negotiation transcript: configured possibilities do not prove which signature was used.

Read the verbose connection in order. Identify the selected key exchange and server host-key algorithm separately from the identity offered for user authentication. Where the client reports its signing algorithm, that is stronger evidence than the key filename. If it never offers the intended identity, solve that before attributing the rejection to SHA-1.

GitHub's public-key troubleshooting guide also covers the ordinary failures this rollout will not fix: connecting as the wrong user, running Git with a different account's keys, and not attaching the public key to the intended GitHub account. On github.com the SSH user is git, not your GitHub username.

A green SSH probe can still fool the deployment

GitHub's connection test intentionally does not provide a shell. Its successful authentication message can accompany exit code 1. A health check that accepts only zero will classify that documented success as a failure.

The reverse mistake is accepting any nonzero result because GitHub's test sometimes returns 1. Verify the authenticated identity in the response, then perform a read-only operation against a repository the deployment is meant to access. The identity probe answers “who am I?”; repository access answers a different question.

For example, run git ls-remote origin from the intended checkout context. It reads remote references without pushing changes. If submodules or separate deployment repositories use different remotes, one successful probe does not cover those paths. This is a proposed validation procedure, not a result measured for this article.

Fix the capability, then prove the path

Upgrade the actual SSH implementation to a supported release and remove configuration that pins it to a retired algorithm. Prefer evidence from the failing execution path over changing every credential speculatively. For a new key, GitHub recommends Ed25519 where possible; an RSA key uploaded now must meet its current size requirement.

Do not copy an old workaround that appends +ssh-rsa and assume it restores compatibility. That setting permits a legacy algorithm on your side; it cannot make a server accept an algorithm the server has removed. Likewise, changing HostKeyAlgorithms does not select the signature for your user credential. The OpenSSH configuration manual defines those controls separately.

Keep host verification intact. A host-key warning calls for checking the expected fingerprint, not deleting trust records until the command stops complaining. And keep the replacement path tested before removing an old credential: changing two independent variables at once makes a failed migration harder to diagnose.

Debugly's workflow-policy explainer covers failures before a runner starts. This migration is a different boundary: a job may start normally and fail when its Git transport negotiates SSH. The useful habit is the same. Establish how far the request got before deciding what to repair.

Before the brownout, record the real client, effective configuration, intended identity and repository probe result for each deployment path. Recheck them during the announced window. An ssh-rsa prefix in a key file is an inventory fact. The negotiated signature is the compatibility fact.