Introduction to the One-Time Pad

package otpapi;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class OneTimePad {
	
	// Suppose Alice wishes to send the message hello to Bob. Assume two pads of paper containing identical 
	// random sequences of letters were somehow previously produced and securely issued to both. Alice chooses 
	// the appropriate unused page from the pad. The way to do this is normally arranged for in advance, 
	// as for instance "use the 12th sheet on 1 May", or "use the next available sheet for the next message".

	// The material on the selected sheet is the key for this message. Each letter from the pad will be 
	// combined in a predetermined way with one letter of the message. (It is common, but not required, 
	// to assign each letter a numerical value, e.g., a is 0, b is 1, and so on.)

	// this example, the technique is to combine the key and the message using modular addition, not 
	// unlike the Vigenère cipher. The numerical values of corresponding message and key letters are added 
	// together, modulo 26. So, if key material begins with XMCKL and the message is hello, then the coding 
	// would be done as follows:
	// [NOTE - instead of adding a random number, one can XOR a random byte, and read in the characters as 
	//         an array of bytes.
	
  //       h       e       l       l       o  message
  //    7 (h)   4 (e)  11 (l)  11 (l)  14 (o) message
  // + 23 (X)  12 (M)   2 (C)  10 (K)  11 (L) key
  // = 30      16      13      21      25     message + key  (send this instead of cipher text)
  // =  4 (E)  16 (Q)  13 (N)  21 (V)  25 (Z) (message + key) mod alphabet_size
  //       E       Q       N       V       Z  → ciphertext
	
	// If a number is larger than 25, then the remainder after subtraction of 26 is taken in modular arithmetic 
	// fashion. This simply means that if the computations "go past" Z, the sequence starts again at A.

	// The ciphertext to be sent to Bob is thus EQNVZ. Bob uses the matching key page and the same process, 
	// but in reverse, to obtain the plaintext. Here the key is subtracted from the ciphertext, again using 
	// modular arithmetic:
	
  //        E       Q       N       V       Z  ciphertext
  //     4 (E)  16 (Q)  13 (N)  21 (V)  25 (Z) ciphertext
  //   −23 (X)  12 (M)   2 (C)  10 (K)  11 (L) key
  // = −19       4      11      11      14     ciphertext – key
  // =   7 (h)   4 (e)  11 (l)  11 (l)  14 (o) ciphertext – key (mod alphabet_size)
  //       h       e       l       l       o  → message
	
	// As long as the key is perfectly random and is never repeated, the One time pad is perfectly secure.
	// Using the CryptTool 2 [https://www.cryptool.org/en/ct2/]: https://www.youtube.com/watch?v=eiMAVOcAO_I
	// The above is a traditional way to do a OTP cipher. That is what we will be using here, so the output 
	// will all be numbers.
	
	// Our example alphabet.
	private String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 ./'-:,"; // our 43 char alphabet
	
	// A map between the alphabet characters and their numerical representation.
  // private HashMap<Integer, String> map = new HashMap<>();
	
	/**
	 * Initialize with the default alphabet.
	 */
	public OneTimePad() {
	}
	
	/**
	 * Initialize with the selected alphabet.
	 * @param alphabet
	 */
	public OneTimePad(String alphabet) {
		this.alphabet = alphabet;
	}
	
	/**
	 * Get the current alphabet.
	 * @return A string containing the current alphabet.
	 */
	public String getAlphabet() {
		return this.alphabet;
	}

	/**
	 * Set the current alphabet.
	 * @param alphabet A string containing the desired alphabet.
	 */
	public void setAlphabet(String alphabet) {
		this.alphabet = alphabet;
	}

	/**
	 * Create a key with a given size using a pseudo random number generator. This can be
	 * broken with a long enough message or enough collected messages. This function is here
	 * to support testing. To ensure that the one time pad is unbreakable, use a manually
	 * generated key string of integers ( from 0 to alphabet size -1) or perhaps keyboard
	 * spacing time or something truly random instead of this function.
	 * @param keySize An int containing the size of the desired key.
	 * @return An array of ints containing the generated key.
	 */
	public List<Integer> createPseudoRandomKey(int keySize) {
		Random r = new Random();
		int min = 1;
		int max = this.alphabet.length();
		System.out.println("keySize="+keySize);
		
		// TODO change to use a seed to generate the random values with.
		List<Integer> key = Stream.generate(() -> (r.nextInt(max-min) + min))
				                   .limit(keySize)		
	    			               .collect(Collectors.toList());
		return key;
	}
	
	/**
	 * Convert a string into it's integer representation from our alphabet.
	 * @param inputMsg The input message to convert.
	 * @return The integer encoding of the message.
	 */	
	public List<Integer> convertMsg2Ints (String inputMsg) {
		List<Integer> msgInts = new ArrayList<Integer>();
		Stream.iterate(0, i-> i<inputMsg.length(),i-> i+1)
		      .forEach(i-> msgInts.add(this.alphabet.indexOf(inputMsg.substring(i, i+1))));
		return msgInts;
	}
	
	/**
	 * Encrypt the message.
	 * @param inputMsg The array of ints containing the message mapped to ints.
	 * @param key The array of ints containing the key.
	 * @return An array of ints containing the encrypted message.
	 */
	public List<Integer> encrypt (List<Integer> inputMsg, List<Integer> key) {
		// Add the key to the message mod alphabet size.
		List<Integer> addedBytes = new ArrayList<Integer>();;
		Stream.iterate(0, i-> i<inputMsg.size(), i-> i+1) 
		      .forEach(i-> addedBytes.add(Math.floorMod((inputMsg.get(i) + key.get(i)), this.alphabet.length())));
		return addedBytes;
	}
	
	/**
	 * Decrypt the message.
	 * @param encryptedMsg An array of ints containing the encrypted message.
	 * @param key An array of ints containing the key.
	 * @return An array of ints which can be mapped back to message characters.
	 */
	public List<Integer> decrypt (List<Integer> encryptedMsg, List<Integer> key) {
		// Subtract the key mod alphabet size.
		List<Integer> subBytes = new ArrayList<Integer>();
		Stream.iterate(0, i-> i<encryptedMsg.size(), i-> i+1)
		      .forEach(i-> subBytes.add(Math.floorMod((encryptedMsg.get(i) - key.get(i)), this.alphabet.length())));
		return subBytes;
	}
	
	/**
	 * Map the message back to its alphabet.
	 * @param msg An array of ints that map to alphabet characters.
	 * @return The String containing the message.
	 */
	public String convertMsg2String (List<Integer> msg) {
		StringBuffer outputMsg = new StringBuffer();
		Stream.iterate(0, i-> i<msg.size(), i-> i+1)
    	      .forEach(i-> outputMsg.append(this.alphabet.substring(msg.get(i), msg.get(i)+1)));    
		return outputMsg.toString();
	}
	
	/**
	 * Pretty print the encrypted message into 5 character groups.
	 * @param encryptedMsg An array of ints containing the encrypted message.
	 * @return A string containing the encrypted message grouped into 5 
	 *         character groups separated by a blank and 0 filled at the end.
	 */
	public String prettyPrint (List<Integer> encryptedMsg) {
		// Create a string of the encrypted numbers, then separate into groups of 5.
		StringBuffer stringBuf = new StringBuffer();
		Stream.iterate(0, i-> i<encryptedMsg.size(), i-> i+1)
		      .forEach(i-> stringBuf.append(String.format("%02d", encryptedMsg.get(i))));
				
		// Take the string buffer and add in spaces after every 5 characters.
		// insert the first blank at 5, then loop to find the last blank and insert 5 positions later
		stringBuf.insert(5, " ");
		boolean complete = false;
		while (!complete) {
			if ((stringBuf.lastIndexOf(" ") + 6) < stringBuf.length()) {
			     stringBuf.insert(stringBuf.lastIndexOf(" ") + 6, " ");
			}  
			else {
				// Determine the number of 0's to append.
				// TODO Test when the diff is 0.
				int diff = (stringBuf.lastIndexOf(" ") + 6) - stringBuf.length();
				for (int j=0; j<diff; j++) {
					stringBuf.append("0");
				}
				complete = true;
			}    
		} 
		return stringBuf.toString();
	}

}

