Anyone who had a Pentium powered
computer back in 1994 might remember a certain processor bug where
math computations were just a bit off after a certain amount of
digits. Intel was quick to squish the problem in the face of bad
publicity, even though the error probably didn't effect 99% of the
users that had one.
Recently one of the original authors of the RSA
encryption algorithm, Adi Shamir of Weizmann Institute in Israel, noted that such a bug, if known about, could be used to break the
venerable RSA encryption technique, as well as many other of the more
modern ones.
RSA is a public-key encryption method.
Messages are encrypted using a public key, and decrypted with a
private key. Only the recipient can decode the original encoded
message via his private key, not even the original sender can do so.
Anyone who happens to be in possession of the target's private keys
could also read the message, but that's another horse entirely.
Simple encrypted messages don't pose
much of a risk, but authentication is where processor flaws can be
exploited. During authentication a message must go both ways (handshake) or the user will
never know if he's actually dealing with a secure site or not. This
message, when decrypted with the proper private key, will have a
known result. The result is then sent back to the original sender. If
it matches up, chances are that the site he's hooked to is indeed
secure, as the private keys were what they were expected to be.
There is a way, however, for a
malicious intrusion to uncover the private keys using a known
processing flaw, such as the one in those ill-fated Pentiums from
1994. An encrypted message can be written in such a way that it will
force the processor to perform the calculation error it is known to
have. The results will come back as unauthenticated because they are
not what the sender expected. However, since the processor flaw
induced a known error into the results, the error can be used to
mathematically deduce the private key used to decrypt the original
authentication message. Once the private keys are known, traffic can
be intercepted by an interested party with the stolen key, decrypted
and used for less than wholesome purposes.
The likelihood of such an attack
working is certainly very slim as there haven't been any publicly
announced processing flaws in recent years. There are also ways to
protect against a poisoned attack like this, such as returning the
same authentication message to the sender and matching the results.
If the results differ, the user could be the victim of such an
attack. Many encryption programs already do this sort of double
check.
While there's little reason to fear
such an attack presently, an exploit of this nature could cost
companies vast amounts of money if their private keys are stolen. The
average desktop user could suffer if he does a lot of online
purchasing, bill paying, or banking, should one of those
institution's keys be snooped.
Processor manufacturers like Intel and
AMD certainly work diligently to ensure there are no flaws in their
chips these days, but there will probably always be someone ready to
exploit such a thing if found. Until then, users can probably feel
safe with current RSA strategies, for the most part.