Crypto Challenge Instructions

[Jason Menard]

Seeing how many of us look forward to Angela's daily riddles, I thought I would ride on her coat tails and provide an occasional crypto challenge. If these go over well, I will continue posting them. If not, c'est la vie. Warning in advance, these are not easy.
There are a few components we need to understand in order to solve these things.
First we have the cipher text. This is what you will be trying to decrypt. For example: sghr hr z sdrs.
In order to decrypt this we need to discover the cipher, or what was used to encrypt the message. For example: abcdefghijklmnopqrstuvwxyz. Yes that is the standard alphabet, but it could also be the cipher.
Knowing the cipher is by no means enough. In order to encrypt a message, a cipher is often applied against itself, but shifted by some number. We can call this the offset cipher and the number by which it is shifted we will call the offset.
cipher: abcdefghijklmnopqrstuvwxyz
offset cipher (+1): zabcdefghijklmnopqrstuvwxy
In order to decrypt a message, simply find the letter in the offset cipher, and look up to the same position on the cipher in order to get the plain text letter. The entire decrypted message is refered to as the plain text.
cipher: abcdefghijklmnopqrstuvwxyz
offset: zabcdefghijklmnopqrstuvwxy
cipher text: sghr hr z sdrs
plain text: this is a test
Too easy. Since a simple offset of the standard alphabet is so easy, we need to make it more interesting. We will apply a key to the cipher. The key is any word (I will only be using English). To apply a key, start your cipher by writing out the key, minus any duplicate letters. Say our key is "java". We will begin writing our cipher like this: jav. Notice we dropped the duplicate 'a'. To complete the cipher simply write the rest of the alphabet minus any letters used by your key. This would give us:
<pre>
Cipher: javbcdefghiklmnopqrstuwxyz
Offset +1: zjavbcdefghiklmnopqrstuwxy
cipher text: sghr hr j sdrs
plain text: this is a test
</pre>
Still pretty simple. Here's where we throw in a monkeywrench. We will apply a hat to the cipher in order to rearrange it. A hat, like a key, is a word. Let's use "rancher" as an example. To apply the hat, we first need to write it down, and then under each letter, place a number which equates to it's natural sorted order. Duplicate letters are numbered according to their appearance in the hat, For example:
rancher
6152437
Another one:
freeload
58346712
Get the idea? Next step is to place the cipher row-wise in the columns under the hat.
<pre>
rancher
6152437
-------
javbcde
fghiklm
nopqrst
uwxyz
</pre>
Now we have enough to apply the hat to the cipher. To make your new cipher, pull each column according to it's numbered order. Using the example above, since the 1 is under the second column, we would begin our cipher with: agow. Continuing on to 2, which is the fourth column, we now have: agowbiqy. When we finish, our cipher, with java as the key, and rancher as the hat, is:
agowbiqydlsckrzvhpxjfnuemt
Using a similar example as earlier, using an offset of +1 to encrypt:
<pre>
Cipher: agowbiqydlsckrzvhpxjfnuemt
Offset +1: tagowbiqydlsckrzvhpxjfnuem
cipher text: mvbl bl t mulm
plain text: this is a test
</pre>
Now that you have the basic info, how do you solve these things? I'll pretty much leave that up to you, since that's half the fun. What I will suggest is that you look for common letter combinations (such as 'th'), prefixes (such as 'pre'), and suffixes (such as 'ing', 'es', 'ed', etc...). Short one or two-letter words are good places to make guesses. Another useful tool might be doing a frequency count of the letters. In English the most common letters are A-E-I-N-O-R-S-T, and the least common are J-K-Q-X.
The objective: For each puzzle I will present a few different bits of cipher text, all using different offsets against the same cipher. The primary objective is to recover the plain text. Bonus points if you can figure out the cipher, hat, and key.
Good luck.
[This message has been edited by Jason Menard (edited November 27, 2001).]

[Jason Menard]

Just as a point of clarification, I don't think it is possible to recover the word used for the hat (outside of a very good guess), but it is possible to recover the sequence the hat generates. That is if the hat is 'rancher', the sequence would be '6152437'.

