public void Analyze()
{
//Set progress to 50%
this.pluginProgress(50, 100);
// Adjust analyzer parameters to ciphertext length
AdjustAnalyzerParameters(this.ciphertext.Length);
this.currun_keys_tested = 0;
// Initialization of repetition data structures
int[][] bestkeys = new int[this.repetitions][];
double[] bestkeys_fit = new double[this.repetitions];
// Execute analysis
for (int curRep = 0; curRep < this.repetitions; curRep++)
{
Population population = new Population();
SetUpEnvironment(population, GeneticAttacker.population_size);
CreateInitialGeneration(population, this.ciphertext, this.ciphertext_alphabet, this.plaintext_alphabet);
double change = population.dev;
int curGen = 1;
Population nextGen = population;
while ((change > GeneticAttacker.changeBorder) && (curGen < GeneticAttacker.maxGenerations))
{
if (StopFlag)
{
return;
}
nextGen = CreateNextGeneration(nextGen, this.ciphertext, this.ciphertext_alphabet, false);
change = nextGen.dev;
curGen++;
this.pluginProgress(50.0 + (((double)(curRep + 1) * curGen) / (this.repetitions * GeneticAttacker.maxGenerations)) / 2 * 100, 100.0);
}
nextGen = CreateNextGeneration(nextGen, this.ciphertext, this.ciphertext_alphabet, true);
this.plaintext = DecryptCiphertext(nextGen.keys[0], this.ciphertext, this.ciphertext_alphabet);
bestkeys[curRep] = nextGen.keys[0];
bestkeys_fit[curRep] = nextGen.fitness[0];
Text plainTxt = DecryptCiphertext(bestkeys[curRep], this.ciphertext, this.ciphertext_alphabet);
String plain = plainTxt.ToString(this.plaintext_alphabet);
String key_string = CreateAlphabetOutput(bestkeys[curRep], this.plaintext_alphabet);
// Report keyCan
KeyCandidate newKeyCan = new KeyCandidate(bestkeys[curRep], bestkeys_fit[curRep], plain, key_string);
newKeyCan.GenAttack = true;
this.updateKeyDisplay(newKeyCan);
}
}
private void AddKeyToResult(Mapping map, bool fullSolution)
{
if (fullSolution)
{
this.completeKey = true;
}
else
{
this.partialKey = true;
}
int[] key = this.MakeKeyComplete(map.DeriveKey());
Text plaintext = this.DecryptCiphertext(key, this.ctext, this.calpha);
string plain = plaintext.ToString(this.palpha);
double fit = this.grams.CalculateCost(plaintext.ToIntArray());
String key_string = CreateAlphabetOutput(key, this.palpha);
KeyCandidate keyCan = new KeyCandidate(key, fit, plain, key_string);
keyCan.DicAttack = true;
this.updateKeyDisplay(keyCan);
}
private void UpdateKeyDisplay(KeyCandidate keyCan)
{
try
{
bool update = false;
// Add key if key does not already exist
if (!this.keyCandidates.Contains(keyCan))
{
this.keyCandidates.Add(keyCan);
this.keyCandidates.Sort(new KeyCandidateComparer());
if (this.keyCandidates.Count > 20)
{
this.keyCandidates.RemoveAt(this.keyCandidates.Count - 1);
}
update = true;
}
else
{
int index = this.keyCandidates.IndexOf(keyCan);
KeyCandidate keyCanAlreadyInList = this.keyCandidates[index];
if (keyCan.DicAttack)
{
if (!keyCanAlreadyInList.DicAttack)
{
keyCanAlreadyInList.DicAttack = true;
update = true;
}
}
if (keyCan.GenAttack)
{
if (!keyCanAlreadyInList.GenAttack)
{
keyCanAlreadyInList.GenAttack = true;
update = true;
}
}
if (keyCan.HillAttack)
{
if (!keyCanAlreadyInList.HillAttack)
{
keyCanAlreadyInList.HillAttack = true;
update = true;
}
}
}
// Display output
if (update)
{
//this.plaintext = this.keyCandidates[0].Plaintext;
//OnPropertyChanged("Plaintext");
//this.plaintextalphabetoutput = CreateKeyOutput(this.keyCandidates[0].Key, this.ptAlphabet, this.ctAlphabet);
//OnPropertyChanged("PlaintextAlphabetOutput");
UpdateOutput(this.keyCandidates[0].Key_string, this.keyCandidates[0].Plaintext);
((AssignmentPresentation)Presentation).Dispatcher.Invoke(DispatcherPriority.Normal,
(SendOrPostCallback) delegate
{
try
{
((AssignmentPresentation)Presentation).Entries.Clear();
for (int i = 0; i < this.keyCandidates.Count; i++)
{
KeyCandidate keyCandidate = this.keyCandidates[i];
ResultEntry entry = new ResultEntry();
entry.Ranking = i + 1;
entry.Text = keyCandidate.Plaintext;
entry.Key = keyCandidate.Key_string;
if (keyCandidate.GenAttack && !keyCandidate.DicAttack)
{
entry.Attack = Resources.GenAttackDisplay;
}
else if (keyCandidate.DicAttack && !keyCandidate.GenAttack)
{
entry.Attack = Resources.DicAttackDisplay;
}
else if (keyCandidate.GenAttack && keyCandidate.DicAttack)
{
entry.Attack = Resources.GenAttackDisplay + ", " + Resources.DicAttackDisplay;
}
else if (keyCandidate.HillAttack)
{
entry.Attack = Resources.HillAttackDisplay;
}
double f = keyCandidate.Fitness;
entry.Value = string.Format("{0:0.00000} ", f);
((AssignmentPresentation)Presentation).Entries.Add(entry);
}
}
catch (Exception ex)
{
GuiLogMessage("Exception during UpdateKeyDisplay Presentation.Dispatcher: " + ex.Message, NotificationLevel.Error);
}
}, null);
}
}
catch (Exception ex)
{
GuiLogMessage("Exception during UpdateKeyDisplay: " + ex.Message, NotificationLevel.Error);
}
}
public void ExecuteOnCPU()
{
#region {Variables}
double globalbestkeycost = double.MinValue;
int[] bestkey = new int[plaintextalphabet.Length];
inplaceAmountOfSymbols = new int[plaintextalphabet.Length];
int alphabetlength = plaintextalphabet.Length; //No need for calculating a few million times. (Performance)
bool foundbetter;
bool foundInplace = false;
totalKeys = 0;
Random random = new Random();
#endregion {Variables}
//Take input and prepare
//int[] ciphertext = MapTextIntoNumberSpace(RemoveInvalidChars(ciphertextString.ToLower(), ciphertextalphabet), ciphertextalphabet);
PluginBase.Utils.Alphabet ciphertextAlphabet = new PluginBase.Utils.Alphabet(ciphertextalphabet);
PluginBase.Utils.Alphabet plaintextAlphabet = new PluginBase.Utils.Alphabet(plaintextalphabet);
PluginBase.Utils.Text cipherText = new PluginBase.Utils.Text(ciphertextString, ciphertextAlphabet);
int[] ciphertext = cipherText.ValidLetterArray;
int length = ciphertext.Length;
int[] plaintext = new int[length];
inplaceSpots = new int[plaintextalphabet.Length, length];
for (int restart = 0; restart < restarts; restart++)
{
pluginProgress(restart, restarts);
//Generate random key:
int[] runkey = BuildRandomKey(random);
double bestkeycost = double.MinValue;
//Create first plaintext and analyze places of symbols:
plaintext = UseKeyOnCipher(ciphertext, runkey);
AnalyzeSymbolPlaces(plaintext, length);
do
{
foundbetter = false;
for (int i = 0; i < alphabetlength; i++)
{
foundInplace = false;
int[] copykey = (int[])runkey.Clone();
for (int j = 0; j < alphabetlength; j++)
{
if (i == j)
{
continue;
}
//create child key
Swap(copykey, i, j);
int sub1 = copykey[i];
int sub2 = copykey[j];
//Inplace swap in text
for (int m = 0; m < inplaceAmountOfSymbols[sub1]; m++)
{
plaintext[inplaceSpots[sub1, m]] = sub2;
}
for (int m = 0; m < inplaceAmountOfSymbols[sub2]; m++)
{
plaintext[inplaceSpots[sub2, m]] = sub1;
}
//Calculate the costfunction
double costvalue = grams.CalculateCost(plaintext);
if (bestkeycost < costvalue) //When found a better key adopt it.
{
bestkeycost = costvalue;
bestkey = (int[])copykey.Clone();
foundbetter = true;
foundInplace = true;
}
//Revert the CopyKey substitution
Swap(copykey, i, j);
for (int m = 0; m < inplaceAmountOfSymbols[sub2]; m++)
{
plaintext[inplaceSpots[sub2, m]] = sub2;
}
for (int m = 0; m < inplaceAmountOfSymbols[sub1]; m++)
{
plaintext[inplaceSpots[sub1, m]] = sub1;
}
totalKeys++; //Count Keys for Performance output
}
//Fast converge take over new key + therefore new resulting plaintext
if (foundInplace)
{
runkey = bestkey;
plaintext = UseKeyOnCipher(ciphertext, runkey);
AnalyzeSymbolPlaces(plaintext, length);
}
}
} while (foundbetter);
if (StopFlag)
{
return;
}
if (globalbestkeycost < bestkeycost)
{
globalbestkeycost = bestkeycost;
//Add to bestlist-output:
string keystring = MapNumbersIntoTextSpace(bestkey, plaintextalphabet);
if (keystring.Contains("ABIRD"))
{
//Console.WriteLine(keystring);
}
KeyCandidate newKeyCan = new KeyCandidate(bestkey, bestkeycost, MapNumbersIntoTextSpace(UseKeyOnCipher(ciphertext, bestkey), plaintextalphabet), keystring);
newKeyCan.HillAttack = true;
updateKeyDisplay(newKeyCan);
}
}
}
