## The Idea Behind Asymmetric Cryptography

In the 1970s Martin Hellman, Whitfield Diffie, and, independently, Ralph Merkle invented a beautiful cryptographic idea. Their idea was to solve the key exchange and trust problems of symmetric cryptography by replacing the single shared secret key with a pair of mathematically related keys, one of which can be made publicly available and another that must be kept secret by the individual who generated the key pair. The advantages are obvious. First, no key agreement is required in advance, since the only key that needs to be shared with the other party is a public key that can be safely shared with everyone. Second, whereas the security of a symmetric algorithm depends on two parties successfully keeping a key secret, an asymmetric algorithm requires only the party that generated it to keep it secret. This is clearly much less problematic. Third, the issue of trusting the other party disappears in many scenarios, since without knowledge of your secret key, that party cannot do certain evil deeds, such as digitally sign a document with your private key or divulge your secret key to others.

Asymmetric cryptography does not replace symmetric cryptography. Rather, it is important to recognize the relative strengths
and weaknesses of both techniques so that they can be used appropriately and in a complementary manner. Symmetric algorithms
tend to be much faster than asymmetric algorithms, especially for bulk data encryption. They also provide much greater security
than asymmetric algorithms for a given key size. On the down side, symmetric key cryptography requires that the secret key
be securely exchanged and then remain secret at both ends. In a large network using symmetric encryption many key pairs will
proliferate, all of which must be securely managed. Because the secret key is exchanged and stored in more than one place,
the symmetric key must be changed frequently, perhaps even on a per-session basis. Finally, although symmetric keys can be
used for message authentication in the form of a keyed secure hash, the full functionality of a digital signature requires
asymmetric encryption techniques, such as RSA or *DSA*. As we shall see in the next chapter, a symmetric keyed secure hash algorithm can be used to implement a *MAC* (Message Authentication Code), which provides authentication and integrity but not nonrepudiation. In contrast, asymmetric
digital signature algorithms provide authentication, integrity, and nonrepudiation, and enable the services of certificate
authorities (CAs).

#### Using Asymmetric Cryptography

To use asymmetric cryptography, Bob randomly generates a public/private key pair.^{4} He allows everyone access to the public key, including Alice. Then, when Alice has some secret information that she would
like to send to Bob, she encrypts the data using an appropriate asymmetric algorithm and the public key generated by Bob.
She then sends the resulting ciphertext to Bob. Anyone who does not know the matching secret key will have an enormously difficult
time retrieving the plaintext from this ciphertext, but since Bob has the matching secret key (i.e., the trapdoor information),
Bob can very easily discover the original plaintext. Figure 4-1 shows how asymmetric cryptography is used.

**Figure 4-1. How asymmetric cryptography is used.**

#### The Combination Lock Analogy

A traditional symmetric cipher is analogous to a lockbox with a combination lock that has one combination used both to open
it and close it.^{5} The analogy for an asymmetric cipher is a somewhat stranger device: The single lock has two distinct combinations, one for
opening it and another for closing it. By keeping one of these combinations secret and making the other combination public,
you can effectively control who can place or remove the contents in the lockbox. This added flexibility supports two useful
scenarios: confidentiality without prior key exchange and data integrity enforcement.

#### CONFIDENTIALITY WITHOUT PRIOR KEY EXCHANGE

Here is the first scenario. If you know the public combination for closing the lock but not the private combination for opening
the lock, then once you have placed something into the box and locked it, it becomes impossible for anybody who does not know
the private opening combination^{6} to obtain the contents. This demonstrates spontaneous confidentiality (i.e., keeping a secret without prior key exchange).
Hence, we have a solution to the key exchange problem described earlier.

#### ENFORCING DATA INTEGRITY

The other scenario is if only you know the private combination for closing the lock, and you place contents into the lockbox and then lock it. Then anyone can open the lock, but nobody else can lock other contents into the lockbox, since nobody else knows the private combination for closing the lock. Therefore, nobody else can tamper with its contents and then close the lock again. You might think that this is easy to defeat, since anyone could easily create his or her own key pair and then lock any data into the lockbox. However, only the newly created public key would then work, and the original public key would fail to unlock the lockbox. Therefore, anyone with knowledge of the original public key would not be fooled by such an attack. Since tampering is detectable, this scenario demonstrates how data integrity can be enforced.

#### Trapdoor One-Way Functions

There are several asymmetric algorithms that make use of this great idea, but all these algorithms have certain mathematical
characteristics in common. In each case an asymmetric algorithm is based on a type of function first suggested by Diffie and
Hellman that has special properties known as *trapdoor one-way functions*. A trapdoor one-way function, if given some additional secret information, allows much easier computation of its inverse
function.

Before discussing what a trapdoor one-way function is, let's look at the broader class of one-way functions.^{7} A one-way function is a mathematical function that is highly asymmetric in terms of its computational complexity with respect
to its inverse function. Such a function is easy to compute in the forward direction but diabolically difficult to compute
in the inverse direction. Such functions are based on *hard* mathematical problems, such as factoring large composites into prime factors, the discrete log problem, and the knapsack
problem. The inherent difficulty of such problems falls under the branch of mathematics known as complexity theory, which
is beyond the scope of this book. Suffice it to say that the difficulty of these problems grows rapidly in relation to the
magnitude of the numbers (which correspond to the key size used in the corresponding cryptographic algorithm) involved.