[Paul Stevens]

Just a little something I threw together last night. It might help a little to solve these. The interface could be improved so feel free to do so. Saves on erasers.

import javax.swing.*;
import javax.swing.border.*;
import java.awt.event.*;
import java.awt.*;
import java.util.*;
import javax.swing.text.*;
import java.awt.Toolkit;
import java.text.NumberFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.Locale;
 
 
public class Crypto extends JFrame {
 
    JTextField chosenLetter = new JTextField(2);
    JTextField cryptoLetter = new JTextField(2);
    JTextField crypto = new JTextField(40);
    JButton updateButton = new JButton("Update");
    JButton addButton = new JButton("Add");
    JButton endButton = new JButton("End");
    JComboBox cryptoNum = new JComboBox();
    JPanel cryptoPanel;
    ArrayList cryptos = new ArrayList();
    JLabel[] labels;
    
    JMenu menu ;
    JMenuBar bar;
    JMenuItem newItem ;
    JMenuItem exitItem ;
    
    Font font = new Font("monospaced", Font.BOLD, 12);
     public Crypto () {
        updateButton.setEnabled(false);
        updateButton.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent e) {
              if (chosenLetter.getText().length() > 0 && cryptoLetter.getText().length() > 0 &&
                  !cryptoLetter.getText().equals(" ")) {
                  updateCrypto();
                  cryptoLetter.requestFocus();
              }
          }
        });
        
        bar = new JMenuBar() ;
        setJMenuBar( bar );
        menu = new JMenu( "Crypto " ) ;
        bar.add( menu );
        newItem = new JMenuItem( "New" ) ;
        newItem.setAccelerator(KeyStroke.getKeyStroke('N', Event.ALT_MASK, false));
        newItem.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent e) {
              newCrypto();
           }
        });
        menu.add( newItem );
     
        exitItem = new JMenuItem( "Exit" ) ;
        exitItem.setAccelerator(KeyStroke.getKeyStroke('X', Event.ALT_MASK, false));
        exitItem.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent e) {
              System.exit(0);
           }
        });
        menu.add( exitItem );
        
        getContentPane().add(getSelectionPanel( ),BorderLayout.NORTH);       
    
        cryptoPanel            = new JPanel();    
        cryptoPanel.setLayout(new BoxLayout(cryptoPanel, 1));
        cryptoPanel.setPreferredSize(new Dimension(500,250));
    
    
        getContentPane().add(cryptoPanel, BorderLayout.CENTER);       
        getContentPane().add(getNewCryptoPanel( ),BorderLayout.SOUTH);
        getRootPane().setDefaultButton(updateButton);       
        
     }

    private JPanel getSelectionPanel( ) {
        JPanel pan            = new JPanel();
        JLabel lab1           = new JLabel("Chosen Letter");
        JLabel lab2           = new JLabel("Crypto Letter");
        JLabel lab3           = new JLabel("Crypto #");
        JTextFieldFilter filter = new JTextFieldFilter(JTextFieldFilter.UPPERCASE + " ", 1);
        filter.setUpperCase(true);
        chosenLetter.setDocument(filter);
        filter = new JTextFieldFilter(JTextFieldFilter.UPPERCASE, 1);
        filter.setUpperCase(true);
        cryptoLetter.setDocument(filter);
        pan.setLayout(new FlowLayout(FlowLayout.CENTER));
        
        pan.add(cryptoLetter);
        pan.add(lab2);
        pan.add(chosenLetter);
        pan.add(lab1);
        pan.add(cryptoNum);
        pan.add(lab3);
        pan.add(updateButton);
        
        return pan;
    }
    
    
    
    private void addLabels() {
        
        labels = new JLabel[(cryptos.size() * 2)];
        int index = 0;
  
        for (int i = 0; i < cryptos.size(); i++) {
            labels[index] = new JLabel(createEmpty(((String)cryptos.get(i)).length()));
            labels[index].setFont(font);
            cryptoPanel.add(labels[index]);
            index++;
            labels[index] = new JLabel((String)cryptos.get(i));
            labels[index].setFont(font);
            cryptoPanel.add(labels[index]);
            index++;
            
            cryptoPanel.add(new JLabel(" "));    
            cryptoNum.addItem("" + (i + 1));
        }
 
        validate();
        
    }
    
    private JPanel getNewCryptoPanel( ) {
        JPanel pan            = new JPanel();
        JPanel pan2           = new JPanel();
        JPanel pan3           = new JPanel();
        JLabel lab            = new JLabel("Crypto");
        
        JTextFieldFilter filter = new JTextFieldFilter((JTextFieldFilter.UPPERCASE + " -:;,?!()'."), 250);
        crypto.setDocument(filter);
        filter.setUpperCase(true);
        
        pan2.setLayout(new FlowLayout(FlowLayout.CENTER));
        pan2.add(lab);
        pan2.add(crypto);
        
        pan3.setLayout(new FlowLayout(FlowLayout.CENTER));
        addButton.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent e) {
              if (!crypto.getText().trim().equals("")) {
                 cryptos.add(crypto.getText());
                 crypto.setText("");
                 endButton.setEnabled(true);
                 crypto.requestFocus();
              }
          }
        });
        
        endButton.setEnabled(false);
        endButton.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent e) {              
              crypto.setEnabled(false);
              addButton.setEnabled(false);
              addLabels();
              endButton.setEnabled(false);
              updateButton.setEnabled(true);
              cryptoLetter.requestFocus();
          }
        });
        pan3.add(addButton);
        pan3.add(endButton);
        
        pan.setLayout(new BoxLayout(pan, 1));
        
        pan.add(pan2);
        pan.add(pan3);
        
        return pan;
    }
    
       
    private void updateCrypto( ) {
       
       int choice      = (Integer.parseInt((String)cryptoNum.getSelectedItem()) - 1) * 2;
       char to         = chosenLetter.getText().charAt(0);
       char from       = cryptoLetter.getText().charAt(0);
       int fromIndex   = 0;
       int index       = labels[choice + 1].getText().indexOf(from, fromIndex);

       StringBuffer sb = new StringBuffer(labels[choice].getText());
       while(index > -1) {
           sb.setCharAt(index, to); 
           fromIndex = index + 1;
           index       = labels[choice + 1].getText().indexOf(from, fromIndex);           
       } 
       
       labels[choice].setText(sb.toString());
       chosenLetter.setText("");
       cryptoLetter.setText("");
        
    }
    
       
    private String createEmpty(int value ) {
       
       StringBuffer sb = new StringBuffer(value);
       
       for (int i = 0; i < value; i++) {
        
           sb.append(" "); 
        
       } 
       
       return sb.toString();
        
    }
    
    private void newCrypto( ) {
       
       cryptoPanel.removeAll();
       cryptoNum.removeAllItems();
       crypto.setEnabled(true);
       addButton.setEnabled(true);
       cryptos.clear();
       chosenLetter.setText("");
       cryptoLetter.setText("");
       updateButton.setEnabled(false);
       endButton.setEnabled(false);
       crypto.requestFocus();
       validate();
       
    }

    public static void main(String[] args) {
        Crypto frame = new Crypto();
        frame.setSize(new Dimension(800, 600));
        frame.pack();
        frame.show();
        frame.newCrypto();
    }
    
    class JTextFieldFilter extends PlainDocument {
    public static final String NUMERIC =
      "0123456789";
    public static final String LOWERCASE =
      "abcdefghijklmnopqrstuvwxyz";
    public static final String UPPERCASE =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    public static final String ALPHA_NUMERIC =
      LOWERCASE + UPPERCASE + NUMERIC;
    private String acceptedChars = null;
    private boolean upperCase = false;
    private boolean lowerCase = false;
    private int columns_ = 15;
    /**
       JTextFieldFilter - This is the default constructor for the JTextFieldFilter.
                          It will set the defaults to ALPHA_NUMERIC and length 15.
     */
    public JTextFieldFilter() {
       this(ALPHA_NUMERIC, 15);
    }
    /**
       JTextFieldFilter - Constructor for the JTextFieldFilter.
       String acceptedchars - The acceptable input.
                              NUMERIC - All digits 0 - 9.
                              LOWERCASE - Alphabetic characters (converted to lowercase).
                              UPPERCASE - Alphabetic characters (converted to uppercase).
                              ALPHA_NUMERIC - All digits and alphabetic characters.
                              or any String of characters.
     */
    public JTextFieldFilter(String acceptedchars, int columns) {
       acceptedChars = acceptedchars;
       setLimitColumns (columns);
    }
    /**
       This method sets the maximum columns field.
       @param int columns - The maximum columns.
     */
    public void setLimitColumns (int columns) {
       columns_ = columns;
    }
    /**
       This method sets the upperCase boolean value. All input to the
       textfield will be converted to upper case.
       @param boolean value - The value.
     */
    public void setUpperCase (boolean value) {
       upperCase = value;
    }
    /**
       This method sets the lowerCase boolean value. All input to the
       textfield will be converted to lower case.
       @param boolean value - The value.
     */
    public void setLowerCase (boolean value) {
       lowerCase = value;
    }
    /**
       This method sets the maximum columns field.
       @return columns_ - The maximum columns.
     */
    public int getLimitColumns () {
       return (columns_);
    }
    /**
       This method validates the entered string and limits to
       the set number of colums.
       @param int offset - The offset within the document.
       @param String str - The entered string.
       @param AttributeSet attr - The AttributeSet.
       @throws BadLocationException
     */
    public void insertString(int offset, String str, AttributeSet attr)
       throws BadLocationException {
       if (str == null) return;
       String result = null;
       //if entered string will go beyond the max columns do not allow.
       if (getLength () == columns_) {
           return;
       }

       if(upperCase) {
          str = str.toUpperCase();
       } else if(lowerCase) {
          str = str.toLowerCase();
       }
       for (int i=0; i < str.length(); i++) {
          if (acceptedChars.indexOf(str.valueOf(str.charAt(i))) == -1)
             return;
       }
       //if the string pasted is longer than max columns truncate
       if (getLength () + str.length () > columns_) {
           result = str.substring (0, columns_);
       } else {
           result = str;
       }
       super.insertString (offset, result, attr);
   }
}
}

