/* *   File:  Connection.java * *   Version 1.02 v1a *   Copyright 1998, 1999 by Hush Communications Corporation, BWI */package hushcode;import java.applet.*;import java.net.*;import java.io.*;import java.awt.*;import java.util.*;import hushcode.HushSHA1;import hushcode.BlowfishCipher;import hushcode.HushApplet;import hushcode.Conversions;import hushcode.ElGamalCipher;import hushcode.HushRandom;import hushcode.ByteQueue;class Connection{ /************************************************************ *  The class variables and the methods that return them  ************************************************************//** * The following variables and methods deal with the user's folderlist.   * The folderlist is obtained by calling the method getFolders(). */  /* The number of folders used by the user   */  private int numberOfFolders;  int numberOfFolders() {return numberOfFolders;}      /* An array containing the names of the user's folders   * in the order they were received from the server   */  private String[] folderNameArray;  String folderName(int x) {return folderNameArray[x];}  /* An array containing the numbers of messages in each folder   * in the order they were received from the server   */  private int[] numberOfMessagesArray;  int numberOfMessages(int x)     {return numberOfMessagesArray[x];}  /* An array containing the numbers of unread messages in each folder   * in the order they were received from the server    */  private int[] numberOfUnreadMessagesArray;  int numberOfUnreadMessages(int x)     {return numberOfUnreadMessagesArray[x];}/** * The following variables and methods deal with the currently open  * folder.  A folder is opened by calling the method openFolder(String foldername) */  /* The name of the currently open folder   */  private String folderName;  String folderName() {return folderName;}   /* The number of messages in the currently open folder   */  private int numberOfMessages;  int numberOfMessages() {return numberOfMessages;}   /* The number of unread messages in the currently open folder   */  private int numberOfUnreadMessages;  int numberOfUnreadMessages() {return numberOfUnreadMessages;}    /* An array containing the messageIDs of messages in the currently    * open folder. messageIDs are assigned in the order messages are     * received from the server.  ?? Do we need this ??   */  private int[] messageIDArray;  int messageID(int x) {return messageIDArray[x];}    /* An array containing the exact sizes in octets of message in the   * currently open folder.  Ordered by messageID.   */  private int[] messageSizeArray;  int messageSize(int x) {return messageSizeArray[x];}  /* An array containing the subjects of the messages in the currently    * open folder.  Ordered by messageID.   */  private String[] subjectArray;  String subject(int x) {return subjectArray[x];}   /* An array containing the from addresses of the messages in the currently    * open folder.  Ordered by messageID.   */  private String[] fromArray;  String from(int x) {return fromArray[x];}  /* An array containing the to addresses of the messages in the currently    * open folder.  Ordered by messageID.   */  private String[] toArray;  String to(int x) {return toArray[x];}   /* An array containing the dates of the messages in the currently    * open folder.  Ordered by messageID.   */  private String[] dateArray;  String date(int x) {return dateArray[x];}   /* An array of type boolean indicating whether or not each message   * in the currently open folder has been read. Ordered by messageID.   */   private boolean[] readArray;  boolean read(int x) {return readArray[x];}  /** * The following variables and methods deal with the current   * message.  The current message is selected by calling * the method getMessage(String messageID). */   /* The messageID of the current message.   */   private int messageID;  int messageID() {return messageID;}  /* The date of the current message.   */   private String date;  String date() {return date;}  /* The subject field of the current message   */  private String subject;  String subject() {return subject;}  /* The to field of the current message   */  private String to;  String to() {return to;}  /* The from field of the current message   */  private String from;  String from() {return from;}  /* The reply-to field of the current message   */  private String replyTo;  String replyTo() {return replyTo;}    /* The cc field of the current message   */  private String cc;  String cc() {return cc;}   /* The bcc field of the current message   */  private String bcc;  String bcc() {return bcc;}   /* The full header of the current message   */  private String header;  String header() {return header;}  /* The body of the current message (unencrypted if the message was secure)   */  private String body;    String body() {return body;}  /* The body of the current message (encrypted if the message was secure)   */  private String actualbody;  String actualbody() {return actualbody;}  /*  If true the message has been rewritten   *  to the server, so the folderlist needs to be reloaded   */  private boolean wasRewritten;  boolean wasRewritten() {return wasRewritten;}  /*  This method wipes the entire message from memory   */  void wipeMessage()  {    date = null;    subject = null;    to = null;    from = null;    replyTo = null;    cc = null;    bcc = null;    header = null;    actualbody = null;    body = "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------"+           "-----------------------------------------------------------";    body = null;  }/** * The following variables and methods deal with the addressbook   * message.  The addressbook is obtained by calling the method * getAddresses(). */  /* The number of addresses in the address book   */  private int numberOfAddresses;  int numberOfAddresses() {return numberOfAddresses;}  /* An array of nicknames for the entries in the addressbook     */  private String[] nicknameArray;  String nickname(int x) {return nicknameArray[x];}  /* An array of fullnames for the entries in the addressbook   */  private String[] fullnameArray;  String fullname(int x) {return fullnameArray[x];}    /* An array of email addresses for the entries in the addressbook   */  private String[] addressesArray;  String addresses(int x) {return addressesArray[x];}  /* An array of public key fingerprints   */  private String[] fingerprintsArray;  String fingerprints(int x) {return fingerprintsArray[x];}/** * The following variables and methods deal with information   * about the users account and current session. */  /* The server's address   */  private String serverAddress;  /* The port the server listens for connections on   */  private int serverPort = 21;  /* The socket used to communicate with the server   */  private Socket s;     /* The service's domain.  Usually hushmail.com   */  private String domain;  String domain() {return domain;}  /* The username   */  private String username;     String username() {return username;}  /* The users email address   */  private String emailAddress;  String emailAddress() {return emailAddress;}    /* Half of a hash of the passPhrase;   */  private byte[] halfPassphraseHash;  void setPassphrase(String passedPassphrase)   {    byte[] passphraseHash = new HushSHA1().SHA1Hash(passedPassphrase);    halfPassphraseHash=new byte[passphraseHash.length/2];    System.arraycopy(passphraseHash,0,halfPassphraseHash,0,halfPassphraseHash.length);    passphraseHash = null;    passCipher = new BlowfishCipher();    passCipher.setKey(passedPassphrase.getBytes());    passedPassphrase = "                                            " +                       "                                            " +                       "                                            " +                       "                                            " +                       "                                            " ;    passedPassphrase=null;  }  /*  The user's public key fingerprint   */  private String fingerprint = "";  String fingerprint() {return fingerprint;}  /* The cipher with the key as user's passphrase   */  private BlowfishCipher passCipher;  void killPassCipher() {passCipher=null;}  /* The pseudo stream cipher for communication between applet and server   */  private BlowfishCipher blowfishPipe;   /* The sessionID.  64 bytes used as a unique identifier by the server to ensure   * a user cannot open multiple sessions, and that no one can break into the middle   * of a session.   */  private byte[] sessionIDBytes;  /* The user's encrypted public key   */  private byte[] encPrivKey;  /* A random number stream for encryption   */  private HushRandom randStream;   /* The applet using this instance of Connection   */  private HushApplet hushApplet;   /* A count of the tasks currently requiring use of the socket.   * Allows the socket to close when not needed.   */  private int socketRequests;  /* An output stream to the socket   */  BufferedOutputStream out;  /* An input stream from the socket.   */  BufferedInputStream eIn;  /* An input stream from a decrypted String which is used as a buffer   * to store data from eIn after it has been decrypted with blowfishPipe   */  DataInputStream in;  /* A boolean flag that indicates if the socket connection has been used yet.   * This ensures the session will only be initialized by method use() once   */  private boolean initialUse;  private String spaces="                               ";/************************************************************ *  Actions ************************************************************/    Connection(String passedUsername, String passedSessionID, String passedSessionKey, HushApplet a) //Constructor  {    /**     * This is the class constructor     */    username = passedUsername.toLowerCase();    /* Convert sessionID hex string to an array of bytes     */    sessionIDBytes = Conversions.hexStringToBytes(passedSessionID);      /* Convert sessionKey hex string to an array of bytes     */    byte[] sessionKeyBytes = Conversions.hexStringToBytes(passedSessionKey);    /* Instantiate cipher with sessionKey     */    blowfishPipe = new BlowfishCipher();    blowfishPipe.setKey(sessionKeyBytes);    hushApplet = a;    serverAddress = hushApplet.getCodeBase().getHost();    domain = "hushmail.com";    emailAddress = username+"@"+domain;    /* Since this session has just been started, no tasks are using the socket yet     */    socketRequests = 0;    /* The socket has not yet been used for communication     */    initialUse = true;    randStream = new HushRandom(new HushSHA1().SHA1Hash(Conversions.longToBytes(new Date().getTime())));  }    void getFolders() throws IOException  {     /**    *  Retrieves information on the folders stored on the server    *       numberOfFolders is set to the number of folders the     *           user has.    *       folderNameArray contains the names of the folders.    *        numberOfMessagesArray contains the numbers of messages    *          in each folder     *        numberOfUnreadMessagesArray contains the numbers of     *          unread messages in each folder     */        encryptAndWrite("LISTFOLDERS\n");    readAndDecrypt();    if (!in.readLine().equals("OK")) throw new IOException();    numberOfFolders = Integer.parseInt(in.readLine());    folderNameArray = new String[numberOfFolders];    numberOfMessagesArray = new int[numberOfFolders];    numberOfUnreadMessagesArray = new int[numberOfFolders];    for (int x=0;x<numberOfFolders;x++)         {      folderNameArray[x] = in.readLine();      numberOfMessagesArray[x] = Integer.parseInt(in.readLine());       numberOfUnreadMessagesArray[x]= Integer.parseInt(in.readLine());    }  }  void deleteFolder(String passedFolderName) throws IOException  {   /**    *  Indicates to the server that the folder with name    *  passedFolderName should be deleted    */     encryptAndWrite("DELETEFOLDER\n"+passedFolderName.trim()+"\n");    readAndDecrypt();    if (!in.readLine().equals("OK")) throw new IOException();   }