private void button3_Click(object sender, EventArgs e)
{
machineSettings = machine.GetSettings();
wheels[0] = comboBox1.SelectedIndex;
wheels[1] = comboBox2.SelectedIndex;
wheels[2] = comboBox3.SelectedIndex;
}
public static void Encrypt_Decrypt(string fRo, string mRo, string sRo, string Ref, string[] steckers, int fRi, int mRi, int sRi, int fGr, int mGr, int sGr, string text)
{
Enigma_Settings = new EnigmaSettings();
Enigma = new EnigmaMachine(fRo, mRo, sRo, Ref, Enigma_Settings);
text = text.Replace(" ", "").ToUpper();
if (!Regex.IsMatch(text, @"^[a-zA-Z ]+$"))
{
EnigmaWindow.setText("You can only enter letters, no numbers, not special tokens. Try again.");
return;
}
if (!steckers[0].Equals(""))
{
Enigma.setSteckers(steckers);
}
Enigma_Settings.storeRings(fRi, mRi, sRi);
Enigma_Settings.storeGround(fGr, mGr, sGr);
Enigma.setSettings(Enigma_Settings.rings, Enigma_Settings.grund);
printResult(text);
/*Debugging, make sure that the ring setting is taken correctly.
* Enigma_Settings.rings[0] = (Char)(sRi + 64);
*
* EnigmaWindow.setChar(Enigma_Settings.rings[0]);*/
}
public void TestDecodingDoubleStep()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.RotorPositions.Add(21);
settings.RotorPositions.Add(4);
settings.RotorPositions.Add(1);
settings.Reflector = Constants.Reflectors.B;
scramblerUnit = new ScramblerUnitBase(settings);
Assert.AreEqual(21, scramblerUnit.RotorPositions[0]);
Assert.AreEqual(4, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual <string>("T", scramblerUnit.Scramble("Y"));
Assert.AreEqual <string>("E", scramblerUnit.Scramble("B"));
Assert.AreEqual <string>("S", scramblerUnit.Scramble("G"));
Assert.AreEqual <string>("T", scramblerUnit.Scramble("F"));
Assert.AreEqual <string>("I", scramblerUnit.Scramble("J"));
Assert.AreEqual <string>("N", scramblerUnit.Scramble("W"));
Assert.AreEqual <string>("G", scramblerUnit.Scramble("Q"));
}
private static string Start(string message, string rings, string rotors, string reflector, string plugs, string rotorStart)
{
EnigmaMachine machine = new EnigmaMachine();
EnigmaSettings eSettings = new EnigmaSettings();
querySettings(eSettings, rings, rotors, reflector, plugs, rotorStart);
//Message to encrypt
if (!Regex.IsMatch(message, @"^[a-zA-Z ]+$"))
{
return("Error: Only letters A-Z are allowed");
}
message = message.Replace(" ", "").ToUpper();
// Enter settings on machine
machine.setSettings(eSettings.rings, eSettings.grund, eSettings.order, eSettings.reflector);
// The plugboard settings
foreach (string plug in eSettings.plugs)
{
char[] p = plug.ToCharArray();
machine.addPlug(p[0], p[1]);
}
return(machine.runEnigma(message));
}
public void settings_OnPropertyChange(object sender, PropertyChangedEventArgs e)
{
EnigmaSettings settings = sender as EnigmaSettings;
if (e.PropertyName == "Model")
{
if (settings.Model == 2)
{
Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
{
visbileCheckbox.
IsEnabled = true;
}, null);
}
else if (settings.Model == 3)
{
Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
{
visbileCheckbox.
IsEnabled = true;
}, null);
}
else
{
Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
{
visbileCheckbox.
IsEnabled = false;
visbileCheckbox.
IsChecked = false;
}, null);
}
}
}
public void TestDecodingNoStep()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.RotorPositions.Add(1);
settings.RotorPositions.Add(1);
settings.RotorPositions.Add(1);
settings.Reflector = Constants.Reflectors.B;
scramblerUnit = new ScramblerUnitBase(settings);
Assert.AreEqual(1, scramblerUnit.RotorPositions[0]);
Assert.AreEqual(1, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual <string>("T", scramblerUnit.Scramble("O"));
Assert.AreEqual <string>("E", scramblerUnit.Scramble("L"));
Assert.AreEqual <string>("S", scramblerUnit.Scramble("P"));
Assert.AreEqual <string>("T", scramblerUnit.Scramble("F"));
Assert.AreEqual <string>("I", scramblerUnit.Scramble("D"));
Assert.AreEqual <string>("N", scramblerUnit.Scramble("E"));
Assert.AreEqual <string>("G", scramblerUnit.Scramble("Z"));
}
public void TestEncodingSingleStepKnownWorkingExample()
{
// Reflector B I II III
// 1 1 26
// Knowing working traversal (input) rotors | rotors (output)
// (A) B J Z | T L K (U)
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.RotorPositions.Add(26);
settings.RotorPositions.Add(1);
settings.RotorPositions.Add(1);
settings.Reflector = Constants.Reflectors.B;
scramblerUnit = new ScramblerUnitBase(settings);
// (A) B J Z | T L K (U)
// (1) 2 10 26 | 20 12 11 (21)
Assert.AreEqual <string>("U", scramblerUnit.Scramble("A"));
// (A) B E S | F D D (B)
// (1) 2 5 19 | 6 4 4 (2)
Assert.AreEqual <string>("B", scramblerUnit.Scramble("A"));
Assert.AreEqual <string>("D", scramblerUnit.Scramble("A"));
Assert.AreEqual <string>("Z", scramblerUnit.Scramble("A"));
Assert.AreEqual <string>("G", scramblerUnit.Scramble("A"));
}
public void Initialize()
{
Dictionary <string, string> plugBoard = new Dictionary <string, string>();
plugBoard.Add("A", "M");
plugBoard.Add("F", "I");
plugBoard.Add("N", "V");
plugBoard.Add("P", "S");
plugBoard.Add("T", "U");
plugBoard.Add("W", "Z");
EnigmaSettings settings = new EnigmaSettings();
PlugboardBase pb = new PlugboardBase();
pb.Layout = plugBoard;
settings.PlugBoard = pb;
settings.Reflector = Constants.Reflectors.A;
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.I);
settings.Rotors.Add(Constants.Rotors.II);
settings.RotorPositions.Add(Constants.Alpha.L);
settings.RotorPositions.Add(Constants.Alpha.B);
settings.RotorPositions.Add(Constants.Alpha.A);
settings.Rotors[0].Ringstellung = Constants.Alpha.V;
settings.Rotors[1].Ringstellung = Constants.Alpha.M;
settings.Rotors[2].Ringstellung = Constants.Alpha.X;
engimaMachine = new M3(settings);
}
public void TestRingstellung()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.I);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.III);
settings.RotorPositions.Add(Constants.Alpha.G);
settings.RotorPositions.Add(Constants.Alpha.A);
settings.RotorPositions.Add(Constants.Alpha.A);
settings.Rotors[0].Ringstellung = Constants.Alpha.S;
settings.Rotors[1].Ringstellung = Constants.Alpha.B;
settings.Rotors[2].Ringstellung = Constants.Alpha.C;
settings.Reflector = Constants.Reflectors.B;
IEnigmaMachine engimaMachine = new EnigmaMachineBase(settings);
Assert.AreEqual <string>("Y", engimaMachine.EncryptDecrypt("A"));
Assert.AreEqual <string>("F", engimaMachine.EncryptDecrypt("A"));
Assert.AreEqual <string>("F", engimaMachine.EncryptDecrypt("A"));
Assert.AreEqual <string>("X", engimaMachine.EncryptDecrypt("A"));
Assert.AreEqual <string>("D", engimaMachine.EncryptDecrypt("A"));
}
public void Name()
{
IEnigmaSettings settings = new EnigmaSettings();
ICipher cipher = new Enigma(settings);
Assert.Equal("Enigma M3", cipher.CipherName);
Assert.Equal("Enigma M3", cipher.ToString());
}
public M4ScrabmlerUnit(EnigmaSettings settings) : base(settings)
{
// Validate settings
// validate wheel numbers
// validate wheel types
// validate reflector
// validate plugboard
}
public void Decrypt(string plaintext, string ciphertext, char newFastestRotorPosition)
{
IEnigmaSettings settings = new EnigmaSettings();
ICipher cipher = new Enigma(settings);
Assert.Equal(plaintext, cipher.Decrypt(ciphertext));
Assert.Equal(newFastestRotorPosition, settings.Rotors[EnigmaRotorPosition.Fastest].CurrentSetting);
}
/* Query the user for settings
Does not check for invalid input at the moment
*/
private static void querySettings(EnigmaSettings e)
{
string r;
Console.WriteLine("Enigma Machine Emulator\n");
Console.Write("Do you want to: [1] Specify settings [2] Use default settings? (Default: [2]): ");
r = Console.ReadLine();
while (r != "1" && r != "2" && r != "") {
Console.Write("Invalid input, enter 1, 2 or 3 ");
r = Console.ReadLine();
}
if (r == "1") {
Console.Write("Enter the ring settings (Ex. AAA, MCK, Default: AAA): ");
r = Console.ReadLine();
if (r == "")
e.rings = new char[] { 'A', 'A', 'A' };
else
e.rings = r.ToCharArray();
Console.Write("Enter the inital rotor start settings (Ex. AAA, MCK, Default: AAA): ");
r = Console.ReadLine();
if (r == "")
e.grund = new char[] { 'A', 'A', 'A' };
else
e.grund = r.ToCharArray();
Console.Write("Enter the order of the rotors (Ex. I-II-III, III-I-II, Default: I-II-III): ");
r = Console.ReadLine();
if (r == "")
e.order = "I-II-III";
else
e.order = r;
Console.Write("Enter the reflector to use (A, B, or C, Default: B): ");
r = Console.ReadLine();
if (r == "")
e.reflector = 'B';
else
e.reflector = r.ToCharArray()[0];
Console.Write("Enter the plugboard configuration (Ex. KH AB CE IJ, Default: None): ");
r = Console.ReadLine();
if (r == "")
e.plugs.Clear();
else {
string[] plugs = r.Split(' ');
foreach (string s in plugs) {
e.plugs.Add(s);
}
}
} else if (r == "2" || r == "") {
e.setDefault();
}
Console.WriteLine();
}
public void TestEncodingAlphabet()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.RotorPositions.Add(1);
settings.RotorPositions.Add(1);
settings.RotorPositions.Add(1);
settings.Reflector = Constants.Reflectors.B;
scramblerUnit = new ScramblerUnitBase(settings);
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(1, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(1, scramblerUnit.RotorPositions[0]);
Assert.AreEqual <string>("B", scramblerUnit.Scramble("A"));
Assert.AreEqual <string>("J", scramblerUnit.Scramble("B"));
Assert.AreEqual <string>("E", scramblerUnit.Scramble("C"));
Assert.AreEqual <string>("L", scramblerUnit.Scramble("D"));
Assert.AreEqual <string>("R", scramblerUnit.Scramble("E"));
Assert.AreEqual <string>("Q", scramblerUnit.Scramble("F"));
Assert.AreEqual <string>("Z", scramblerUnit.Scramble("G"));
Assert.AreEqual <string>("V", scramblerUnit.Scramble("H"));
Assert.AreEqual <string>("J", scramblerUnit.Scramble("I"));
Assert.AreEqual <string>("W", scramblerUnit.Scramble("J"));
Assert.AreEqual <string>("A", scramblerUnit.Scramble("K"));
Assert.AreEqual <string>("R", scramblerUnit.Scramble("L"));
Assert.AreEqual <string>("X", scramblerUnit.Scramble("M"));
Assert.AreEqual <string>("S", scramblerUnit.Scramble("N"));
Assert.AreEqual <string>("N", scramblerUnit.Scramble("O"));
Assert.AreEqual <string>("B", scramblerUnit.Scramble("P"));
Assert.AreEqual <string>("X", scramblerUnit.Scramble("Q"));
Assert.AreEqual <string>("O", scramblerUnit.Scramble("R"));
Assert.AreEqual <string>("R", scramblerUnit.Scramble("S"));
Assert.AreEqual <string>("S", scramblerUnit.Scramble("T"));
Assert.AreEqual <string>("T", scramblerUnit.Scramble("U"));
Assert.AreEqual <string>("N", scramblerUnit.Scramble("V"));
Assert.AreEqual <string>("C", scramblerUnit.Scramble("W"));
Assert.AreEqual <string>("F", scramblerUnit.Scramble("X"));
Assert.AreEqual <string>("M", scramblerUnit.Scramble("Y"));
Assert.AreEqual <string>("E", scramblerUnit.Scramble("Z"));
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(2, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(1, scramblerUnit.RotorPositions[0]);
}
public void SetSettings(EnigmaSettings enigmaSettings)
{
for (int i = 0; i < this.rotors.Length; i++)
{
this.rotors[i].SetSettings(enigmaSettings.rotorSettings[i]);
}
this.reflector.SetSettings(enigmaSettings.reflectorSettings);
this.plugBoard.SetSettings(enigmaSettings.plugBoardSettings);
Refresh();
}
public void Reflector()
{
IEnigmaSettings settings = new EnigmaSettings()
{
Reflector = new EnigmaReflector()
{
ReflectorNumber = EnigmaReflectorNumber.C
},
};
Assert.Equal(EnigmaReflectorNumber.C, settings.Reflector.ReflectorNumber);
}
public EnigmaSettings GetSettings()
{
var rotorSettings = new RotorSettings[this.rotors.Length];
for (int i = 0; i < this.rotors.Length; i++)
{
rotorSettings[i] = this.rotors[i].GetSettings();
}
var enigmaSettings = new EnigmaSettings(rotorSettings, this.reflector.GetSettings(), this.plugBoard.GetSettings());
return(enigmaSettings);
}
private static void querySettings(EnigmaSettings e)
{
string r;
Console.WriteLine("Enigma Machine Emulator");
Console.WriteLine("Type of left Rotor: III");
Console.WriteLine("Type of middle Rotor: Gamma");
Console.WriteLine("Type of right Rotor: V");
Console.WriteLine("Type of Reflector: C Duhn");
Console.WriteLine("Step L-M-R: 1-1-2");
e.setDefault();
Console.WriteLine();
}
public void DoubleRotorStepTest()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.RotorPositions.Add(21);
settings.RotorPositions.Add(4);
settings.RotorPositions.Add(1);
settings.Reflector = Constants.Reflectors.A;
scramblerUnit = new ScramblerUnitBase(settings);
// Check initial wheel positions
// ADU — normal step of right rotor
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(4, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(21, scramblerUnit.RotorPositions[0]);
// ADV — right rotor(III)goes in V—notch position
scramblerUnit.Scramble("T");
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(4, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(22, scramblerUnit.RotorPositions[0]);
// AEW — right rotor steps, takes middle rotor(II) one step further, which is now in its own E—notch position
scramblerUnit.Scramble("T");
Assert.AreEqual(1, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(5, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(23, scramblerUnit.RotorPositions[0]);
// BFX — normal step of right rotor, double step of middle rotor, normal step of left rotor
scramblerUnit.Scramble("T");
Assert.AreEqual(2, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(6, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(24, scramblerUnit.RotorPositions[0]);
// BFY — normal step of right rotor
scramblerUnit.Scramble("T");
Assert.AreEqual(2, scramblerUnit.RotorPositions[2]);
Assert.AreEqual(6, scramblerUnit.RotorPositions[1]);
Assert.AreEqual(25, scramblerUnit.RotorPositions[0]);
}
public void Initialize()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.RotorPositions.Add(21);
settings.RotorPositions.Add(1);
settings.RotorPositions.Add(1);
settings.Reflector = Constants.Reflectors.B;
scramblerUnit = new ScramblerUnitBase(settings);
}
public void Plugboard()
{
IEnigmaSettings settings = new EnigmaSettings()
{
Plugboard = new EnigmaPlugboard(new List <EnigmaPlugboardPair>()
{
{ new EnigmaPlugboardPair()
{
From = 'A', To = 'B'
} },
}),
};
Assert.Equal(1, settings.Plugboard.SubstitutionCount);
Assert.Equal('B', settings.Plugboard.Substitutions()['A']);
}
public void Initialize()
{
EnigmaSettings settings = new EnigmaSettings();
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.I);
settings.Rotors.Add(Constants.Rotors.III);
settings.RotorPositions.Add(16);
settings.RotorPositions.Add(17);
settings.RotorPositions.Add(26);
settings.Reflector = Constants.Reflectors.A;
engimaMachine = new KRailway(settings);
}
public void Initialize()
{
Dictionary <string, string> plugBoard = new Dictionary <string, string>();
plugBoard.Add("A", "T");
plugBoard.Add("B", "L");
plugBoard.Add("D", "F");
plugBoard.Add("G", "J");
plugBoard.Add("H", "M");
plugBoard.Add("N", "W");
plugBoard.Add("O", "P");
plugBoard.Add("Q", "Y");
plugBoard.Add("R", "Z");
plugBoard.Add("V", "X");
EnigmaSettings settings = new EnigmaSettings();
PlugboardBase pb = new PlugboardBase();
pb.Layout = plugBoard;
settings.PlugBoard = pb;
//settings.Rotors.Add(new Rotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ", "I", new List<string>() { "Y" }, new List<string>() { "Q" }, new List<string>() { "R" }));
//settings.Rotors.Add(new Rotor("ESOVPZJAYQUIRHXLNFTGKDCMWB", "IV", new List<string>() { "R" }, new List<string>() { "J" }, new List<string>() { "K" }));
//settings.Rotors.Add(new Rotor("AJDKSIRUXBLHWTMCQGZNPYFVOE", "II", new List<string>() { "M" }, new List<string>() { "E" }, new List<string>() { "F" }));
//settings.Rotors.Add(new Rotor("LEYJVCNIXWPBQMDRTAKZGFUHOS", "Beta", null, null, null));
settings.Rotors.Add(Constants.Rotors.I);
settings.Rotors.Add(Constants.Rotors.IV);
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.Beta);
settings.RotorPositions.Add(Constants.Alpha.A);
settings.RotorPositions.Add(Constants.Alpha.N);
settings.RotorPositions.Add(Constants.Alpha.J);
settings.RotorPositions.Add(Constants.Alpha.V);
settings.Rotors[0].Ringstellung = Constants.Alpha.V;
settings.Rotors[1].Ringstellung = Constants.Alpha.A;
settings.Rotors[2].Ringstellung = Constants.Alpha.A;
settings.Rotors[3].Ringstellung = Constants.Alpha.A;
settings.Reflector = Constants.Reflectors.BThin;
engimaMachine = new M4(settings);
}
static void Main(string[] args)
{
EnigmaMachine machine = new EnigmaMachine();
EnigmaSettings eSettings = new EnigmaSettings();
querySettings(eSettings);
string message = "";
Console.Write("Enter message to encrypt: ");
message = Console.ReadLine();
while (!Regex.IsMatch(message, @"^[a-zA-Z ]+$"))
{
Console.Write("Only letters A-Z is allowed, try again: ");
message = Console.ReadLine();
}
message = message.Replace(" ", "").ToUpper();
// Enter settings on machine
machine.setSettings(eSettings.rings, eSettings.grund, eSettings.order, eSettings.reflector);
// The plugboard settings
foreach (string plug in eSettings.plugs)
{
char[] p = plug.ToCharArray();
machine.addPlug(p[0], p[1]);
}
// Message encrypt
Console.WriteLine();
Console.WriteLine("Plain text:\t" + message);
string enc = machine.runEnigma(message);
Console.WriteLine("Encrypted:\t" + enc);
// Reset the settings before decrypting!
machine.setSettings(eSettings.rings, eSettings.grund, eSettings.order, eSettings.reflector);
// Message decrypt
string dec = machine.runEnigma(enc);
Console.WriteLine("Decrypted:\t" + dec);
Console.WriteLine();
Console.ReadLine();
}
public void CtorDefault()
{
IEnigmaSettings settings = new EnigmaSettings();
Assert.Equal(EnigmaReflectorNumber.B, settings.Reflector.ReflectorNumber);
Assert.Equal(EnigmaRotorNumber.I, settings.Rotors[EnigmaRotorPosition.Fastest].RotorNumber);
Assert.Equal(EnigmaRotorNumber.II, settings.Rotors[EnigmaRotorPosition.Second].RotorNumber);
Assert.Equal(EnigmaRotorNumber.III, settings.Rotors[EnigmaRotorPosition.Third].RotorNumber);
Assert.Equal(1, settings.Rotors[EnigmaRotorPosition.Fastest].RingPosition);
Assert.Equal(1, settings.Rotors[EnigmaRotorPosition.Second].RingPosition);
Assert.Equal(1, settings.Rotors[EnigmaRotorPosition.Third].RingPosition);
Assert.Equal('A', settings.Rotors[EnigmaRotorPosition.Fastest].CurrentSetting);
Assert.Equal('A', settings.Rotors[EnigmaRotorPosition.Second].CurrentSetting);
Assert.Equal('A', settings.Rotors[EnigmaRotorPosition.Third].CurrentSetting);
Assert.Equal(0, settings.Plugboard.SubstitutionCount);
Assert.Empty(settings.Plugboard.Substitutions());
}
public void Initialize()
{
Dictionary <string, string> plugBoard = new Dictionary <string, string>();
plugBoard.Add("A", "E");
plugBoard.Add("B", "F");
plugBoard.Add("C", "M");
plugBoard.Add("D", "Q");
plugBoard.Add("H", "U");
plugBoard.Add("J", "N");
plugBoard.Add("L", "X");
plugBoard.Add("P", "R");
plugBoard.Add("S", "Z");
plugBoard.Add("V", "W");
EnigmaSettings settings = new EnigmaSettings();
PlugboardBase pb = new PlugboardBase();
pb.Layout = plugBoard;
settings.PlugBoard = pb;
settings.Rotors.Add(Constants.Rotors.VIII);
settings.Rotors.Add(Constants.Rotors.VI);
settings.Rotors.Add(Constants.Rotors.V);
settings.Rotors.Add(Constants.Rotors.Beta);
settings.RotorPositions.Add(Constants.Alpha.Z);
settings.RotorPositions.Add(Constants.Alpha.S);
settings.RotorPositions.Add(Constants.Alpha.D);
settings.RotorPositions.Add(Constants.Alpha.C);
settings.Rotors[0].Ringstellung = Constants.Alpha.L;
settings.Rotors[1].Ringstellung = Constants.Alpha.E;
settings.Rotors[2].Ringstellung = Constants.Alpha.P;
settings.Rotors[3].Ringstellung = Constants.Alpha.E;
settings.Reflector = Constants.Reflectors.CThin;
engimaMachine = new M4(settings);
}
public void Initialize()
{
Dictionary <string, string> plugBoard = new Dictionary <string, string>();
plugBoard.Add("A", "X");
plugBoard.Add("B", "K");
plugBoard.Add("D", "E");
plugBoard.Add("G", "J");
plugBoard.Add("H", "M");
plugBoard.Add("N", "W");
plugBoard.Add("O", "P");
plugBoard.Add("Q", "Y");
plugBoard.Add("R", "Z");
plugBoard.Add("V", "T");
EnigmaSettings settings = new EnigmaSettings();
PlugboardBase pb = new PlugboardBase();
pb.Layout = plugBoard;
settings.PlugBoard = pb;
settings.Rotors.Add(Constants.Rotors.II);
settings.Rotors.Add(Constants.Rotors.IV);
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.Beta);
settings.RotorPositions.Add(Constants.Alpha.S);
settings.RotorPositions.Add(Constants.Alpha.S);
settings.RotorPositions.Add(Constants.Alpha.O);
settings.RotorPositions.Add(Constants.Alpha.B);
settings.Rotors[0].Ringstellung = Constants.Alpha.G;
settings.Rotors[1].Ringstellung = Constants.Alpha.C;
settings.Rotors[2].Ringstellung = Constants.Alpha.C;
settings.Rotors[3].Ringstellung = Constants.Alpha.A;
settings.Reflector = Constants.Reflectors.CThin;
engimaMachine = new M4(settings);
}
public void Initialize()
{
Dictionary <string, string> plugBoard = new Dictionary <string, string>();
plugBoard.Add("A", "Y");
plugBoard.Add("B", "F");
plugBoard.Add("D", "L");
plugBoard.Add("G", "X");
plugBoard.Add("H", "Z");
plugBoard.Add("N", "S");
plugBoard.Add("O", "C");
plugBoard.Add("Q", "T");
plugBoard.Add("R", "J");
plugBoard.Add("V", "P");
EnigmaSettings settings = new EnigmaSettings();
PlugboardBase pb = new PlugboardBase();
pb.Layout = plugBoard;
settings.PlugBoard = pb;
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors.Add(Constants.Rotors.I);
settings.Rotors.Add(Constants.Rotors.V);
settings.Rotors.Add(Constants.Rotors.Gamma);
settings.RotorPositions.Add(Constants.Alpha.E);
settings.RotorPositions.Add(Constants.Alpha.D);
settings.RotorPositions.Add(Constants.Alpha.O);
settings.RotorPositions.Add(Constants.Alpha.C);
settings.Rotors[0].Ringstellung = Constants.Alpha.P;
settings.Rotors[1].Ringstellung = Constants.Alpha.M;
settings.Rotors[2].Ringstellung = Constants.Alpha.I;
settings.Rotors[3].Ringstellung = Constants.Alpha.P;
settings.Reflector = Constants.Reflectors.CThin;
engimaMachine = new M4(settings);
}
public Enigma()
{
this.settings = new EnigmaSettings();
this.core = new EnigmaCore(this);
this.analyzer = new EnigmaAnalyzer(this);
this.analyzer.OnIntermediateResult += new EventHandler <IntermediateResultEventArgs>(analyzer_OnIntermediateResult);
this.statistics = new Dictionary <int, IDictionary <string, double[]> >();
enigmaPresentationFrame = new EnigmaPresentationFrame(this);
EnigmaPresentation myPresentation = enigmaPresentationFrame.EnigmaPresentation;
this.Presentation = enigmaPresentationFrame;
//this.Presentation.IsVisibleChanged += presentation_isvisibleChanged;
this.settings.PropertyChanged += enigmaPresentationFrame.EnigmaPresentation.settings_OnPropertyChange;
this.settings.PropertyChanged += settings_OnPropertyChange;
this.enigmaPresentationFrame.EnigmaPresentation.fireLetters += fireLetters;
this.enigmaPresentationFrame.EnigmaPresentation.newInput += newInput;
}
static void Main(string[] args)
{
EnigmaMachine machine = new EnigmaMachine();
EnigmaSettings eSettings = new EnigmaSettings();
querySettings(eSettings);
string message = "";
Console.Write("Enter message to encrypt: ");
message = Console.ReadLine();
while (!Regex.IsMatch(message, @"^[a-zA-Z ]+$")) {
Console.Write("Only letters A-Z is allowed, try again: ");
message = Console.ReadLine();
}
message = message.Replace(" ", "").ToUpper();
// Enter settings on machine
machine.setSettings(eSettings.rings, eSettings.grund, eSettings.order, eSettings.reflector);
// The plugboard settings
foreach (string plug in eSettings.plugs) {
char[] p = plug.ToCharArray();
machine.addPlug(p[0], p[1]);
}
// Message encrypt
Console.WriteLine();
Console.WriteLine("Plain text:\t" + message);
string enc = machine.runEnigma(message);
Console.WriteLine("Encrypted:\t" + enc);
// Reset the settings before decrypting!
machine.setSettings(eSettings.rings, eSettings.grund, eSettings.order, eSettings.reflector);
// Message decrypt
string dec = machine.runEnigma(enc);
Console.WriteLine("Decrypted:\t" + dec);
Console.WriteLine();
Console.ReadLine();
}
public void Initialize()
{
Dictionary <string, string> plugBoard = new Dictionary <string, string>();
plugBoard.Add("A", "N");
plugBoard.Add("E", "Z");
plugBoard.Add("H", "K");
plugBoard.Add("I", "J");
plugBoard.Add("L", "R");
plugBoard.Add("M", "Q");
plugBoard.Add("O", "T");
plugBoard.Add("P", "V");
plugBoard.Add("S", "W");
plugBoard.Add("U", "X");
EnigmaSettings settings = new EnigmaSettings();
PlugboardBase pb = new PlugboardBase();
pb.Layout = plugBoard;
settings.PlugBoard = pb;
settings.Reflector = Constants.Reflectors.B;
settings.EntryWheel = Constants.Rotors.Etw;
settings.Rotors.Add(Constants.Rotors.VIII);
settings.Rotors.Add(Constants.Rotors.VI);
settings.Rotors.Add(Constants.Rotors.III);
settings.Rotors[0].Ringstellung = Constants.Alpha.M;
settings.Rotors[1].Ringstellung = Constants.Alpha.H;
settings.Rotors[2].Ringstellung = Constants.Alpha.A;
settings.RotorPositions.Add(Constants.Alpha.V);
settings.RotorPositions.Add(Constants.Alpha.Z);
settings.RotorPositions.Add(Constants.Alpha.U);
engimaMachine = new M3(settings);
}
public void Rotors()
{
IEnigmaRotors rotors = new EnigmaRotors()
{
Rotors = new Dictionary <EnigmaRotorPosition, IEnigmaRotor>()
{
{ EnigmaRotorPosition.Fastest, new EnigmaRotor()
{
RotorNumber = EnigmaRotorNumber.VI, RingPosition = 2, CurrentSetting = 'X'
} },
{ EnigmaRotorPosition.Second, new EnigmaRotor()
{
RotorNumber = EnigmaRotorNumber.VII, RingPosition = 3, CurrentSetting = 'Y'
} },
{ EnigmaRotorPosition.Third, new EnigmaRotor()
{
RotorNumber = EnigmaRotorNumber.VIII, RingPosition = 4, CurrentSetting = 'Z'
} },
},
};
IEnigmaSettings settings = new EnigmaSettings()
{
Rotors = rotors,
};
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Fastest].RotorNumber, settings.Rotors[EnigmaRotorPosition.Fastest].RotorNumber);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Second].RotorNumber, settings.Rotors[EnigmaRotorPosition.Second].RotorNumber);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Third].RotorNumber, settings.Rotors[EnigmaRotorPosition.Third].RotorNumber);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Fastest].RingPosition, settings.Rotors[EnigmaRotorPosition.Fastest].RingPosition);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Second].RingPosition, settings.Rotors[EnigmaRotorPosition.Second].RingPosition);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Third].RingPosition, settings.Rotors[EnigmaRotorPosition.Third].RingPosition);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Fastest].CurrentSetting, settings.Rotors[EnigmaRotorPosition.Fastest].CurrentSetting);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Second].CurrentSetting, settings.Rotors[EnigmaRotorPosition.Second].CurrentSetting);
Assert.Equal(rotors.Rotors[EnigmaRotorPosition.Third].CurrentSetting, settings.Rotors[EnigmaRotorPosition.Third].CurrentSetting);
}
