The goal of this lab is to introduce you to basic concepts in the C++ program language. Concepts you will be familiar with after this lab include:

• basic user input/output (i.e., cin, cout)
• file input and output (using the fstream library)
• function declarations, definitions, and calls
• managing arrays, including passing to functions
• for loops
• defensive programming (e.g., detecting improper input)

A skeleton version the program will appear in your cs35/labs/02 directory when you run update35. The program handin35 will only submit files in this directory. In this and most future labs, you'll work with one partner (there is one group of three). I am assigning partners for this lab; find your partner in this file. Useful links: In the extras directory of this lab, there are a couple of text files, along with encryptions of each file using each encryption scheme you'll have to implement for this lab. Use these to compare against your encrypt implementations, and compare your decrypted files with the original text file to make sure you're encrypting and decrypting correctly.

Encryption is the process of encoding messages in such a way that only authorized parties can read the message. The idea of encrypting messages is thousands of years old and has been particularly useful in the military, where it is important to exchange messages (e.g. "Attack at dawn!" vs "Hold your ground") without enemies being able to understand them in the event a message is intercepted. A cipher is a kind of encryption scheme where each letter is replaced by another. Ciphers have been used since at least Roman times. Julius Caesar used an cipher where each letter of the message was replaced with one three positions earlier in the alphabet. So, for instance, 'A' is encrypted as 'X', 'B' becomes 'Y', 'C' is encrypted as 'Z', 'D' is encrypted as 'A', and so on. An encrypted message is called the ciphertext, and if an enemy intercepted a message, it would just look like a jumble of letters. On the other hand, Caesar's subordinates, knowing the encryption scheme, could decrypt the message by employing doing the opposite of the encryption scheme: 'A' is decrypted as 'D', 'B' is decrypted as 'E', etc. This cipher was used so effectively that it became known as the Caesar cipher. In this lab, you will implement the following ciphers:

• Caesar cipher. Replace each letter with one three letters before it. (The encryption and decryption routines for this cipher have been provided).
• ROT13. Short for rotate-13. Replace each letter with one 13 letters after it. (e.g. replace 'A' with 'N', 'B' with 'O', 'C' with 'P', etc)
• Substitution. Repace each letter with an arbitrary fixed substitution. (e.g. replace every 'A' with 'M'; 'B' with 'D', etc.) You will need to read in what substitutions to make from a file.
• Enigma Cipher. In World War II, the Germans used a very sophisticated cipher generated by a machine called the Engima Machine. This machine looked somewhat similar to a typewriter, but contained three rotors under the hood. When a letter was typed into the machine, it would be encrypted into a different letter based on the rotor positions. More importantly, after each letter, the rotors rotated, changing how future letters were encrypted. For more details, see the last part of this writeup.

The Allies made a huge effort to break the Engima code during World War II. This task was led in part by Alan Turing, and it was said that breaking the enigma machine shortened the war in Europe by two years. The effort to break German ciphers also resulted in the first electrical digital computers.

The essential flow of your program will be as follows: The user specifies whether they want to encrypt or decrypt. Then they must specifiy input and output files and the cipher they wish to use. Finally, your program must use the requested cipher to encrypt or decrypt the input file, writing it to the output file.

I recommend implementing your lab assignment in 4 phases:

1. File Input and Output - be able to read in a text file and output it without loss of information.
2. ROT13, Substitution ciphers - implement all the ROT13 and Substitution ciphers and verify that they correctly encrypt and decrypt text.
3. Implement a menu-based interface - fill in your program by adding user interaction to choose (i) whether to encrypt or decrypt and (ii) which cipher to use.
4. Enigma Cipher - complete the lab by implementing the Engima cipher.

Your program should use proper design. That is, your program will be tested on your use of modular functions and understanding of how to call, define, and declare functions in C++.

You should complete the following items:

1. enigma.cpp This file will contain your entire completed assignment
2. any encrypted files or decrypted files you feel will show the graders that your ciphers work as advertised.
3. README Answer a few short questions in this file

---

I. File Input and Output

Your program will need to handle opening, reading, closing, and writing to file.

• The user will specify the name of the input file. Depending on whether the user wants to encrypt or decrypt, the input file will contain either raw text or a ciphertext i.e. an encrypted file. Either way, the input file is opened using the ifstream data type.

        string inputFileName = "message.txt";  // get this filename from user
        ifstream inputFile(inputFileName.c_str());
      

