
Unlike symmetric cryptography, public key cryptography uses two different keys 
one public and one private. The keys are mathematically related, yet
it is computationally infeasible to deduce one from the other. Anyone with
the public key can encrypt a message but not decrypt it. Only
the person with the private key can decrypt the message.
Bruce Schneier compares publickey cryptography with a mailbox. He writes:
"Putting mail in the mailbox is analogous to encrypting with the public key;
anyone can do it. Just open the slot and drop it in. Getting mail out of a mailbox
is analogous to decrypting with the private key. Generally it's hard; you need welding torches.
However, if you have the secret (the physical key to the mailbox), it's easy to get
mail out of a mailbox." [1]
Using publickey cryptography, Alice and Bob can communicate
securely using the following simple protocol:
 Alice and Bob agree on a public key algorithm.
 Bob sends Alice his public key.
 Alice encrypts her message with Bob's public key and sends it to Bob.
 Bob decrypts Alice's message with his private key.
Notice that this protocol does not require any prior arrangements (such
as agreeing on a key) for Alice and Bob to communicate securely.
In realworld implementations, public keys are rarely used to encrypt
actual messages as publickey cryptography is very slow,
about 1000 times slower that conventional cryptography [1]. Instead,
publickey cryptography is used to distribute symmetric keys which are then used
to encrypt and decrypt actual messages, as follows:
 Bob sends Alice his public key.
 Alice generates a random symmetric key (usually called a session key), encrypts it with Bob's
public key and sends it to Bob.
 Bob decrypts the session key with his private key.
 Alice and Bob exchange messages using the session key.
Systems that use both symmetric and publickey cryptography
in this manner are called hybrid.
Certain publickey algorithms such as RSA allow
both the public and private key to be used for encryption. If a message
is encrypted with someone's private key it can
only be decrypted with the corresponding public key.
This feature can be used to create digital signatures, as follows:
 Alice encrypts the document with her private key. The encrypted
document becomes her digital signature.
 Alice sends the signature to Bob.
 Bob decrypts the document with Alice's public key thereby verifying
the signature.
Once again, encrypting an actual message with a private key is very inefficient.
Instead of signing the entire document, the document's hash can be signed,
as follows:
 Alice computes a oneway hash of a document.
 Alice encrypts the hash with her private key. The encrypted
hash becomes the document's signature.
 Alice sends the document along with the signature to Bob.
 Bob produces a oneway hash function of the document received from
Alice, decrypts the signature with Alice's public key and compares the two values.
If they match, Bob knows that: (1) the document really came from Alice and (2) the document
was not tampered with during transmission.
RSA is by far the most popular publickey cryptography algorithm.
It supports both encryption and digital signatures. It is also the easiest
one to describe and implement. RSA has withstood years of
extensive cryptoanalysis and is a de facto standard in much of the World [1].
RSA is named after the three inventors  Ron Rivest,
Adi Shamir and Leonard Adleman.
In RSA, a public key is based on the product of two large prime numbers. These two
numbers must be kept secret as they are used to compute the private key.
The product of the two prime numbers is referred to as modulus.
The security of RSA lies in the difficulty of factoring large numbers.
The Microsoft Base Cryptographic Provider implements RSA with a 512bit
modulus. With the Microsoft Enhanced and Strong Providers, the default modulus
is 1024 bits, and valid moduli can be in the range of 384 bits to 16,384 bits in 8 bit increments.
The hybrid communication protocol described above is vulnerable to a maninthemiddle
attack. Let's assume that Mallory, an enemy hacker, not only can listen to
the traffic between Alice and Bob, but also can modify, delete, and substitute
Alice's and Bob's messages, as well as introduce new ones.
Mallory can impersonate Alice when talking to Bob and impersonate Bob
when talking to Alice. Here is how the attack goes:
 Bob sends Alice his public key. Mallory intercepts the key and sends his
own public key to Alice.
 Alice generates a random session key, encrypts it with "Bob"'s public
key (which is really Mallory's) and sends it to Bob.
 Mallory intercepts the message. He decrypts the session key
with his private key, encrypts it with Bob's public key and sends it to Bob.
 Bob receives the message thinking it came from Alice. He decrypts it
with his private key and obtains the session key.
 Alice and Bob start exchanging messages using the session key. Mallory,
who also has that key, can now read the entire conversation.
A maninthemiddle attack works because Alice and Bob have no way
to verify they are talking to each other. An independent
third party that everyone trusts is needed to foil the attack.
This third party could bundle the name "Bob"
with Bob's public key and sign the package with its own private key.
When Alice receives the signed public key from Bob, she can verify
the third party's signature. This way she knows that the public key
really belongs to Bob, and not Mallory.
A signed package containing a person's name (and possibly some other information
such as an email address and company name) and his/her public key is called
a digital certificate (or digital ID). An independent third party that everyone
trusts whose responsibility is to issue certificates is called a
Certification Authority (CA). Digital certificates are the topic of the
next chapter.




