Four thousand and ninety six bits, and why the number misleads

Key sizes get quoted like scores. The size itself is a plain fact. Any claim that a bigger size means a better key is a judgement, and the assumption behind it usually goes unsaid, so this page says it.

4096 bits in an RSA key Judged
Value
4096 bits, an RSA key length
Kind
Judged. Size only means something inside one algorithm
Assumption
That the comparison is RSA against RSA. Across algorithms it breaks
Changes with
The algorithm, not the market and not the holder

Mars market addresses

Published, not monitored
mars24pas2vgwtr4drrsy7tlngevbvxyguejynnkeywibjzenet7knqd.onion
marsautbk3di5cj75eh4dakjjrngddnjwqfdltbq2sy6cf7unzkd2bad.onion
marsautkudspgk6j23cxdtrk36ae4fpis2eoe7izu5y2rsksvmfji2ad.onion

These three addresses are printed as given. This site does not test them, does not know whether any of them answers right now, and publishes no availability figure. An address that opens is not the same thing as an address that is genuine, which is what the forty character fingerprint is for.

Where the 4096 comes from

It is a common RSA key length, twice the 2048 that current guidance still treats as adequate for ordinary use. RSA sizes cluster on powers of two by convention rather than by necessity, so the ladder people actually climb runs 1024, 2048, 4096, and generating something in between is possible and almost nobody does it.

Nothing derives 4096 from a threat model. It is the next rung, picked by people who wanted margin and did not want to think about the question again. That is a defensible reason and it is not a calculated one, which is why this page carries the judged chip while the rest of the section is counted. The split is set out on the counted and judged page.

What 4096 bits actually buy

Less than the doubling suggests. The difficulty of factoring does not scale with key length in any way a reader can take off the number. Moving from 2048 to 4096 adds margin measured in decades of estimated headroom rather than doubling anything, and the estimates themselves are soft enough that arguing over them is a waste of an afternoon.

The cost is easier to state precisely. Operations with a 4096 bit key run several times slower than with a 2048 bit key, signatures and encrypted blocks are larger, and on small hardware the difference shows. For somebody signing a few messages a week the cost is irrelevant. That is worth saying plainly, because the case against 4096 is not that it is dangerous.

So the honest summary is a modest amount of future proofing at a modest price, in exchange for nothing else. A larger key is not harder to steal, does not make its holder more careful, and does not make a signed statement any more true.

What people read into 4096

The first misreading is ranking. Vendors and services get compared on key size as though it were a specification sheet. The size tells you which ladder somebody climbed and nothing else, and almost every failure in this subject happens elsewhere: a private key on a machine other people can reach, a passphrase reused from somewhere it should not have been, a signature nobody bothered to check, an identity accepted on the strength of eight hex characters.

The second is the cross algorithm mistake, which is the reason this page exists. A 256 bit key on a modern elliptic curve is not weaker than a 4096 bit RSA key. By the usual estimates it is stronger, and it is faster, and its signatures are far smaller. The two numbers are not on one scale because they count different things.

A bigger number can therefore sit on a weaker key. That is the sentence to take away from the page. The 256 in a curve key and the 4096 in an RSA key are as comparable as a shoe size and a temperature, and reading the smaller one as a warning gets the ranking exactly backwards.

The third error is quoting a size that belongs to the wrong key. A key can carry subkeys of different sizes, and the figure your tool shows may describe the primary key while the signing happens on a subkey. If you are going to quote a size at all, quote the one doing the work.

What moves the 4096

The algorithm and the research around it. Guidance shifts as factoring and curve work shift, on a scale of a decade. Nothing a market does affects it, nothing a vendor does affects it, and no existing key becomes weaker because a paper was published about a different scheme.

The other thing that moves is what tools generate by default. Defaults drifted toward curve keys years ago, so the mix of keys anybody meets changes without a single person deciding anything. A key made today is more likely to be 256 bits than 4096, and that says more about the software than about the taste of the holder.

None of it changes what you should be checking. Length is not the check. The fingerprint is the check, and it is the same forty characters whatever algorithm sits behind it.

The one rule hereComparing key sizes across algorithms produces confident nonsense. Inside one algorithm the comparison is fair and dull. Across the boundary it means nothing.

Questions people ask

Is 2048 bit RSA a problem?

Not on current guidance for ordinary use. The gap between 2048 and 4096 is far smaller than the gap between a key that gets verified and a key that never does.

Why is this page judged when the size is a fact?

Because the bare number is inert. Everything people do with it, ranking and comparing and reassuring themselves, rests on an assumption about algorithms that has to be chosen first.

Should I regenerate at a larger size?

Size is rarely the weak part. Where the key lives and whether anybody ever compares it against a stored fingerprint matter far more, and the forty page covers the second.