private void ButtonClick(object sender, EventArgs e)
{
if (ErrorsFound())
{
var errorMessage = new MessageDialog(this, DialogFlags.DestroyWithParent, MessageType.Error, ButtonsType.None,
"Wrong pararameters\nOne rotor can not be used twice");
errorMessage.ShowAll();
return;
}
BuildRotors();
var left = AssignRotor(rotorLeftType.ActiveText);
var center = AssignRotor(rotorCenterType.ActiveText);
var right = AssignRotor(rotorRightType.ActiveText);
BuildReflectors();
var reflector = AssignReflector(reflectorType.ActiveText);
var plugboardCipher = BuildPlugboardCipher(GetPlugboardString());
BuildPlugboard(plugboardCipher);
var posRef = reflectorPosition.Active;
var startLeft = rotorLeftStartPosition.Active;
var startCenter = rotorCenterStartPosition.Active;
var startRight = rotorRightStartPosition.Active;
var ringLeft = rotorLeftRingPosition.Active;
var ringCenter = rotorCenterRingPosition.Active;
var ringRight = rotorRightRingPosition.Active;
var machine = new Enigma.Enigma(_plugboard, left, center, right, reflector);
machine.SetRingPositions(posRef, ringLeft, ringCenter, ringRight);
machine.SetPositions(startLeft, startCenter, startRight);
var message = inputText.Buffer.Text;
var messageLetters = "";
foreach (var ch in message)
{
if (char.IsUpper(ch))
{
messageLetters += ch;
}
else if (char.IsLower(ch))
{
messageLetters += char.ToUpper(ch);
}
}
var res = messageLetters.Aggregate("", (current, t) => current + (char)(machine.Convert(t - 'A') + 'A'));
outputText.Buffer.Text = res;
}
private void buttonChooseVersion_Click(object sender, EventArgs e)
{
string path = IO.chooseFile("Enigma auswählen", "JSON-Dateien|*.json");
StreamReader reader = new StreamReader(path);
string data = reader.ReadToEnd();
reader.Close();
enigma = JsonConvert.DeserializeObject <Enigma>(data);
richTextBoxVersion.Text = enigma.toString();
buttonNext.Enabled = true;
}
static void Main(string[] args)
{
//starting the Enigma with the specified starting position
var e = new Enigma(12, 8, 20);
var newCh = '.';
while (true)
{
DrawUI(newCh);
ConsoleKeyInfo pressed;
pressed = Console.ReadKey();
newCh = e.Encrypt(pressed.KeyChar);
}
}
public _FormMain(Enigma enigma, Form previous)
{
InitializeComponent();
this.enigma = enigma;
this.previous = previous;
hitboxes = new List <IHitbox>();
wires = new CharacterEllipse(30, 60, 200);
enigma.cableConnections = new Connections(new char[, ] {
{ 'A', 'Q' }, { 'C', 'G' }, { 'A', 'T' }
});
enigma.wheelCombination[0] = 0;
enigma.wheelCombination[1] = 1;
enigma.wheelCombination[2] = 2;
enigma.wheelSettings[0] = 0;
enigma.wheelSettings[1] = 0;
}
static void Main(string[] args)
{
Console.WriteLine("Input source filename");
var fileName = Console.ReadLine();
Console.WriteLine($"inputed filename = {fileName}");
var bytes = File.ReadAllBytes(fileName);
var enigma = new Enigma.Enigma();
var bytesRes = new byte[bytes.Length];
for (int i = 0; i < bytes.Length; i++)
{
//Console.WriteLine(bytes.ElementAt(i));
var res = enigma.InputValue(bytes.ElementAt(i));
bytesRes[i] = (byte)res;
}
Console.WriteLine("Input destination file");
fileName = Console.ReadLine();
Console.WriteLine($"inputed filename = {fileName}");
File.WriteAllBytes(fileName, bytesRes);
}
static void Main()
{
Console.WriteLine("Input Wheels: ");
char a = Console.ReadKey().KeyChar;
char b = Console.ReadKey().KeyChar;
char c = Console.ReadKey().KeyChar;
Console.WriteLine("\nMessage: ");
string message = Console.ReadLine();
Enigma machine = new Enigma(a, b, c);
machine.SetMessage(message);
machine.Cipher();
Console.WriteLine(machine.GetMessage());
Console.WriteLine("Input Wheels: ");
char d = Console.ReadKey().KeyChar;
char e = Console.ReadKey().KeyChar;
char f = Console.ReadKey().KeyChar;
Console.WriteLine();
machine.Decipher(d, e, f);
Console.WriteLine(machine.GetMessage());
}
// function to run performance tests
static public void performance()
{
// ROTORS
string[] rotorArray = { "EKMFLGDQVZNTOWYHXUSPAIBRCJ", "AJDKSIRUXBLHWTMCQGZNPYFVOE", "BDFHJLCPRTXVZNYEIWGAKMUSQO", "ESOVPZJAYQUIRHXLNFTGKDCMWB", "VZBRGITYUPSDNHLXAWMJQOFECK" };
rotorArray[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
rotorArray[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
rotorArray[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
rotorArray[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
rotorArray[4] = "VZBRGITYUPSDNHLXAWMJQOFECK";
char[] notches = { 'Q', 'E', 'V', 'J', 'Z' };
// reflector
Reflector r = new Reflector();
// plugboRD
Plugboard p = new Plugboard();
string plug = "ZU HL CQ WM OA PY EB TR DN VI";
char[] ar = plug.ToCharArray();
//-------------------------------------------------------------------------------
//get rotors
//-------------------------------------------------------------------------------
int n = 0;
while (n < 1000)
{
Random rnd = new Random();
int r1, r2, r3;
int of1, of2, of3;
int ri1, ri2, ri3;
do
{
r1 = rnd.Next(5);
r2 = rnd.Next(5);
r3 = rnd.Next(5);
} while (r1 == r2 || r2 == r3 || r1 == r3);
//-------------------------------------------------------------------------------
//get offset
//-------------------------------------------------------------------------------
do
{
of1 = rnd.Next(26);
of2 = rnd.Next(26);
of3 = rnd.Next(26);
} while (of1 == of2 || of2 == of3 || of1 == of3);
//-------------------------------------------------------------------------------
//get ring setting
//-------------------------------------------------------------------------------
do
{
ri1 = rnd.Next(26);
ri2 = rnd.Next(26);
ri3 = rnd.Next(26);
} while (ri1 == ri2 || ri2 == ri3 || ri1 == ri3);
//-------------------------------------------------------------------------------
//get notch
//-------------------------------------------------------------------------------
Rotor ro1 = new Rotor(of1, ri1, notches[r1], rotorArray[r1]);
Rotor ro2 = new Rotor(of2, ri2, notches[r2], rotorArray[r2]);
Rotor ro3 = new Rotor(of3, ri3, notches[r3], rotorArray[r3]);
Enigma e = new Enigma(ro3, ro2, ro1, p, r);
string str = "UMDPQCUAQNLVVSPIARKCTTRJQKCFPTOKRGOZXALDRLPUHAUZSOSZFSUGWFNFDZCUGVEXUULQYXOTCYRPSYGGZHQMAGPZDKCKGOJMMYYDDH";
for (int i = 0; i < str.Length; i++)
{
if (str[i] == ' ')
{
continue;
}
else
{
//Console.Write(e.RunEnigma(str[i]));
e.RunEnigma(str[i]);
}
}
Console.WriteLine();
n++;
}
}
// main function
static void Main(string[] args)
{
// ROTORS
string[] rotorArray = { "EKMFLGDQVZNTOWYHXUSPAIBRCJ", "AJDKSIRUXBLHWTMCQGZNPYFVOE", "BDFHJLCPRTXVZNYEIWGAKMUSQO", "ESOVPZJAYQUIRHXLNFTGKDCMWB", "VZBRGITYUPSDNHLXAWMJQOFECK" };
rotorArray[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
rotorArray[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
rotorArray[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
rotorArray[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
rotorArray[4] = "VZBRGITYUPSDNHLXAWMJQOFECK";
char[] notches = { 'Q', 'E', 'V', 'J', 'Z' };
// reflector
Reflector r = new Reflector();
// plugboRD
Plugboard p = new Plugboard();
do
{
try
{
// INPUT FROM USER
string input;
do
{
int ring1 = 0, ring2 = 0, ring3 = 0, of1 = 0, of2 = 0, of3 = 0, r1 = 0, r2 = 0, r3 = 0;
Console.WriteLine("**********************************");
Console.WriteLine("please, choose your action:");
Console.WriteLine("[1] Dycrypt OR Encrypt");
Console.WriteLine("[2] Quit.");
Console.WriteLine("**********************************");
input = Console.ReadLine();
if (input == "1")
{
//-------------------------------------------------------------------------------
// get plugboard from user
//-------------------------------------------------------------------------------
int flag = 0;
char[] ar;
do
{
Console.WriteLine("Please enter plugboard: (format of: AB CD EF) ");
ar = Console.ReadLine().ToUpper().ToCharArray();
if (checkplugboard(ar) != false)
{
flag = 1;
p.setPlugboard(ar);
}
else
{
Console.WriteLine();
Console.WriteLine("wrong input.");
}
} while (flag == 0);
//-------------------------------------------------------------------------------
//get rotors
//-------------------------------------------------------------------------------
flag = 0;
do
{
try
{
Console.WriteLine("Please enter rotors: (format of 1-2-3 OR 5-4-3)");
string rotors = Console.ReadLine();
r1 = rotors[0] - 49;
r2 = rotors[2] - 49;
r3 = rotors[4] - 49;
flag = 1;
}
catch (System.IndexOutOfRangeException) { Console.WriteLine(); Console.WriteLine("wrong input."); }
catch (System.IO.IOException) { Console.WriteLine(); Console.WriteLine("wrong input."); }
} while (flag == 0);
//-------------------------------------------------------------------------------
//get offset
//-------------------------------------------------------------------------------
flag = 0;
do
{
try
{
Console.WriteLine("Please enter offset: (format of 01-20-13 OR 02-13-25)");
string offsets = Console.ReadLine();
of1 = (offsets[0] - 48) * 10 + (offsets[1] - 48) - 1;
of2 = (offsets[3] - 48) * 10 + (offsets[4] - 48) - 1;
of3 = (offsets[6] - 48) * 10 + (offsets[7] - 48) - 1;
flag = 1;
}
catch (System.IndexOutOfRangeException) { Console.WriteLine(); Console.WriteLine("wrong input."); }
catch (System.IO.IOException) { Console.WriteLine(); Console.WriteLine("wrong input."); }
} while (flag == 0);
//-------------------------------------------------------------------------------
//get ring setting
//-------------------------------------------------------------------------------
flag = 0;
do
{
try
{
Console.WriteLine("Please enter ring settings: (format of 01-20-13 OR 02-13-25)");
string ringsettings = Console.ReadLine();
ring1 = (ringsettings[0] - 48) * 10 + (ringsettings[1] - 48) - 1;
ring2 = (ringsettings[3] - 48) * 10 + (ringsettings[4] - 48) - 1;
ring3 = (ringsettings[6] - 48) * 10 + (ringsettings[7] - 48) - 1;
flag = 1;
}
catch (System.IndexOutOfRangeException) { Console.WriteLine(); Console.WriteLine("wrong input."); }
catch (System.IO.IOException) { Console.WriteLine(); Console.WriteLine("wrong input."); }
} while (flag == 0);
//-------------------------------------------------------------------------------
//get notch
//-------------------------------------------------------------------------------
Rotor ro1 = new Rotor(of1, ring1, notches[r1], rotorArray[r1]);
Rotor ro2 = new Rotor(of2, ring2, notches[r2], rotorArray[r2]);
Rotor ro3 = new Rotor(of3, ring3, notches[r3], rotorArray[r3]);
Enigma e = new Enigma(ro3, ro2, ro1, p, r);
Console.WriteLine("Please enter the message:");
string str = Console.ReadLine().ToUpper();
Console.WriteLine("************* OUTPUT *************");
for (int i = 0; i < str.Length; i++)
{
if (str[i] == ' ')
{
continue;
}
else
{
Console.Write(e.RunEnigma(str[i]));
}
}
Console.WriteLine();
Console.WriteLine("**********************************");
Console.WriteLine("PRESS ENTER TO CONTINEU.");
Console.ReadLine();
Console.Clear();
Console.WriteLine("**********************************");
Console.WriteLine("**********************************");
Console.WriteLine("Last runnig enigma settings are:");
Console.WriteLine("Rotors: " + (r1 + 1) + "-" + (r2 + 1) + "-" + (r3 + 1) + ".");
Console.WriteLine("Plugboard: " + new string(ar));
Console.WriteLine("Offset: " + (ro1.getOffset() + 1) + "-" + (ro2.getOffset() + 1) + "-" + (ro3.getOffset() + 1) + ".");
Console.WriteLine("Ring settings: " + (ring1 + 1) + "-" + (ring2 + 1) + "-" + (ring3 + 1) + ".");
Console.WriteLine("**********************************");
}
else if (input == "2")
{
Console.WriteLine("see ya.");
return;
}
else
{
Console.Clear();
Console.WriteLine("wrong input..");
}
} while (input != "0");
// performance();
}
catch (System.IO.IOException)
{
Console.Clear();
Console.WriteLine("wrong input.");
}
catch (System.IndexOutOfRangeException)
{
Console.Clear();
Console.WriteLine("wrong input.");
}
} while (true);
// performance();
}
/// <summary>
/// Main function.
/// </summary>
/// <param name="args">Program arguments.</param>
public static void Main(string[] args)
{
CheckForErrors(args);
BuildRotors();
var left = AssignRotor(args[1]);
var center = AssignRotor(args[2]);
var right = AssignRotor(args[3]);
BuildReflectors();
var reflector = AssignReflector(args[0]);
if (args.Length == 7)
{
var plugboardCipher = BuildPlugboardCipher(args[6]);
BuildPlugboard(plugboardCipher);
}
else
{
BuildPlugboard();
}
var posRef = args[4][0] - 'A';
var ringLeft = args[4][1] - 'A';
var ringCenter = args[4][2] - 'A';
var ringRight = args[4][3] - 'A';
var startLeft = args[5][0] - 'A';
var startCenter = args[5][1] - 'A';
var startRight = args[5][2] - 'A';
var machine = new Enigma(_plugboard, left, center, right, reflector);
machine.SetRingPositions(posRef, ringLeft, ringCenter, ringRight);
machine.SetPositions(startLeft, startCenter, startRight);
var message = Console.ReadLine();
var messageLetters = "";
if (message == null)
{
Console.WriteLine("Invalid input.");
Environment.Exit(InvalidInput);
}
foreach (var ch in message)
{
if (char.IsUpper(ch))
{
messageLetters += ch;
}
else if (char.IsLower(ch))
{
messageLetters += char.ToUpper(ch);
}
}
var res = messageLetters.Aggregate("", (current, t) => current + (char)(machine.Convert(t - 'A') + 'A'));
Console.WriteLine(res);
}
/*Hello! This is an Enigma Machine.
* Currently your machine is set up like this:
*
* [ R1 ][ R2 ][ R3 ]
* [ 01 ][ 01 ][ 01 ]
*
* ABCDEFGHIJKLMNOPQRSTUVWXYZ
* ||||||||||||||||||||||||||
* ABCDEFGHIJKLMNOPQRSTUVWXYZ
*
* [1] Use the machine.
* [2] Change the rotors.
* [3] Wire the plugbox.
* [4] Exit the application.
*
*/
static void Main(string[] args)
{
Rotor[] aantalRotors = new Rotor[5];
Plugbox enigmaPlugbox = new Plugbox();
Enigma enigma = new Enigma();
enigma = new Enigma();
// default/start waarden invullen
int[] currentRotors = { 1, 2, 3 };
char[] menuKeuzes = { '1', '2', '3', '4' };
char keyStrike;
for (int i = 0; i < aantalRotors.Length; i++)
{
aantalRotors[i] = new Rotor();
aantalRotors[i].myCode = i;
}
Console.WriteLine($"Hello! This is an Enigma Machine.\n" +
$"Currently your machine is set up like this:\n\n");
printRotor();
printPlugbox();
// menu keuze functie aanmaken
Console.Write($"\n");
Console.WriteLine($"[1] Use the machine.\n" +
$"[2] Change the rotors.\n" +
$"[3] Wire the plugbox.\n" +
$"[4] Exit the application\n");
do
{
keyStrike = Console.ReadKey().KeyChar;
}while (!menuKeuzes.Contains(keyStrike));
switch (keyStrike)
{
case '1':
useMachine();
break;
case '2':
break;
case '3':
break;
case '4':
break;
}
void printRotor()
{
foreach (Rotor enigmaRotor in enigma.Rotors)
{
if (currentRotors.Contains(enigmaRotor.myCode))
{
Console.Write($"[ R{enigmaRotor.myCode} ] ");
}
}
Console.Write("\n");
foreach (Rotor enigmaRotor in enigma.Rotors)
{
if (currentRotors.Contains(enigmaRotor.myCode))
{
Console.Write("[ " + String.Format("{0:00}", enigmaRotor.myRotation) + " ] ");
}
}
Console.Write("\n");
}
void printPlugbox()
{
Console.WriteLine("\n");
Console.WriteLine(enigmaPlugbox.encryptionKeysLeft);
for (int i = 0; i < enigmaPlugbox.encryptionKeysLeft.Length; i++)
{
if (i != enigmaPlugbox.encryptionKeysLeft.Length - 1)
{
Console.Write("|");
}
else
{
Console.WriteLine("|");
}
}
Console.WriteLine(enigmaPlugbox.encryptionKeysRight);
}
void useMachine()
/*
* [ENIGMA MACHINE]
*
* [ R1 ] [ R2 ] [ R3 ]
* [ 10 ] [ 01 ] [ 01 ]
*
* Input: CIXHNHWGK
* Output:
*/
{
string inputMsg = "";
string outputMsg = "";
ConsoleKeyInfo keyinfo;
do
{
Console.Clear();
Console.WriteLine("[ENIGMA MACHINE]\n");
printRotor();
Console.Write("\n" +
$"Input: {inputMsg}\n" +
$"Output: {outputMsg}\n\n" +
$"(Esc) key to go back\n");
keyinfo = Console.ReadKey(true);
inputMsg += Char.ToUpper(keyinfo.KeyChar);
outputMsg += enigma.Gebruiken(Char.ToUpper(keyinfo.KeyChar));
}while (keyinfo.Key != ConsoleKey.Escape);
}
}
public MappingEdit(Enigma enigma)
{
InitializeComponent();
this.enigma = enigma;
}
