In this exercise we will implement the one-time pad. This is a type of encryption which is impossible to crack (if you don’t have the pad)!

To use this encryption method, we take a plaintext string, for example THISISMYSECRETCODE, and encrypt it using a key, for example, SUPERSECRETKEYKEEPMESAFE. For a one-time pad to work, we need the key to be longer than the plaintext.

The code is simple in concept. First, we consider mapping letters to numbers:

This allows us to convert both our key and plaintext into a list of numbers. For example:

To encipher, using the one-time pad, we add up the numbers:

Take the modulo of each number around 26:

and then convert these numbers back to letters:

In this exercise, we will need to introduce another basic type, char. char represents a single letter, similar to Haskell.

To implement the ciphering and deciphering using the one-time pad, you will create a class OneTimePadEncipher. We have given the skeleton for this class below:

public class OneTimePadEncipher {

    public static int charToInt(char l) {
      // ADD CODE HERE
      // Should convert a character to an integer, for example 'a' -> 0, 'b' -> 1
    }

    public static char intToChar(int i) {
      // ADD CODE HERE
      // Should convert an integer to a character, for example 0 -> 'a', b -> '1'
      // it should always return lower case chae
    }

    public static boolean isAlpha(char c) {
      // You do not need to implement this method, but you may find it useful.
    }

    public static String encipher(String original, String onetimepad) {
      // ADD CODE HERE
    }


    public static void main(String[] args) {
      String ciphertext = encipher("HELLO EVERYBODY", "MYSECRETKETMYSECRETKEY");
      System.out.print(ciphertext);
    }

}

Notes:

• You should be careful that your plaintext and your key are both in uppercase. You can use the String method toUpperCase() and toLowerCase() to convert a string to upper or lowercase. Note that this method returns a new string, so it must be assigned. E.g., mystring = mystring.toLowerCase;.
• To extract a char from a String at a certain index, you can use the String.charAt() method on the String object. For example, char c = "hello".charAt(2);, will set c=l .
• It is possible to convert a char into an int using casting. However, note that this will give the ascii value of the letter. For example (int) ('a') -> 97, (int) ('b') -> 98, (int) ('A') -> 65.
• Think about what to do in the case of spaces in the plaintext; they should be spaces in the output (This is not good for making the code secure, but makes human reading easier!). Unit tests will assume that you ignore the values in the one-time pad at the indices of the spaces.

If everything is successful, you should be able to encrypt the following:

Create a new class OneTimePadDecipher and implement a method to decrypt ciphertext given a key. To decrypt a code, you need to subtract the key from the ciphertext representation, instead of adding it.

As with Question 3, you can call methods already defined in OneTimePadEncipher by using the qualified name (for example OneTimePadEncipher.charToInt(o)).

The signature of the new method is as follows:

public static String decipher(String encipheredText, String onetimepad)

If everything is sucessful, you should be able to decrypt the following: