/// <summary>
/// Task 3. Corelation test
/// </summary>
/// <param name="binaryKey"></param>
private static void CorelationTest(List <short> binaryKey, string testedName)
{
var corTest = new CorelationTester(binaryKey, 3);
corTest.Test();
ConsoleMessager.ShowCorelationTestResults(corTest._Rk, corTest._Rkr, testedName);
}
/// <summary>
/// ПУНКТ 2. Сериальный тест
/// Task 2. frequency test
/// </summary>
/// <param name="binaryKey"></param>
/// <returns>Returns either empty list or key</returns>
private static List <short> FrequencyTest(List <short> binaryText, int k, string testedName)
{
var freqTest = new FrequencyTester(k, binaryText.Count);
// testing sequence and getting khi value
var khi = freqTest.Test(binaryText);
var teorFreq = freqTest._TeorFrequency;
var practFrequencies = freqTest._PossibleBlocks;
// represent to user results of executed test
var isKeyOkay = ConsoleMessager.CheckKhiValue(khi, k, teorFreq, practFrequencies, testedName);
// TRYING TO GET VALID KEY
if (testedName == "ключа")
{
if (!isKeyOkay)
{
// generating a good key
var newKey = ReGenerateKey(isKeyOkay, binaryText.Count, k, testedName);
return(newKey);
}
else
{
return(binaryText);
}
}
return(new List <short>());
}
static void Main(string[] args)
{
// getting a string to calculate a hash function
var inputString = ConsoleMessager.AskString();
Console.WriteLine("Task 1.");
// Task 1. Getting hash from initial string value
var mdFourInstance = GetHashFromString(inputString);
// printing results to console
ConsoleMessager.DemonstrateHashResult(inputString, mdFourInstance.ResultHashString);
// Task 2. "The avalanche effect"
Console.WriteLine("Task 2.");
var inputStringWithOneBitChanged = ChangeOneBitInString(inputString);
var mdFourInstanceWithOneBitChanged = GetHashFromString(inputStringWithOneBitChanged);
// printing results to console
ConsoleMessager.DemonstrateHashResult(inputStringWithOneBitChanged, mdFourInstanceWithOneBitChanged.ResultHashString);
var numberOfDifferentBits = CalculateDifferentBits(mdFourInstance.ResultHashBytes, mdFourInstanceWithOneBitChanged.ResultHashBytes);
// printing results to console
ConsoleMessager.ShowDifferentBits(inputString, inputStringWithOneBitChanged, numberOfDifferentBits);
// Task 3. finding a collision.
Console.WriteLine("Task 3.");
FindAndPrintCollision();
// Task 4. Finding prototype
Console.WriteLine("Task 4.");
FindAndPrintPrototype();
}
static void Main(string[] args)
{
DeleteOldFiles();
var fileName = ConsoleMessager.AskFilename();
// converting a file to binary sequence
var binaryFile = FileWorker.GetBinaryFile(fileName);
// generating a key
var binaryKey = GenerateKey(binaryFile.Count);
// ask series length
var k = ConsoleMessager.AskBlockLength(binaryFile.Count);
// frequency test for key
binaryKey = FrequencyTest(binaryKey, k, "key");
// frequency test for file before any manipulation
FrequencyTest(binaryFile, k, "file before encryption");
// a number to divide key length on it
var number = ConsoleMessager.AskKeyDivideOnNumber();
// vername manipulations
var cryptedFile = CypherLogic(binaryKey.GetRange(0, binaryKey.Count / number), binaryFile, fileName);
// Frequency test for encrypted file
FrequencyTest(cryptedFile, k, "file after encryption");
// Corelation tests
CorelationTest(binaryKey, "key");
CorelationTest(binaryFile, "file before encryption");
CorelationTest(cryptedFile, "file after encryption");
}
static void Main(string[] args)
{
// Ask user key length
var keyLength = ConsoleMessager.AskKeyLength();
Console.WriteLine("Now input number (number p will be increased on this number, q will be decreased on this number):");
var keyChange = (int)ConsoleMessager.AskRate();
var keysGenerationTime = new Stopwatch();
keysGenerationTime.Start();
// generating of public, private key and cypher module
var keys = GenerateKeys(keyLength, keyChange);
keysGenerationTime.Stop();
Console.WriteLine(String.Format("Key generation time: {0} sec", (double)keysGenerationTime.ElapsedMilliseconds / 1000));
Console.WriteLine("-------------------------------------------------------------");
// ask file name which will be encrypted
var fileName = ConsoleMessager.AskFilename();
// Rsa encrypting
RsaCrypt(keys, fileName, keyLength);
//var a = BigInteger.Parse(Console.ReadLine());
//RsaBreaking(a);
// trying to break cypher module
RsaBreaking(keys.cypherModule);
}
static void Main(string[] args)
{
var messager = new ConsoleMessager();
var processor = new ConsoleProcessUserInput(messager);
var board = new Board {
SizeX = 100, SizeY = 20
};
var handler = ConsoleBoardHandler.GetInstance();
new AppLogic(messager, handler, processor).Run(board);
}
static void Main(string[] args)
{
var willGenerate = ConsoleMessager.WillGenerateAlphabet();
// zeroize key to generate new one
File.WriteAllText("key.txt", "");
// deleting old files
File.Delete("cryptedtext.txt");
File.Delete("decryptedtext.txt");
Console.WriteLine("Старые файлы удалены!");
Console.WriteLine();
// generating a key
var forKeyGenerating = new StreamWriter("key.txt", true);
KeyWorker.GenerateKey(forKeyGenerating);
forKeyGenerating.Close();
// Reading a key from file
// A dictionary where key is a letter from russian alphabet, value - a letter from new alphabet
var forKeyReading = new StreamReader("key.txt");
Dictionary <char, char> alphabet = KeyWorker.GetKey(forKeyReading);
forKeyReading.Close();
var encoder = new Encoder();
var blockLength = ConsoleMessager.ReadBlockLength();
// encrypting
Func <char[], Dictionary <char, char>, char[]> crypt = new Func <char[], Dictionary <char, char>, char[]>(encoder.Crypt);
CryptOrDecrypt(crypt, blockLength, alphabet, "text.txt", "Encryption", "cryptedtext.txt");
// decrypting
Func <char[], Dictionary <char, char>, char[]> decrypt = new Func <char[], Dictionary <char, char>, char[]>(encoder.DeCrypt);
CryptOrDecrypt(decrypt, blockLength, alphabet, "cryptedtext.txt", "Decryption", "decryptedtext.txt");
// calculating entropy
var entropyWorker = new EntropyWorker();
var textReader = new StreamReader("шифрограмма.txt");
var text = textReader.ReadToEnd();
var entropy = entropyWorker.CalculateEntropy(text);
Console.WriteLine();
Console.WriteLine("Entropy value: " + entropy);
}
/// <summary>
/// Regeneration a key if it has not passed frequency test
/// </summary>
/// <param name="isKeyOkay"></param>
/// <param name="binaryTextLength"></param>
/// <param name="k"></param>
/// <param name="testedName"></param>
/// <returns></returns>
private static List <short> ReGenerateKey(bool isKeyOkay, int binaryTextLength, int k, string testedName)
{
var newKey = new List <short>();
while (!isKeyOkay)
{
Console.WriteLine("Regenerating key because it hasn't passed frequency test.");
newKey = GenerateKey(binaryTextLength);
var freqTest = new FrequencyTester(k, binaryTextLength);
var khi = freqTest.Test(newKey);
var teorFreq = freqTest._TeorFrequency;
var practFrequencies = freqTest._PossibleBlocks;
// represent to user results of executed test
isKeyOkay = ConsoleMessager.CheckKhiValue(khi, k, teorFreq, practFrequencies, testedName);
}
return(newKey);
}
/// <summary>
/// Task 3. Collision
/// </summary>
private static void FindAndPrintCollision()
{
// asking user how many bits (counting from the beginning of initial message) he wants to be the same
var k = ConsoleMessager.AskHashLength();
// asking length for future string value generating
var L = ConsoleMessager.AskStringLength();
// a dictionary where key is a bits piece and value is a random generated string
var kBitsStringHashDict = new Dictionary <string, string>();
while (true)
{
var randString = GetRandomString(L);
var mdFourInstance = GetHashFromString(randString);
var firstBitsList = GetBitsList(mdFourInstance.ResultHashBytes, k);
var firstBitsString = Helper.PrintList(firstBitsList);
// when we try to add the same key an exception is going to be raised.
// that means a collision has been found.
try
{
kBitsStringHashDict.Add(firstBitsString, randString);
}
catch (ArgumentException e)
{
var firstHash = GetHashFromString(kBitsStringHashDict[firstBitsString]).ResultHashString;
var secondHash = mdFourInstance.ResultHashString;
var firstRandomString = kBitsStringHashDict[firstBitsString];
var secondRandomString = randString;
var N = kBitsStringHashDict.Count;
ConsoleMessager.PrintCollisionResults(firstHash, firstRandomString, secondHash, secondRandomString,
firstBitsString, N);
break;
}
}
}
/// <summary>
/// Task 4. Prototype
/// </summary>
private static void FindAndPrintPrototype()
{
Console.WriteLine("Enter a password:"******"";
int N = 0;
while (prototypeString == "")
{
N++;
var randomString = GetRandomString(L);
var mdFourRandomStringInstance = GetHashFromString(randomString);
var randomHashFirstBitsList = GetBitsList(mdFourRandomStringInstance.ResultHashBytes, k);
var randomHashFirstBitsString = Helper.PrintList(randomHashFirstBitsList);
if (randomHashFirstBitsString == firstBitsString)
{
Console.WriteLine(String.Format("We found a string with the same {0} first bits in hash for your password '{1}'", k, inputPassword));
prototypeString = randomString;
ConsoleMessager.PrintCollisionResults(mdFourInitialInstance.ResultHashString, inputPassword,
mdFourRandomStringInstance.ResultHashString, randomString, randomHashFirstBitsString, N);
}
}
}
/// <summary>
/// Task 1. Key generation
/// </summary>
/// <param name="binaryFileLength">length of file in binary format</param>
/// <returns>list int</returns>
private static List <short> GenerateKey(int binaryFileLength)
{
var polinomNumbers = ConsoleMessager.AskPolinomNumbers();
var keyWorker = new KeyWorker(new Random());
// generating registr and save his initial state to file
var forRegistr = new StreamWriter("registr.txt", true);
var registr = keyWorker.GenerateRegistr(31, forRegistr);
forRegistr.Close();
Console.WriteLine();
Console.WriteLine("Registr has been randomized and now placed in registr.txt");
// generating a key (m-sequence)
var forKeyGenerating = new StreamWriter("key.txt", true);
var binaryKey = keyWorker.GenerateKey(registr, binaryFileLength, polinomNumbers.ElementAt(1), polinomNumbers.ElementAt(0), forKeyGenerating);
forKeyGenerating.Close();
Console.WriteLine();
Console.WriteLine("A key is generated and now placed in key.txt");
return(binaryKey);
}