• To read from a file, treat inputFile the same as cin. You can read in any basic data type including integers, characters, and strings. The >> operator parses text by reading all characters until whitespace is found. It will also ignore all preceding whitespace. For example, to read the lines:

  	The
  	356     blue
      

  You can use the code:

  	string word, color;
  	int number;
  	input >> word;   //"The"
  	input >> number; //356
  	input >> color;  //"blue"
      

  Notice that the strings do not contain whitespace, and that it automatically skipped the whitespace between 356 and blue.
  In this lab, it will be useful to read in lines as characters. The above text can be read as characters as follows:

          char c;
  	input >> c; // 'T'
  	input >> c; // 'h'
  	input >> c; // 'e'
  	input >> c; // '3'
  	input >> c; // '5'
  	...
      

  Notice that whitespace is still skipped even though characters are being read one at a time.


• It is not specified how long the text files are, so you will need to know if the file still has data to read. Use the eof() function to do this. That is, if inputFile.eof() returns true, you have reached the end of the file and should not continue. Depending on your algorithm, this may not be necessary.


• The user will specify an output filename. Opening this is similar to the example above, except you will use the ofstream data type. Details on file i/o can be found here. Here is an example of loading an output file and writing the variables above:

  	string outName = "output.txt";
  	ofstream outputFile(outName.c_str());
  	output << word << endl;
  	output << number << "   " << color << endl;
          

• In the first phase, your goal is just to make a copy of the input file, i.e. you should read in the entire input file and write it to the output file. Does the text in your output file correspond to the text in your input file? Note: in this lab, it is the text that is important, not the whitespace. Do not feel like you need to maintain spacing and/or linebreaks in this phase. Feel free to include whatever whitespace you wish.

Example text files are available in the input folder in your labs directory for this week.

Review of requirements before moving forward:

• Check if input file opened properly
• reads all text from input file
• writes all text to output file
• All files are closed when no longer used
• Test program: output file should match input (up to differences in whitespace)

---

II. Encryption and Decryption Functions

Once you are able to replicate a text file, you can begin writing your encryption and decryption functions. At this stage, you should implement encryption and decryption functions for the Caesar, ROT13, and substitution ciphers. Hold off on implementing the Enigma cipher until the last stage. Let's begin with the encryption function for the Caesar cipher.

• I have given you code for functions caesar_encrypt and caesar_decrypt:

        void caesar_encrypt(ifstream& inFile, ofstream& outFile);
        void caesar_decrypt(ifstream& inFile, ofstream& outFile);
      

  The caesar_encrypt function takes references to already opened input and output file streams. It then reads in one character at a time, encrypts according to the Caesar cipher, and writes the corresponding character out to the output stream. The caesar_decrypt does something similar, decrypting characters instead of encrypting them.
  Take these existing functions and use them with your code from phase I to encrypt the file input/sample.txt. Verify that your function works by comparing the output to the file encrypted/sample-caesar.enc. Do the files look identical?
• Next, write encryption and decryption functions for the ROT13 cipher. These should be very similar to caesar_encrypt and caesar_decrypt. Once you have written these functions, test them by encrypting input/sample.txt. Compare the output to the file encrypted/sample-rot.enc. Do the files look identical? Also test the decryption function by decrypting this file and comparing it to sample.txt. The text in the decrypted file should match (up to whitespace) the text of the file you encrypted.
• Write functions substitute_encrypt and substitute_decrypt that implement the encryption and decryption schemes for the substitution cipher. Again, when you finish writing the encrpytion function, test it by encrypting input/sample.txt using the substitution setting from input/subsetting and comparing to the encrypted file input/sample-sub.enc. After you write the decryption function, test it by decrypting some files you encrypted using substitute_encrypt.

In all cases, do not just test using input/sample.txt. Also encrypt and decrypt several larger text files, with more varied text, to ensure you handle encryption and decryption in all cases.

Managing the encryption and decryption. So you read in a letter 'K' and are encrypting using the Caesar cipher. How does your lab figure out that 'H' is the encrypted character? More generally, with an arbitrary cipher, how should the data be structured to manage the encryption? There are several different possibilities, but the most straightforward is to use arrays. In the case of the Caesar cipher, the most straightforward solution is to use a character array:

    char alphabet[] = {'A','B','C','D','E','F','G', 'H','I', 'J',
    'K','L','M','N','O','P','Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
    'Y', 'Z'};
  

When encrypting a character, search through this array (using a for loop) until you find the index of the character to encrypt. Then subtract 3 from the index and output that character. Warning: you will need to handle the case where the cipher "wraps around" e.g. when you want to encrypt 'B' as 'Y'.

