Enigma Simulator Report

Introduction:

During World War II, the German military used the Enigma machine, which was a complicated way

to keep messages secret. The machine used a number of rotors and reflectors to turn plaintext

messages into ciphertext. This made it a very effective instrument for keeping messages secret.

People knew how hard it was to break the code on the Enigma machine because it was so

complicated.

I used the C programming language to make an Enigma simulator for this project. The idea was to

make a program that would replicate how the Enigma machine encrypted messages, letting users

type in plaintext and get encrypted messages back.

Design:

The Enigma simulator was designed to take in rotor and reflector configurations from the command

line arguments. The rotor position, offset, and substitution map were all part of the rotor

arrangement. The substitution map was part of the reflector arrangement. These settings were used

to set up the Enigma machine, which was represented by a struct named "enigma_t" that held the

rotor and reflector settings.

"process_input()" and "rotate_rotor()" were used by the application to encrypt text. The

"process_input()" function was in charge of encrypting a single character by spinning the rotors and

sending the character via the rotor and reflector maps. The function took in a single character and

gave back the encrypted version of that character.

function moved the right rotor forward and checked to see if it also needed to move the centre and

left rotors forward. When the right rotor turned all the way around, the middle rotor turned once. In

the same way, if the middle rotor turned all the way around, the left rotor turned once.

An array of structs, where each struct stood for a rotor, was used to show how the rotors were set

up. Each rotor struct had a position, an offset, and a substitution map. The input character was

encoded using the substitution map, and the location and offset were used to figure out where the

rotor should start and where it should be in relation to the other rotors.

The configuration of the reflector was shown by an array of integers that showed the reflector's

substitution map. After the character went through the rotors, it was encoded again with the help of

the reflector map.

To make sure the encryption worked well, the replacement maps for the rotors and reflectors were

calculated ahead of time and stored in arrays. This meant that the maps didn't have to be

recalculated during encryption.

In short, the design of the Enigma simulator was based on the design of the original Enigma

machine. The substitution maps, rotor configurations, and reflector configurations were utilized to

set up the Enigma machine. To replicate the encryption process, the "process_input()" and

"rotate_rotor()" methods were utilized, and an array of structs was used to show how the rotors

were set up. To make sure the encryption worked well, the substitution maps were also worked out

ahead of time.

Overall, the architecture of the Enigma simulator did a good job of copying the essential parts of the

original Enigma machine and letting text be encrypted in the same way.

Development:
The Enigma simulator was developed using the C programming language, with a modular approach

that separated the functionality into specific functions. Standard C libraries like "stdio.h," "stdlib.h,"

"string.h," and "ctype.h" were used in the program.

The program checked the rotor and reflector configurations that were given on the command line to

make sure they were correct. The software verified the number of arguments to make sure that the

right number of configurations were given. It also tested the position, offset, and substitution map

for each rotor.

Each rotor was set up based on its configuration with the "init_rotor()" function. The function

grabbed the rotor's position, offset, and substitution map and put them in a rotor_t struct. The

location of the rotor was saved as a number between 0 and 25, and the offset was also saved as a

number between 0 and 25. The substitution map was saved as a string of 26 characters.

After each character was processed, each rotor was turned by the "rotate_rotor()" function. The

function just moved the rotor position up by one and checked to see if the offset also needed to be

moved up by one. The "process_input()" method invoked this function after each character was

encrypted.

A single character was encrypted using the "process_input()" method. The function accepted a

character and an enigma_t struct and ran the character through the rotor and reflector maps. First,

the "rotate_rotor()" method was used to turn each rotor. Then, it mapped the character through each

rotor, starting with the last rotor and going backward. After the character went through the reflector,

the function re-routed it through each rotor, starting with the first and moving onward. The ultimate

result was the character that had been scrambled.

The program also has a function called "process_string()," which could handle a whole string of

plaintext. The "process_input()" method was run for each character in the string, and the encrypted

output was saved in a new string.

inputs. For each input, the encrypted output was confirmed to be correct. Overall, the Enigma

simulator is a complete and working model of the way the German military encrypted messages

during World War II.

Testing:

The Enigma simulator was tested using a variety of rotor and reflector configurations. The software

was tested with both valid and invalid setups to make sure it checked the input arguments correctly.

Different input strings were also used to test the application and make sure that the encryption

process was working correctly. To make sure the computer was replicating the Enigma machine

correctly, the output of the program was tested by hand against known Enigma encrypt-ions.

Conclusion:

In conclusion, we successfully developed an Enigma simulator using the C programming language.

The program was designed to mimic the basic components of the original Enigma machine and

allowed users to input plaintext and receive encrypted output. The program was thoroughly tested

and found to produce accurate results for each plaintext input.

Through the development of the Enigma simulator, we were able to gain a deeper understanding of

the encryption process used by the German military during World War II. The simulation helped us

understand how complicated the Enigma machine was, which was originally thought to be

impossible to crack. The Enigma machine was good at encoding communications because the

simulator was able to give accurate results for each plaintext input.

Also, the creation of the Enigma simulator gives people interested in cryptography and computer

programming a great chance to learn about the history and physics of encryption. The initiative
shows how important encryption is in our modern world and how important it is to communicate

securely.

Overall, the Enigma simulator is a fun and interesting way to learn more about how the German

military exploited encryption during World War II. By making this simulator, we were able to learn

a lot about cryptography and programming, which was quite helpful. The initiative is a great

illustration of how technology can be utilized to keep history alive and help people learn about it.

Additionally, the Enigma simulator can be extended and improved upon in various ways. For

example, additional features can be added, such as the ability to set the initial positions and

substitutions of the rotors. Moreover, the program can be optimized for faster processing speed and

can be made more user-friendly with a graphical user interface.

1. "The Code Book" by Simon Singh - This book provides a comprehensive history of
cryptography, including the Enigma machine and its role in World War II.
2. "Codebreakers: The Inside Story of Bletchley Park" by F.H. Hinsley and Alan Stripp - This
book provides an in-depth look at the work done by codebreakers at Bletchley Park during
World War II, including breaking the Enigma code.
3. "Breaking the Enigma Code" by Dermot Turing - This book provides a detailed look at the
efforts to break the Enigma code, including the role played by Alan Turing and the team at
Bletchley Park.
4. The National Security Agency's (NSA) website - The NSA has a page on their website
dedicated to the Enigma machine and its history, including information on their efforts to
break the code during World War II.
5. The Enigma Museum - The Enigma Museum in the Netherlands has a collection of Enigma
machines and other cryptography-related artifacts, as well as information on the history of
the Enigma machine and its use in World War II.