Edit: Removed the space from being a valid character for the cryptoLetter filter. Should be able to change to spaces but not actually change the spaces from the original.
[This message has been edited by Paul Stevens (edited November 30, 2001).]

[Jason Menard]

Paul,
I think I'm a little confused on how to use it. I'm sure it's intuitive, but I'm not. Do you have any instructions?

[Jason Menard]

As long as we are sharing code... Here is the code I use to come up with the ciphers and encrypt the text. There are three files... Cipher.java (the bean that does all the work), CipherFrame.java, and CipherText.java. Caveat: I'm a server-side application programmer by trade and don't play around with this Swing stuff too much. The GUI was thrown together with JBuilder and could probably use many fixes/enhancements. Feel free to let me know of anything that needs to be fixed, or of any improvements.
Cipher.java

package jmca;
import java.util.Arrays;
public class Cipher
{
    public final char[] PLAINTEXT_ALPHABET =
        new String("abcdefghijklmnopqrstuvwxyz").toCharArray();
    private char[] cipher;
    private String hat;
    private String key;
    private int offset;
    private String plainText;
    private String cipherText;
    public Cipher()
    {
    }
    public String getCipher()
    {
        return new String(cipher);
    }
    public String getHat()
    {
        return hat;
    }
    public void setHat(String hat)
    {
        this.hat = hat;
    }
    public void setKey(String key)
    {
        this.key = key;
    }
    public String getKey()
    {
        return key;
    }
    public void setOffset(int offset)
    {
        this.offset = offset;
    }
    public int getOffset()
    {
        return offset;
    }
    public String getOffsetCipher()
    {
        return new String(applyOffset(cipher));
    }
    public void setPlainText(String text)
    {
        this.plainText = text.toLowerCase();
    }
    public String getPlainText()
    {
        return plainText;
    }
    public String getCipherText()
    {
        return cipherText;
    }
    public String getTruncatedKey()
    {
        if (key == null | | key.equals(""))
            return "";
        StringBuffer truncatedKey = new StringBuffer(key);
        int[] deleteChars = new int[key.length()];
        java.util.Arrays.fill(deleteChars, -1);
        // identify duplicate letters and add their index to deleteChars
        int j = 0;
        for (int i = 0; i < key.length() - 1; i++)
        {
            int index = key.indexOf(key.substring(i,i + 1),i + 1);
            if (index != -1)
            {
                deleteChars[j++] = index;
            }
        }
        // replace letters to be deleted with spaces
        j = 0;
        while (deleteChars[j] != -1)
        {
            truncatedKey.setCharAt(deleteChars[j],' ');
            j++;
        }
        // delete spaces
        for (int i = 0; i < truncatedKey.length(); i++)
        {
            if (truncatedKey.charAt(i) == ' ')
                truncatedKey.deleteCharAt(i);
        }
        if (truncatedKey.charAt(truncatedKey.length() - 1) == ' ')
            truncatedKey.deleteCharAt(truncatedKey.length() - 1);
        return truncatedKey.toString();
    }
    public char[] applyKey(char[] alphabet)
    {
        String truncatedKey = getTruncatedKey();
        char[] k = truncatedKey.toCharArray();
        char[] newCipher = new char[alphabet.length];
        for (int i = 0; i < k.length; i++)
        {
            newCipher[i] = k[i];
        }
        int j = 0;
        for (int i = k.length; i < newCipher.length; i++)
        {
            while (truncatedKey.indexOf(alphabet[j]) != -1)
                j++;
            newCipher[i] = alphabet[j++];
        }
        return newCipher;
    }
    public char[] applyHat(char[] alphabet)
    {
        if (hat == null | | hat.equals(""))
            return alphabet;
        char[] sortedHatArray = hat.toCharArray();
        Arrays.sort(sortedHatArray);
        // order[] will contain the sequence number of the corresponding value of hat[]
        int[] order = new int[hat.length()];
        Arrays.fill(order, -1);
        StringBuffer sortedHat = new StringBuffer(new String(sortedHatArray));
        // Get the index in sortedHat of the first occurence of the ith letter in hat
        // This determines our hat sequence, stored in order[]
        for (int i = 0; i < hat.length(); i++)
        {
            int index = sortedHat.toString().indexOf(hat.substring(i,i+1));
            sortedHat.setCharAt(index,' ');
            order[i] = index;
        }
        char[] newCipher = new char[alphabet.length];
        // applying the hat sequence, we can calculate indexes in alphabet[]
        // as if it were a transposition matrix of 'rows' rows by 'hat.length()' columns.
        // mod tells us which columns have more than rows letters in them
        int rows = alphabet.length / hat.length();
        int mod = alphabet.length % hat.length();
        for (int i = 0; i < hat.length(); i++)
        {
            int col = order[i];
            int count = rows;
            if (i < mod)
                count++;
            int additive = 0;
            for (int x = 0; x < order.length; x++)
            {
                if (order[x] < col)
                {
                    additive += rows;
                    if (x < mod)
                        additive++;
                }
            }
            for (int j = 0; j < count; j++)
            {
                int k = i + (j*hat.length());
                int cipherIndex = additive + j;
                newCipher[cipherIndex] = alphabet[k];
            }
        }
        return newCipher;
    }
    public char[] applyOffset(char[] alphabet)
    {
        char[] newCipher = new char[alphabet.length];
        for (int i = 0; i < alphabet.length; i++)
        {
            int cipherIndex = i + offset;
            if (cipherIndex >= alphabet.length)
            {
                while (cipherIndex >= alphabet.length)
                {
                    cipherIndex = cipherIndex - alphabet.length;
                }
            }
            if (cipherIndex < 0)
            {
                while (cipherIndex < 0)
                {
                    cipherIndex = cipherIndex + alphabet.length;
                }
            }
            newCipher[cipherIndex] = alphabet[i];
        }
        return newCipher;
    }
    public void encrypt()
    {
        cipher = applyHat(applyKey(PLAINTEXT_ALPHABET));
        String cipherString = new String(cipher);
        char[] cipherOffset = applyOffset(cipher);
        if (plainText == null)
            plainText = "";
        char[] plainTxt = plainText.toCharArray();
        char[] cipherTxt = new char[plainTxt.length];
        for (int i = 0; i < plainTxt.length; i++)
        {
            char currentChar = plainTxt[i];
            char cipherChar = plainTxt[i];
            int index = cipherString.indexOf(currentChar);
            if (index != -1)
                cipherChar = cipherOffset[index];
            cipherTxt[i] = cipherChar;
        }
        cipherText = new String(cipherTxt);
    }
    public static void main(String[] args)
    {
        Cipher a = new Cipher();
        a.setKey("java");
        a.setHat("ranch");
        a.setOffset(1);
        a.setPlainText("This is a test");
        a.encrypt();
        System.out.println(a.getPlainText());
        System.out.println(a.getCipherText());
    }
}

