Enigma Machine Project

Project Details

Development Time: 1 month

Team Size: 1

Engine: Unreal Engine 4

Programming language: C++

Main contributions: Player movement, head throwing (Projectile Motion) with preview line, and box pushing

EnigmaMachine Repo

Background

I got the inspiration to make an Enigma Machine after seeing the movie “The Imitation Game” and watching a few Computerphile youtube-videos that talked about how the machine worked and how the code was cracked. My goal with the project was to make a machine that had rotors you could manually rotate and swap out for different configs and to have a working lampboard that shows the encrypted letter.

Resources

I did not want to look at any existing algorithms, as I wanted to try and figure out how the machine works internally. As such I limited myself to only looking up images of disassembled machines, as well as the following resources:

Emulator

Article

Wikipedia page

How it works

A typical machine has an input board, plugboard, lampboard, three RotorWheels, and a reflector. The rotor wheels have unique configs but they behave like rotating substitution ciphers, so RotorWheel I in position 0 might take an A as input and output it as K, whereas another wheel might output the same as X. The wheels can be placed in any of the three positions, and the initial rotation offset and ring setting (which shifts the wiring around) can also be changed.

The first wheel rotates every time a key is pressed, and when it reaches a so-called “turnover notch position” it will rotate the next wheel, which in turn will rotate the last wheel when it reaches its own turnover position, similarly to an odometer. The rotation behaves like an index offset, which makes it so pressing the same key multiple times won’t output the same letter multiple times in a row. At the end of the machine, there is a “reflector” that has pairs of letters mapped together (where a regular wheel would map A to B but not have B mapped to A, the reflector maps A to B and B to A).

Encryption Example

1. A is pressed
2. Wheel 1 rotates and a signal is sent from the keyboard to Wheel 1
3. Wheel 1 receives A and outputs C
4. Wheel 2 receives C and outputs D
5. Wheel 3 receives D and outputs F
6. Reflector receives F and outputs S
7. Wheel 3 receives S and outputs S
8. Wheel 2 receives S and outputs E
9. Wheel 1 receives E and outputs B
10. Lamp with letter B lights up

1. A is pressed
2. Wheel 1 rotates and a signal is sent from the keyboard to Wheel 1
3. Wheel 1 receives A and outputs D
4. …
10. Lamp with letter D lights up

1. A is pressed
2. Wheel 1 rotates and a signal is sent from the keyboard to Wheel 1
3. Wheel 1 receives A and outputs E
4. …
10. Lamp with letter Z lights up

Implementation

For easy and quick access to the interactive input key objects, lamps, and plug-board ports; I chose to use a hash-map with custom structs. I simulate the rotation of the wheels by incrementing an index offset, and the ring setting with a different index offset. These offsets change which letter gets returned by the encryption. When a key is pressed I call EncodeLetter with the alphabet position of the letter as the parameter.

EnigmaComponents Struct Snippet

USTRUCT()
struct FEnigmaComponents
{
	GENERATED_BODY()

	UPROPERTY(EditInstanceOnly)
	AMachineLamp* Lamp;
	UPROPERTY(EditInstanceOnly)
	AMachineKey* Key;
	UPROPERTY(EditInstanceOnly)
	AMachinePort* Port;
};

Individual Rotor Encryption Snippet

NewAlphabetIndex = 0;
InputLetter = Alphabet[Input];
if (reverse == false)
{
	Index = Input + CurrentRotationOffset - RingSettingOffset;
	Wrap(Index, 0, 26);
	CipherLetter = CipherArr[Index];
	NewAlphabetIndex = CipherLetter - 'A' - CurrentRotationOffset + RingSettingOffset;
	Wrap(NewAlphabetIndex, 0, 26);
}
else if (reverse == true)
{
	Index = Input + CurrentRotationOffset - RingSettingOffset;
	Wrap(Index, 0, 26);
	for (int i = 0; i < 26; i++)
	{
		if (CipherArr[i] - 'A' == Index)
		{
			NewAlphabetIndex = i - CurrentRotationOffset + RingSettingOffset;
			Wrap(NewAlphabetIndex, 0, 26);
			break;
		}
	}
}
return NewAlphabetIndex;

Machine Encryption Snippet

int32 AEnigmaMachine::EncodeLetter(int32 AlphabetIndex)
{
	/*
	* ENCRYPTION LOGIC
	* 1. Rotate first wheel every time a key is pressed.
	* 2. Go through plugboard (Check if the letter port is connected to another port if so replace letter)
	* 3. Encrypt the input based on each wheel's configs.
	* 4. Get the connected letter in the reflector.
	* 5. Reverse through the wheels. 
		(different encryption to simulate the electric signal going the opposite way)
	* 6. Go through plugboard again
	* 7. Turn on the lamp matching the encrypted key, and output it to the onscreen textwidget.
	*/

	RotorWheels[0]->Rotate();

	FString Key = "";
	Key.AppendChar((TCHAR)(AlphabetIndex + 'A'));
	TWeakObjectPtr<AMachinePort> Port = LetterComponents[Key].Port->GetSwappedPort();
	if (Port != nullptr)
	{
		AlphabetIndex = Port->GetLetterIndex();
	}

	TCHAR Letter;

	for (int i = 0; i < 3; i++)
	{
		AlphabetIndex = RotorWheels[i]->Encode(AlphabetIndex, false);
		Letter = (TCHAR)(AlphabetIndex + 'A');
	}

	AlphabetIndex = ReflectorWheel->Encode(AlphabetIndex, false);
	Letter = (TCHAR)(AlphabetIndex + 'A');

	for (int i = 2; i >= 0; i--)
	{
		AlphabetIndex = RotorWheels[i]->Encode(AlphabetIndex, true);
		Letter = (TCHAR)(AlphabetIndex + 'A');
	}
	Key = "";
	Key.AppendChar(Letter);
	Port = LetterComponents[Key].Port->GetSwappedPort();
	if (Port != nullptr)
	{
		AlphabetIndex = Port->GetLetterIndex();
		Letter = (TCHAR)(AlphabetIndex + 'A');
	}
	
	if (LastLampKey != "")
	{
		LetterComponents[LastLampKey].Lamp->TurnOff();
	}

	LastLampKey.Reset();
	LastLampKey = LastLampKey.AppendChar(Letter);
	LetterComponents[LastLampKey].Lamp->TurnOn();

	FString ReadableText = "";
	OutputText += Letter;
	ReadableText += OutputText[0];
	
	for (int i = 1; i < OutputText.Len(); i++)
	{
		if (i % 5 == 0)
			ReadableText += " ";

		ReadableText += OutputText[i];
	}

	OutputWidget->SetText(ReadableText);
}

Learning outcomes so far

This project taught me a lot already. I have gotten a lot more experience in working with Unreal Engine C++ and its custom implementation of fstructs and ubojects, learned about the inner workings of an Enigma Machine, and reverse engineering based on expected results.

I have more features planned that haven’t made it in yet: I want to implement a plug-board with cable connectors, and have the player to walk around and find machine parts, and have more things to decrypt!