While finding a solution to the mathematical problem on which a one-way function is based, it is very easy to test if a proposed
solution is correct. Imagine yourself working on a large jigsaw puzzle, and you want to find the piece that belongs in a particular
position. It might take you a long time to find the correct piece, but at any time that you believe you have good candidate,
it takes very little effort to test it out. For a mathematical example, consider the problem of finding all of the prime^{8} factors of a large composite number. This is believed to be very difficult,^{9} but if you are given the prime factors, testing them is a simple matter of multiplying them together and comparing the result
with the original large composite number. To convince yourself of this, imagine trying to find all the prime factors of the
composite number 3431 with only pencil and paper to work with. Without the aid of a computer, most people would take several
hours to do this. However, if you were asked to test the candidate solution of 47 and 73, you would probably take only a few
seconds to show that indeed they do multiply to produce the resulting value of 3431. Now consider that the number 3431 can
be represented with a mere 12 bits. What if you tried this experiment with a 1024-bit number? Finding the prime factors is
a problem that grows exponentially with bit size (think in terms of billions or trillions of years on a supercomputer), whereas
testing a solution grows at a very moderate rate with bit size (microseconds or milliseconds on a personal computer).

The term one-way function is slightly misleading, since by definition, a cipher can only be based on a mathematical function that is invertible, meaning that its inverse function does indeed exist. After all, if a cipher were based on a function that had no inverse, you could encrypt data, but then you could not reliably decrypt that data. However, in practice, the inverse of a one-way function is so difficult to compute that the mere fact that the inverse function exists is of no help whatsoever in computing its value. Such a function is theoretically two-way, but, in practical terms, it is effectively one-way.

Now let's add in the idea of a trapdoor. A trapdoor turns something that is normally very difficult into something that is very easy, provided that you know a powerful little secret. This is analogous to a haunted house where the bookshelf revolves, opening a hidden passageway, but you first need to know that it exists and that the secret to opening it is to pull on the candelabra three times. A one-way function that has the additional property that its inverse function suddenly becomes very easy to compute provided an additional piece of secret information is known (i.e., a private key) becomes a trapdoor one-way function. You can think of a trapdoor one-way function as a haunted mathematical function if you like.

There are many one-way functions to choose from in mathematics, but finding one that allows you to incorporate the all-important
backdoor is not so easy. A few candidates have been discovered that are convenient and appear to be secure. Finding those
algorithms that are also efficient enough to be practical and use keys of a reasonable size reduces the candidates further.
Examples of successful trapdoor one-way functions are the discrete log problem, which forms the basis of the *DSA* algorithm, and the factoring of large composites into prime factors, which forms the basis of the RSA algorithm.

#### Advantages of the Asymmetric Approach

With the asymmetric (also known as public key) approach, only the private key must be kept secret, and that secret needs to
be kept only by one party. This is a big improvement in many situations, especially if the parties have no previous contact
with one another. However, for this to work, the authenticity of the corresponding public key must typically be guaranteed
somehow by a trusted third party, such as a *CA*. Because the private key needs to be kept only by one party, it never needs to be transmitted over any potentially compromised
networks. Therefore, in many cases an asymmetric key pair may remain unchanged over many sessions or perhaps even over several
years. Another benefit of public key schemes is that they generally can be used to implement digital signature schemes that
include nonrepudiation. Finally, because one key pair is associated with one party, even on a large network, the total number
of required keys is much smaller than in the symmetric case.

#### Combining Asymmetric and Symmetric Algorithms

Since there is no secret key exchange required in order to use asymmetric algorithms, you might be tempted to solve the symmetric key exchange problem by simply replacing the symmetric algorithm with an asymmetric algorithm. However, that would be like throwing the baby out with the bath water. We still want to take advantage of the superior speed and security offered by symmetric algorithms, so, instead, we actually combine the two (and sometimes more than two) algorithms.

For example, Microsoft Outlook and Netscape Communicator implement secure email using the S/*MIME* (Secure/Multipurpose Internet Mail Extensions) specification. S/*MIME* is an *IETF* standard that supports both digital signatures for authentication and encryption for privacy. S/*MIME* provides bulk message data encryption using any of several symmetric algorithms, including *DES*, 3DES, and RC2. Secure symmetric key exchange and digital signatures are provided by the RSA asymmetric algorithm as well
as either of the MD5 or SHA-1 hash algorithms.

As another example, the popular *PGP* software (developed by Philip Zimmermann) provides cryptographic services for email and file storage by combining several
algorithms to implement useful cryptographic protocols.^{10} In this way, message encryption and digital signatures are provided to email clients using an assortment of selected symmetric,
asymmetric, and hash algorithms. RSA or ElGamal are used for *PGP* session key transport. 3DES is one of several alternatives used for bulk *PGP* message encryption. *PGP* digital signatures use either RSA or *DSA* for signing and MD5 or SHA-1 for generating message digests.

There are several other protocols that are built in a hybrid manner by combining asymmetric and symmetric algorithms, including
IPSec (IP Security Protocol) and *SSL* (Secure Sockets Layer). IPSec is an *IETF* standard that provides authentication, integrity, and privacy services at the datagram layer, allowing the construction of
virtual private networks (VPNs). The *SSL* protocol, developed by Netscape, provides authentication and privacy over the Internet, especially for *HTTP* (Hypertext Transfer Protocol).