CipherFrame.java

package jmca;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CipherFrame extends JFrame
{
    private JPanel contentPane;
    private BorderLayout borderLayout1 = new BorderLayout();
    private Cipher cipher = new Cipher();
    private JPanel jPanel1 = new JPanel();
    private JPanel jPanel2 = new JPanel();
    private JLabel jLabel1 = new JLabel();
    private JLabel jLabel2 = new JLabel();
    private JLabel jLabel3 = new JLabel();
    private JTextField keyField = new JTextField();
    private JTextField hatField = new JTextField();
    private JTextField offsetField = new JTextField();
    private BorderLayout borderLayout2 = new BorderLayout();
    private JPanel jPanel3 = new JPanel();
    private GridBagLayout gridBagLayout1 = new GridBagLayout();
    private JLabel jLabel4 = new JLabel();
    private JTextField cipherField = new JTextField();
    private JLabel jLabel5 = new JLabel();
    private JTextField offsetCipherField = new JTextField();
    private JLabel jLabel6 = new JLabel();
    private JTextArea plainTextArea = new JTextArea();
    private JLabel jLabel7 = new JLabel();
    private JLabel jLabel8 = new JLabel();
    private JTextArea cipherTextArea = new JTextArea();
    private JPanel jPanel4 = new JPanel();
    private JButton encryptButton = new JButton();
    private JLabel jLabel9 = new JLabel();
    /**Construct the frame*/
    public CipherFrame()
    {
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
        try
        {
            jbInit();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    /**Component initialization*/
    private void jbInit() throws Exception
    {
        //setIconImage(Toolkit.getDefaultToolkit().createImage(CipherFrame.class.getResource("[Your Icon]")));
        contentPane = (JPanel) this.getContentPane();
        contentPane.setLayout(borderLayout1);
        this.setSize(new Dimension(400, 300));
        this.setTitle("Cipher Text");
        jLabel1.setText("Key");
        jLabel2.setText("Hat");
        jLabel3.setText("Offset");
        keyField.setColumns(7);
        hatField.setColumns(7);
        offsetField.setColumns(3);
        jPanel1.setLayout(borderLayout2);
        jPanel3.setLayout(gridBagLayout1);
        jLabel4.setText("Cipher");
        cipherField.setBackground(Color.lightGray);
        cipherField.setEditable(false);
        cipherField.setColumns(26);
        jLabel5.setText("Offset Cipher");
        offsetCipherField.setBackground(Color.lightGray);
        offsetCipherField.setEditable(false);
        offsetCipherField.setColumns(26);
        jLabel6.setText("Plain Text");
        plainTextArea.setColumns(40);
        plainTextArea.setRows(3);
        plainTextArea.setLineWrap(true);
        plainTextArea.setWrapStyleWord(true);
        jLabel7.setText(" ");
        jLabel8.setToolTipText("");
        jLabel8.setText("Cipher Text");
        cipherTextArea.setEditable(false);
        cipherTextArea.setColumns(40);
        cipherTextArea.setRows(3);
        cipherTextArea.setLineWrap(true);
        cipherTextArea.setWrapStyleWord(true);
        encryptButton.setText("Encrypt");
        encryptButton.addActionListener(new java.awt.event.ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                encryptButton_actionPerformed(e);
            }
        });
        jLabel9.setText(" ");
        contentPane.add(jPanel1, BorderLayout.CENTER);
        jPanel1.add(jPanel2, BorderLayout.NORTH);
        jPanel2.add(jLabel1, null);
        jPanel2.add(keyField, null);
        jPanel2.add(jLabel2, null);
        jPanel2.add(hatField, null);
        jPanel2.add(jLabel3, null);
        jPanel2.add(offsetField, null);
        jPanel1.add(jPanel3, BorderLayout.CENTER);
        jPanel3.add(cipherField,     new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(offsetCipherField,     new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(jLabel6,      new GridBagConstraints(0, 3, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(plainTextArea,       new GridBagConstraints(1, 3, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(jLabel7,     new GridBagConstraints(1, 4, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(jLabel8,      new GridBagConstraints(0, 5, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(cipherTextArea,       new GridBagConstraints(1, 5, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(jLabel9,   new GridBagConstraints(1, 2, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
        jPanel3.add(jLabel5,     new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 1, 0, 6), 0, 0));
        jPanel3.add(jLabel4,         new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0
            ,GridBagConstraints.EAST, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 7, 0));
        jPanel1.add(jPanel4,  BorderLayout.SOUTH);
        jPanel4.add(encryptButton, null);
    }
    /**Overridden so we can exit when window is closed*/
    protected void processWindowEvent(WindowEvent e)
    {
        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING)
        {
            System.exit(0);
        }
    }
    void encryptButton_actionPerformed(ActionEvent e)
    {
        cipher.setKey(keyField.getText());
        cipher.setHat(hatField.getText());
        String offset = offsetField.getText();
        if (offset.equals(""))
            offset = "0";
        cipher.setOffset(Integer.parseInt(offset));
        cipher.setPlainText(plainTextArea.getText());
        cipher.encrypt();
        cipherField.setText(cipher.getCipher());
        offsetCipherField.setText(cipher.getOffsetCipher());
        cipherTextArea.setText(cipher.getCipherText());
    }
}

CipherText.java

package jmca;
import javax.swing.UIManager;
import java.awt.*;
public class CipherText
{
    private boolean packFrame = false;
    /**Construct the application*/
    public CipherText()
    {
        CipherFrame frame = new CipherFrame();
        //Validate frames that have preset sizes
        //Pack frames that have useful preferred size info, e.g. from their layout
        if (packFrame)
        {
            frame.pack();
        }
        else
        {
            frame.validate();
        }
        //Center the window
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        Dimension frameSize = frame.getSize();
        if (frameSize.height > screenSize.height)
        {
            frameSize.height = screenSize.height;
        }
        if (frameSize.width > screenSize.width)
        {
            frameSize.width = screenSize.width;
        }
        frame.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);
        frame.setVisible(true);
    }
    /**Main method*/
    public static void main(String[] args)
    {
        try
        {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        new CipherText();
    }
}

[This message has been edited by Jason Menard (edited November 30, 2001).]

[Jason Menard]

Originally posted by Jason Menard:
Paul,
I think I'm a little confused on how to use it. I'm sure it's intuitive, but I'm not. Do you have any instructions?

Nevermind, I figured it out.

[Paul Stevens]

Instructions are for sissies
Copy from your post paste in the text field at the bottom. Click add. Copy as many as there are and click the end button.
The crypts will appear. Put in the letter from the crypt the letter you want to change, which crypt to change and click update. Those components are in the order I just described. I didn't really spend much time creating this so design and instructions where kind of left out.
PS to blank out a letter put the crypt letter and put a space for the replacing letter.
[This message has been edited by Paul Stevens (edited November 30, 2001).]

[Paul Stevens]

I never saw your post asking for directions. It was sandwhiched between my long code post and yours and I missed it. Sorry.

[Jim Yingst]

Bump.

[Jason Menard]

See this page for useful info on solving these problems.