The Operating System of the CCNI (IBM Blue Gene)

Unfolding Blue Gene

Benchmarking the effects of operating system interference on extreme scale parallel machines.

Kerberos

The gold standard for computer and network security is Kerberos. Kerberos was developed at MIT as part of Project Athena, which also developed the X Windows system. It is designed to provide complete security for services on a network. The name comes from the name of a three headed dog that guarded Hades in Greek mythology.

Networking services opens up the possibility of new kinds of security violations. One such violation is called the "Man in the Middle", in which the bad guy is not only able to intercept all communication between a client and server, but also attempts to pretend that his program is the server (or client) by changing the network address. For example, a legitimate client could contact a file server requesting a file, and the man in the middle could intercept this request, read the request, and perhaps send back a different file. The client assumes that it has contacted the file server, but in fact has not.

Similarly, the Man in the Middle could contact the file server pretending to be a legitimate client, and so the file server could send a file or files over the network, but they are intercepted by the bad guy. As above, the file server thinks that it has successfully sent the files to a legitimate client.

Recall that one of the problems that SSL fixed was the WWW version of Man in the Middle, where a browser thought that it was communicating with, say, Amazon.com, but in fact, all of the packets had been intercepted. SSL solved this problem by having a Certificate Authority whom everyone trusted who issued certificates.

Kerberos is a trusted third party authentication system because it requires the user to identify themselves every time a service is requested. It effectively prevents the man in the middle attack. Every user has a password and every service has a password, and the only entity that knows both is the authentication server. The authentication server operates under considerable physical security. Typically it runs on a separate machine for which only a few people have access.

Here is what happens when Alice logs into a Kerberos system and attempts to use a service.

• Alice logs into a workstation by entering her login name
• Before prompting user for the password, a message is sent to the Kerberos authentication server. The message contains the login name and name of a service, the Kerberos Ticket Granting Service (TGS). This is not encrypted. Note that the ticket granting service (TGS) is just another network service.
• The TGS (and every other service) has a password (also called an encryption key), just as all users have passwords. The authentication server looks up Alice's login name and the service name and obtains an encryption key (password) for each. It also generates a random session key, which will be used for all of Alice's communications with the TGS.
• The authentication server sends a response back to the workstation, containing a ticket with four fields, The login name of the user, the name of the service the network address of the user's workstation, and the session key that the user will use to encrypt messages for that service

  ticket = loginname, TGS, Workstation network address, TGS session key

  This ticket is encrypted using the TGS encryption key. A message is then formed containing this sealed ticket and the TGS session key, which is then encrypted using Alice's login password. This is sent to the Alice's login process.

  

• The user is prompted for a password. This is used to decrypt the message. So the workstation now has a sealed ticket encrypted with the TGS password and a session key. Both of these are saved.
• Suppose Alice wants to read a file and so she has to contact the file server. She will need a ticket to do this, and this ticket is issued by the TGS. The request message looks like this.

  message = sealed ticket, sealed authenticator, end-server-name

  The authenticator consists of the loginname, the Workstation network address and the current time.

  The authenticator is encrypted using the TGS session key, and the message is sent to the ticket granting service.

  

• The ticket granting service receives the message and it decrypts the sealed ticket using its own encryption key. This allows it to read the session key, which it then uses to decrypt the sealed authenticator. It can verify all of the information. It then looks up the appropriate server and gets the encryption key for the file server.
• It forms a new random session key and creates a new ticket based on the requested end service and the new session key. This new session key will be used by Alice only for file server requests.

  ticket = login name, end server name, workstation network address, new-session-key

  This ticket is encrypted using the file server encryption key. This is a new sealed ticket. Alice's workstation cannot decrypt it because it does not know the file server encryption key (password).

  A message is created

  message = new session key, sealed ticket

  and this is encrypted using the TGS session key. This is sent to the user.

• The user decrypts this using the session key, which it knows, but it still cannot read the sealed ticket. Now it has the new session key as well.
• The workstation builds an authenticator authenticator = login name, Workstation network address, current time

  and seals it using the new session key.

• The workstation then sends a message (unencrypted) to the file server

  message = sealed ticket, sealed authenticator, file server name

• - the file server receives this message, decrypts the sealed ticket using its encryption key, thereby getting the session key. It uses the session key to decrypt the authenticator. It then provides the service. All files are encrypted using the session key, which is known to both the file server and Alice.

Here are some observations about Kerberos.

In order to use a service, a ticket is required. All tickets except the first are obtained from TGS. The first is obtained from the authentication server.

The tickets are not comprehensible to the workstation because they are encrypted using the key of the service

Every ticket is associated with a session key that is assigned every time a ticket is allocated.

Tickets are reusable. They have lifetimes of about eight hours.

But a new authenticator is required for each request, and these expire within a few minutes.

The server maintains a list of all recent requests so that it can detect duplicate requests which might arise from a stolen ticket.

Since both ticket and authenticator contain the network address, another workstation cannot use a stolen ticket without changing their system to impersonate the owners network address (and they have to do this quickly because authenticators have a time stamp).

Note that Alice's password is never sent over the network, so it is impossible for the bad guys to steal passwords by network sniffing. Note also that the Man in the Middle attack is foiled, because if the request is interrupted, the bad guy cannot read it because it does not know the encryption key of the service, so it cannot pretend to be that service.

Kerberos is in some ways cumbersome. It should be installed for all system services, such as file servers, mail servers, and printers, as well as the login process. It obviously slows down almost any operation because of all of the encryption and decryption, and it also causes additional network traffic to obtain tickets. But the advantage is that all network traffic is encrypted, and this prevents a huge amount of security violations.

The Andrew File System (AFS) has Kerberos built in.

Kerberos is believed to be secure, with the huge caveat that if the security of the authenticator or other services is breached, all security is lost.

Here is a link to the Official Kerberos Web site at MIT

Return to the course home page