- Fortification
- Validation
- Auditing
- Authentication
- Privacy
- Integrity
- Nonrepudiation
- Authorization
- Summary

## 7.4 Authentication

*Authentication* refers to the procedure we go through to convince ourselves that somebody is who he or she claims to be. We have two fortresses in a trust relationship: Ed the envoy's fortress and Gwen the guard's fortress. Neither fortress wants to talk to Bart the bad guy. But how does Gwen know that she is talking to Ed, and not to Bart pretending to be Ed? For that matter, how does Ed know that he is really talking to Gwen, and not to Bart pretending to be Gwen? It is just one more task we're going to add to Gwen's ever expanding list of responsibilities: to be sure that when she thinks she is talking to Ed, she really is talking to Ed. Depending on how paranoid Ed is, he can also take on the problem of being sure that Gwen is really Gwen.

There are generally two approaches to authentication: (1) through a shared key (symmetrical encryption) or (2) through a public/private key (asymmetrical encryption). Both are based on encryption/decryption algorithms; let's look at this class of algorithms.

Encryption and decryption are mirror images of each other. Encryption means taking some text and an encryption key and returning garbled text. Decryption means taking that same garbled text along with a decryption key and returning the original text. The two processes are illustrated in Figure 7.3.

**Figure 7.3. Encryption and Decryption Phases**

The difference between a shared-key system, like Kerberos, and public/private–key systems, like secure sockets, is whether or not the decryption key is the same as the encryption key. For shared-key systems, the two keys are the same. For public/private–key systems, the two keys are different, although algorithmically related.

For shared-key systems, both parties (in this case Ed and Gwen) store a secret key (often corresponding to a password) with a trusted third-party authenticator, whom I will call Al. Both Ed and Gwen trust Al to keep each of their secret keys a secret.

When Ed wants to talk to Gwen, he asks Al the authenticator for a "ticket" to use Gwen. In response, Al gives Ed a ticket to use Gwen. The ticket contains information about Ed and a temporary key called a *session key*. That ticket is encrypted with Gwen's secret key, which only Gwen and the authenticator (Al) know. Notice that the ticket is useless to Ed; Ed can't read it. Only Gwen, who knows the decryption key (which is, after all, her secret key), can read the ticket. About the only thing that Ed can do with the ticket is send it on to Gwen.

Al gives Ed one more thing. He gives him a package containing the session key, the same one contained in the ticket. That package is encrypted with Ed's secret key, which only Ed and the authenticator know.

Now Ed has two things. He has the ticket, which only Gwen can read, and he has the package containing the session key, which only he can read. So both Gwen and Ed now have the session key, albeit encoded with different secret keys.

Now Ed and Gwen are ready to prove to each other their respective identities. Ed sends the ticket to Gwen. Gwen reads it with her secret key, thereby convincing herself that only Al could have prepared the package. She opens (decrypts) the package and gets both the session key and the information about Ed. This convinces her that Al has authenticated Ed, and she trusts Al.

This algorithm is very close to the one used by Kerberos, and in fact a Kerberos authenticator could be used as the trusted third party Al.

There are at least four disadvantages to this algorithm. First, both parties need to trust the same third party with their secret keys. Kerberos relaxes this requirement slightly by providing a fourth party, but the effect is the same.

Second, the trusted third party, Al, can be a bottleneck for the algorithms because he is needed for every communication initiation. For fortresses, this probably means that Al must be consulted with every use of the drawbridge.

Third, the algorithm is susceptible to compromise. The algorithm can be compromised if Bart (the bad guy; remember him?) steals a ticket. Bart can then use brute force to guess Gwen's private key. Once he knows Gwen's private key, there is nothing to stop him from impersonating her. Similarly, Bart can steal the package (the one encrypted with Ed's private key) and use a similar brute-force approach to guess Ed's private key, with similar consequences.

The fourth disadvantage of the algorithm is a particular problem for Web service and presentation fortresses, the very fortresses that are most likely to want to use this algorithm. To understand this problem, we need to follow the algorithm from Gwen's perspective.

Gwen gets a message from somebody who claims to be Ed. She believes it really is Ed if her secret key can be used to decrypt the data. Besides herself, only Al the authenticator knows her secret key, so Al must have sent Ed the package containing the session key. To prove that Ed is who he says he is, Gwen must decrypt the ticket. And to decrypt the ticket, she must use her secret key. This need implies that Gwen is storing her secret key someplace in her fortress, someplace where she can get to it easily.

In Chapter 10 (Internet Fortresses) I will discuss some of the security guidelines for building Web service and presentation fortresses. One of these guidelines is to be careful not to store confidential information in the fortress. A great example of confidential information that should not be stored in the presentation fortress is Gwen's secret key, the very key she needs to prove that Ed is Ed. This is a fundamental problem with the shared-key algorithm. Without her key, Gwen can't securely prove that Ed is Ed. But if anybody steals her private key, then she is really in trouble. Now Bart can impersonate her at will.

All of these disadvantages can be eliminated with public/private–key systems. In these systems, each player (Ed and Gwen, in our drama) has both a public and a private key. The public key is readily available to anybody who wants it. The private key is kept secret. The only one who knows Ed's private key is Ed.

Either the public or the private key can be used to encrypt, and whichever one is used, the other one, and only the other one, can be used to decrypt. So if the private key was used for encryption, only the public key will decrypt. If the public key was used to encrypt, only the private key will decrypt.

We still need a trusted authenticator, Al, but he plays a much smaller role here than he does in the shared-key system. First of all, Al doesn't need to know anybody's secret key (as he does with the Kerberos-like system). Second, Al is not consulted on every communications initiation. In fact, the only role Al plays is to guarantee that Ed's and Gwen's public keys are really Ed's and Gwen's.

The way that Al guarantees that Ed's public key is really Ed's is to create a package containing Ed's public key and identification information about Ed. Al then encrypts this package with his own private key. This encrypted package is called a *certificate*. Al sends this certificate to Ed. Ed can now send the certificate to Gwen.

How does Gwen know that Al certified Ed's public key, the one that is contained in the certificate? She decrypts the certificate with Al's public key. This decryption will work only if the certificate was originally encrypted with Al's private key. Gwen doesn't know Al's private key, but she does know his public key (so does everybody else). Anything that Al's public key decrypts must have been encrypted with Al's private key, and she trusts Al to keep his private key private.

Most of the disadvantages of the shared-key (Kerberos-like) algorithm are eliminated or greatly reduced with the public/private–key system. First, nobody needs to trust Al with a secret key (except Al, and if Al can't trust Al, who can?). Second, Al is not needed on an ongoing basis—only once in a while for approving certificates. The third disadvantage is still there; that is, Bart can still potentially guess Gwen's secret key by brute force, but in this case even if that happened, Gwen would just need to create a new secret key and reregister its public counterpart with Al.

The final disadvantage of the shared-key system—the fact that Gwen is forced to store her private key in her own fortress—is completely eliminated with public/private–key systems. Gwen now no longer needs her own private key, at least to prove to herself that Ed is really Ed. She may need her private key to prove to Ed that she is really Gwen, but Gwen can also provide such proof by having another fortress that she trusts do the encryption on her behalf.

One final note: None of these authentication schemes work well for the typical presentation fortresses that must deal with very large numbers of browsers. Private-key systems don't work because no third parties are widely trusted. Private/public–key systems don't work because the credentials are too difficult to manage effectively. But for presentation fortresses that deal with only a limited number of browsers, or Web service fortresses, these systems usually work fine.

This is a fairly high-level look at the main issues involved with fortress authentication, but it should start you thinking.