package otpapi;

import java.util.List;

public class OTP_Test {
	
	/**
	 * This class tests each use case for the API. There may be a few more test cases needed.
	 * May use JUnit later.
	 */
	public void testOTP() {	
		
		// Create the test message. We are using a 42 character alphabet to get spaces, periods, 
		// numbers and a couple of special characters.
		OneTimePad otp = new OneTimePad();
		String testMsg = "1, 2, 3 ... THIS IS A SIMPLE TEST MESSAGE TO TEST OUT THE ONE TIME PAD.";
		
		// Convert the test message to an array of ints, may use bytes later;
		List<Integer> msgInts = otp.convertMsg2Ints(testMsg);
		
		// Display msgBytes
		System.out.println("msgBytes:");
		for (int i=0; i<msgInts.size() ; i++) {
			System.out.println("message letter " + testMsg.substring(i, i+1) + " = " + msgInts.get(i));
		}
		
		// Key Creation
    List<Integer> keyChars = otp.createPseudoRandomKey(msgInts.size());
    String prettyKey = otp.prettyPrint(keyChars);
		System.out.println("Pretty printed key: ");
		System.out.println("     " + prettyKey);
		
    // Encrypt
    List<Integer> addedInts = otp.encrypt(msgInts, keyChars);
		
		// Display the encrypted letters
		System.out.println("addedBytes:");
		for (int i=0; i<addedInts.size() ; i++) {
			System.out.println("added byte " + i + " = " + addedInts.get(i));
		}
		
		// Decrypt the message
		List<Integer> subInts = otp.decrypt(addedInts, keyChars);

		// Display the message.
		System.out.println("subBytes:");
		for (int i=0; i<subInts.size() ; i++) {
			System.out.println("subtracted byte " + i + " = " + subInts.get(i));
		}
		
		// Map the message back to a string.
		String outputMsg = otp.convertMsg2String (subInts);
		System.out.println("outputMsg: " + outputMsg);
		
		// Create a string of the encrypted numbers, then separate into groups of 5.
		String prettyMsg = otp.prettyPrint(addedInts);
		System.out.println("Pretty printed encrypted message: ");
		System.out.println("     " + prettyMsg);
	}
	
	public static void main(String[] args) {	
    OTP_Test prog = new OTP_Test();
    prog.testOTP();
	}

}