### RSA public exponent size (16 Mar 2012)

RSA public operations are much faster than private operations. Thirty-two times faster for a 2048-bit key on my machine. But the two operations are basically the same: take the message, raise it to the power of the public or private exponent and reduce modulo the key's modulus.

What makes the public operations so much faster is that the public exponent is typically tiny, while the private exponent should be the same size as the modulus. One can actually use a public exponent of three in RSA, and clearly cubing a number should be faster than raising it to the power of a 2048-bit number.

In 2006, Daniel Bleichenbacher (a fellow Googler) gave a talk at the CRYPTO 2006 rump session where he outlined a bug in several, very common RSA signature verification implementations at the time. The bug wasn't nearly as bad as it could have been because it only affected public keys that used a public exponent of three and most keys used a larger exponent: 2^{16}+1. But the fact that a slightly larger public exponent saved these buggy verifiers cemented 2^{16}+1 as sensible default value for the public exponent.

But there's absolutely no reason to think that a public exponent larger than 2^{16}+1 does any good. I even checked that with Bleichenbacher before writing this. Three should be fine, 2^{16}+1 saved some buggy software a couple of times and any larger is probably a mistake.

Because of that, when writing the Go RSA package, I didn't bother supporting public exponents larger than 2^{31}-1. But then several people reported that they couldn't verify some DNSSEC signatures. Sure enough, the DNSKEY records for `.cz` and `.us` are using a public exponent of 2^{32}+1.

DNSSEC is absolutely the last place to use large, public exponents. Busy DNS resolvers have to resolve tens or hundreds of thousands of records a second; fast RSA signature verification is big deal in DNSSEC. So I measured the speed impact of various public exponent sizes with OpenSSL (1.0.1-beta3):

Public exponent | Verification time (µs) |
---|---|

3 | 10.6 |

2^{16}+1 | 23.9 |

2^{32}+1 | 42.7 |

2^{127}-1 | 160.7 |

So a public exponent of 2^{32}+1 makes signature verification over four times slower than an exponent of three. As DNSSEC grows, and DNSSEC resolvers too, that extra CPU time is going to be a big deal.

It looks like the zones using a value of 2^{32}+1 are just passing the `-e` flag to BIND's `dnssec-keygen` utility. There's some suggestion that `-e` used to select 2^{16}+1 but silently changed semantics in some release.

So today's lesson is **don't pass -e to dnssec-keygen**! The default of

`dnssec-keygen`is 2

^{16}+1 and that's certainly safe. The

`.com`zone uses a value of three and I think that's probably the best choice given the CPU cost and the fact that the original Bleichenbacher bug has been long since fixed.