kerberosticketgrantingclient.java

java kerberos implementation

package SimpleKerberos.guitool;

import SimpleKerberos.*;
import SimpleKerberos.tool.ICryptor;
import SimpleKerberos.tool.HashedNormalCryptor;
import SimpleKerberos.tool.NormalCryptor;
import SimpleKerberos.config.DefaultSettings;

import javax.swing.*;
import javax.crypto.SealedObject;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.*;

// TODO: split into authentication and tgs parts
// TODO: authentication: only want client name and password
// TODO: tgs: only want service name (select from combo box)

/**
 * Author: Thia Yeo Ching, [e-mail]
 * Date: Mar 23, 2003
 * Time: 12:06:55 AM
 * Submitted in Partial Fulfillment of the Requirements
 * for the Degree of Bachelor of Computer Engineering
 * of the Nanyang Technological University
 */
public class KerberosTicketGrantingClient extends JFrame
  implements ActionListener
{
  public static final String TITLE = "Kerberos Ticket Granting Client";

  public void setSoTGSTicket(SealedObject soTGSTicket_)
  {
    this.soTGSTicket_ = soTGSTicket_;
  }

  public void setTgsSessionKey(String tgsSessionKey_)
  {
    this.tgsSessionKey_ = tgsSessionKey_;
  }

  public void setClientName(String clientName_)
  {
    this.clientName_ = clientName_;
  }

  public String getServiceSessionKey()
  {
    return serviceSessionKey_;
  }

  public String getServiceName()
  {
    // TODO: should be stored into a variable
    return serviceName_;
  }

  private SealedObject soTGSTicket_ = null;
  private String tgsSessionKey_ = null;
  private String clientName_ = null;

  private String serviceName_ = null;
  private SealedObject soServiceTicket_ = null;
  private String serviceSessionKey_ = null;
  private SealedObject soServiceSessionClientAuthenticator_ = null;

  private JTextField hostText;
  private JLabel hostLabel;
  private JButton okButton;
  private StatusArea statusArea;
  private JLabel serviceLabel;
  private JComboBox serviceSelection;

  private static final String ELLIPSIS = "...";
  private static final String EXCEPTION = "Exception:";
  private static final String SUCCESS_OBTAIN_TICKET = "*** obtained ticket";
  private static final String FAILED_OBTAIN_TICKET = "*** failed to obtain ticket";
  private static final String ENTER_HOST = "Please enter your host";
  private static final String FAILED_CONTACT_HOST = "failed to contact host ";
  private static final String CONTACT_HOST = "Contacting host ";
  private static final String KERBEROS_HOST_NAME = "Kerberos Host Name";
  private static final String OK = "OK";

  public static void main(String args[])
  {
    new KerberosTicketGrantingClient().setVisible(true);
  }

  public KerberosTicketGrantingClient()
  {
    super(TITLE);
    hostLabel = new JLabel(KERBEROS_HOST_NAME);
    hostText = new JTextField();
    okButton = new JButton(OK);
    statusArea = new StatusArea();
    serviceLabel = new JLabel("Service");
    serviceSelection = new JComboBox(DefaultSettings.SERVICE_NAMES);


    LayoutManager detailsLayout = new GridLayout(2, 2);
    Container detailsPane = new Container();
    detailsPane.setLayout(detailsLayout);
    detailsPane.add(hostLabel);
    detailsPane.add(hostText);
    detailsPane.add(serviceLabel);
    detailsPane.add(serviceSelection);

    LayoutManager contentLayout = new GridLayout(3, 1);
    Container contentPane = this.getContentPane();
    contentPane.setLayout(contentLayout);
    contentPane.add(detailsPane);
    contentPane.add(okButton);
    contentPane.add(statusArea);

    okButton.addActionListener(this);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.pack();
  }


  public void actionPerformed(ActionEvent e)
  {
    if (e.getSource() == okButton)
    {
      statusArea.clearStatus();
      if (checkDetails())
      {
        if (obtainServiceTicket(hostText.getText()))
        {
          statusArea.appendStatus(SUCCESS_OBTAIN_TICKET);
        }
        else
        {
          statusArea.appendStatus(FAILED_OBTAIN_TICKET);
        }

      }
    }
  }


  private boolean checkHost()
  {
    if (hostText.getText().length() > 0)
    {
      return true;
    }

    statusArea.appendStatus(ENTER_HOST);
    return false;
  }

  private boolean checkDetails()
  {
    boolean c3 = checkHost();

    return c3;
  }


  private boolean obtainServiceTicket(String host)
  {
    if (!(soTGSTicket_ != null && tgsSessionKey_ != null && clientName_ != null))
    {
      return false;
    }


    statusArea.appendStatus(CONTACT_HOST + host + ELLIPSIS);
    // assuming that the services are running
    ITicketGrantingService tgs = TicketGrantingServiceFactory.getRemoteInstance(host);
    if (tgs != null)
    {
      return do_obtainServiceTicket(tgs);
    }

    //clearStatus();
    statusArea.appendStatus(FAILED_CONTACT_HOST + host);
    return false;
  }


  private String getServicePassword()
  {
    return DefaultSettings.SERVICE_PASSWORDS[serviceSelection.getSelectedIndex()];
  }

  /**
   * init soTGSTicket_, tgsSessionKey_,
   * soServiceTicket_, serviceSessionKey_
   *
   * @param tgs
   * @return true if success login and got service ticket
   */
  private boolean do_obtainServiceTicket(ITicketGrantingService tgs)
  {

    try
    {

      // TODO: actually ticket granting service should be
      // TODO: move to another login window, since here it
      // TODO: does not concern with the identity of user

      // now get ticket from TGS

      // auth(C)
      Authenticator ClientAuthenticator =
        new Authenticator(clientName_);

      ICryptor tgsSessionCryptor =
        new NormalCryptor(tgsSessionKey_);
      // {auth(C)}KCT
      SealedObject soClientAuthenticator =
        tgsSessionCryptor.encryptObject(ClientAuthenticator);

      serviceName_ = (String) (serviceSelection.getSelectedItem());

      Nounce ticketNounce = new Nounce();
      // {auth(C)}KCT, {ticket(C,T)}KT, S, n
      TicketRequestMsg ticreq =
        new TicketRequestMsg(soClientAuthenticator, soTGSTicket_,
          serviceName_, ticketNounce);


      KDCServiceReplyMsg ticreply = tgs.getTicket(ticreq);
      Challenge serviceChallenge = ticreply.extractChallenge(tgsSessionCryptor);
      assert (serviceChallenge != null);

      // TODO: this part can be removed since it make use of the
      // TODO: password of <current selected service clientName>
      // for testing also decrypt ticket
      ICryptor serviceCryptor = new HashedNormalCryptor(getServicePassword());
      Ticket serviceTicket = ticreply.extractTicket(serviceCryptor);
      assert (serviceTicket != null);

      assert (serviceChallenge.getNounce().getValue() == ticketNounce.getValue());
      assert (serviceChallenge.getSessionKey().equals(serviceTicket.getSessionKey()));
      assert (serviceTicket.getClientName().equals(ClientAuthenticator.getName()));
      assert (serviceTicket.getServiceName().equals(ticreq.getServiceName()));
      serviceTicket.checkValid();

      statusArea.appendStatus("TGS: KDCServiceReplyMsg passed");
      statusArea.appendStatus("Dump:");
      statusArea.appendStatus(serviceChallenge.toString());
      statusArea.appendStatus(serviceTicket.toString());


      // store for future usage
      soServiceTicket_ = ticreply.getSoTicket();
      serviceSessionKey_ = serviceChallenge.getSessionKey();

      // prepare the authenticator for use with service
      ICryptor serviceSessionCryptor = new NormalCryptor(serviceTicket.getSessionKey());
      soServiceSessionClientAuthenticator_ =
        serviceSessionCryptor.encryptObject(ClientAuthenticator);



      return true;


    }
    catch (Exception e)
    {
      statusArea.appendStatus(EXCEPTION + e.getMessage());
      e.printStackTrace();

    }

    return false;
  }

  /**
   Create a new ServiceRequestMsg object for used with a service
   Example code, when serviceReq is a ServiceRequestMsg object:

   // an object requires the use of serviceReq
   CDummyAccountAgent aa = new CDummyAccountAgent();
   // call the operation with serviceReq; 2 is any extra parameters
   ServiceReplyMsg serviceReply = aa.method1(serviceReq, 2);
   // test if the service is the real one
   assert (serviceReply.extractNounce(serviceSessionCryptor).getValue() == serviceSessionNounce.getValue());

   * @return null if soServiceSessionClientAuthenticator_ or soServiceTicket_ not initialized
   */
  public ServiceRequestMsg createNewServiceRequestMsg()
  {

    if (soServiceSessionClientAuthenticator_ != null &&
      soServiceTicket_ != null )
    {
      Nounce serviceSessionNounce = new Nounce();
      ServiceRequestMsg serviceReq = new ServiceRequestMsg(
        soServiceSessionClientAuthenticator_, soServiceTicket_,
        serviceSessionNounce);

      return serviceReq;
    }

    return null;
  }

}