Managing arbitrary substitutions in the substitution cipher. The Substitution cipher allows arbitrary substitutions. You should enable the user to pick any permutations she likes. To enable arbitrary permutations here, load a substitution alphabet from a file and store it in a second character array. The format of your file should be just a permutation of characters, such as the example in input/subalpha:

    KJRTPEQFBHYLZDOCMASWUVNXIG
  

Your substitution cipher should take this setting and use it to encrypt 'A' as 'K', 'B' as 'J', 'C' as 'R', and so on.

Handling nonalphabetic characters. In this lab you can assume that the text consists of all capital letters, along with possibly some whitespace, which you can ignore. What happens if the text contains characters which are not capital letters, such as lower case letters, numbers, or punctuation? For this lab, feel free to ignore these characters -- if one appears, just leave it out of the encryption and read in the next character. In the real world, these characters might be (i) ignored, (ii) written to the output file without encrypting them, or (iii) encrypting them using some other means. Again, for this lab, you should ignore these characters.

---

III. Implementing the User Interface

The overall design of your program should be as follows:

Greet user.
Ask user if they want to encrypt, decrypt, or exit.
Repeat the following until the user chooses to exit.
  Ask user for input file (check if valid)
  Ask user for output file
  Ask user which encryption/decryption scheme he/she wants to use.
  If necessary, load settings for the chosen encrypyion/decryption scheme.
  For each character in the text:
    read in the character
    encrypt or decrypt the character using the cipher chosen by the user
    write character to output file.
  Close input and output files.

There are multiple ways to implement this user interface. One possible solution is to implement three menus:

• A main menu which asks the user if they want to encrypt, decrypt, or exit.
• An encryption menu which presents choices of ciphers the user can use to encrypt a plaintext file.
• A decryption menu which presents choices of ciphers the user will use to decrypt a ciphertext file.

Your program should either encrypt or decrypt the chosen input file as demanded by the user. At all times, you should practice defensive programming.

---

IV. Implementing the Enigma Cipher

For the final part of your lab, you'll implement a simplified version of the Enigma Machine cipher. Warning: this is more complicated than previous ciphers, and I strongly recommend you get the rest of your lab working first. An Enigma machine uses three rotors. Each rotor (call them the inner, middle, and outer rotors) contains some fixed permutation of the letters. To encrypt a character c, perform the following:

1. Locate c on the inner rotor.
2. Find the character on the outer rotor aligned with c. Call this character c'.
3. Locate c' on the middle rotor.
4. Find the character on the outer rotor aligned with c'. Output this character.

After encrypting a letter but before encrypting the next letter, you must move the rotors in the following way:

1. Move the inner rotor clockwise one position.
2. If the inner rotor is now back in the start position, also move the middle rotor.

Initial Enigma Settings. Like the substitution cipher, you should read in from a file both (i) the initial offset for the inner and middle rotors and (ii) the fixed permutation for each rotor. The format for this file should be as follows. The first line contains integers denoting the inner rotor offset and middle rotor offset respectively. The second, third, and fourth lines contain the information for the inner, middle, and outer rotors respectively. There is an example enigma settings file in input/enigmasettings.

Hint: to implement the enigma cipher, I recommend using character arrays for each rotor. Use integer variables (say inner_offset and middle_offset) to maintain the offsets. In this way, the state of the inner rotor would be implemented with (i) an array of chars and (ii) an offset. If 'D' is the first element of the array and the offset=3, then this character would align with the fourth character in the outer array.

Hint 2: decrypting the enigma cipher can seem complicated, but you still want to do essentially the opposite of the encryption. Specifically, perform the following:

• First, decrypt the character by reversing steps 1-4 in the encryption routine.
• Then move the rotors in the same direction you moved them during encryption. This will ensure the rotors are aligned correctly to decrypt the next character.

• Are you validating user input? Do you correctly handle characters that are not capital letters?
  Do you correctly load settings for the substitution and enigma machine ciphers? Do you exit gracefully when you fail to open files?
• Implement encrypt and decrypt functions for the Caesar cipher, substitution cipher, and Engima Machine cipher.
• Your program must use good design. Main should be fairly simple, calling on other methods to perform work. Use separate functions for each encryption and decryption routine.
• All functions must have a top header comment that includes the functions name, purpose, parameter descriptions, and expected return values if any.
• All significant portions of code and non-trivial code should have a comment explaining purpose.
• All functions must be declared before main, but defined after main.

Once you are satisfied with your code, hand it in by typing handin35. This will copy the code from your cs35/labs/02 to my grading directory. You may run handin35 as many times as you like, and only the most recent submission will be recorded.

The Enigma Machine cipher part of the lab is based on David Reed's NIFTY 2009 submission entitled "Enigma Encryption".