public void CalculatesForBitArray() { var imageHandler = new ImageDCTHashCalculator(); var imageHashService = new ImageHashService(imageHandler); var hashPng = new BitArray(64); var hashJpg = new BitArray(64); var hashJpgSmall = new BitArray(64); using (var pngStream = new FileStream(@"IMG_0.png", FileMode.Open, FileAccess.Read)) { imageHashService.CalculateImageHash(pngStream, hashPng); } using (var jpgStream = new FileStream(@"IMG_0.jpg", FileMode.Open, FileAccess.Read)) { imageHashService.CalculateImageHash(jpgStream, hashJpg); } using (var jpgStream = new FileStream(@"IMG_0_small.jpg", FileMode.Open, FileAccess.Read)) { imageHashService.CalculateImageHash(jpgStream, hashJpgSmall); } Assert.Equal(0, HammingDistance.Calculate(hashPng, hashJpg)); Assert.Equal(1, HammingDistance.Calculate(hashJpgSmall, hashJpg)); }
public void HammingDistanceTest( ) { HammingDistance dist = new HammingDistance( ); Assert.Throws <ArgumentException>(() => dist.GetDistance(p0, q4)); double result = dist.GetDistance(p0, q0); Assert.AreEqual(result, 2); result = dist.GetDistance(p1, q1); Assert.AreEqual(result, 2); result = dist.GetDistance(p2, q2); Assert.AreEqual(result, 0); result = dist.GetDistance(p3, q3); Assert.AreEqual(result, 0); result = dist.GetDistance(p4, q4); Assert.AreEqual(result, 4); result = dist.GetDistance(p5, q5); Assert.AreEqual(result, 9); }
public int FindBlockSize() { var aggregated = new Dictionary <int, float>(); int start = 10; int end = 32; int blocks = 4; for (int i = start; i < end * 3; i++) { Base64 encrypted = eo.EncryptConsistentKey(new String('A', i), unknownString); var keys = HammingDistance.FindDistancePerKeySize(start, end, encrypted.Decode(), blocks); foreach (var kvp in keys) { if (aggregated.ContainsKey(kvp.Key)) { aggregated[kvp.Key] += kvp.Value; } else { aggregated.Add(kvp.Key, kvp.Value); } } } var possibleKey = aggregated.OrderBy(x => x.Value).Take(1); return(possibleKey.Select(x => x.Key).Single()); }
public static int GetDistances(string s, string t, FuzzyAlgorithm algorithm = FuzzyAlgorithm.LevenshteinDistance) { int distance = 100000; switch (algorithm) { case FuzzyAlgorithm.LevenshteinDistance: distance = LevenshteinDistance.GetLevenshteinDistance(s, t); break; case FuzzyAlgorithm.DamerauLevenshteinDistance: distance = DamerauLevenshteinDistance.GetDamerauLevenshteinDistance(s, t); break; case FuzzyAlgorithm.HammingDistance: distance = HammingDistance.GetHammingDistance(s, t); break; default: distance = LevenshteinDistance.GetLevenshteinDistance(s, t); break; } return(distance); }
public void TestDistanceByFiles(string filePath1, string filePath2) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(filePath1, filePath2); Assert.That(distance, Is.EqualTo(2)); }
public void HammingDistanceTest() { HammingDistance dist = new HammingDistance(); // TODO: Re-enable argument checking only for debugging // Assert.Throws<ArgumentException>(() => dist.GetDistance(p0, q4)); double result = dist.GetDistance(p0, q0); Assert.AreEqual(result, 2); result = dist.GetDistance(p1, q1); Assert.AreEqual(result, 2); result = dist.GetDistance(p2, q2); Assert.AreEqual(result, 0); result = dist.GetDistance(p3, q3); Assert.AreEqual(result, 0); result = dist.GetDistance(p4, q4); Assert.AreEqual(result, 4); result = dist.GetDistance(p5, q5); Assert.AreEqual(result, 9); }
public void TestDistanceByStrings(string source1, string source2) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(source1, source2); Assert.That(distance, Is.EqualTo(2)); }
public void TestZeroDistanceDifferentSources(string source1, string source2) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(source1, source2); Assert.That(distance, Is.EqualTo(0)); }
public void TestZeroDistanceSimilarSources(byte[] data1, byte[] data2) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(data1, data2); Assert.That(distance, Is.EqualTo(0)); }
public void CalculateHammingDistance() { string str1 = "this is a test"; string str2 = "wokka wokka!!!"; int distance = 37; Assert.AreEqual(distance, HammingDistance.Calculate(str1, str2)); }
public void TestFileNotFound(string source1, string source2) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(source1, source2); Assert.That(hd.SourceStatus, Is.EqualTo(Const.FILE_NOT_FOUND)); Assert.That(distance, Is.Not.EqualTo(0)); }
public void TestOnlyOneSource(string source1) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(source1, null); Assert.That(hd.SourceStatus, Is.EqualTo(Const.INSUFFICIENT_SOURCE)); Assert.That(distance, Is.Not.EqualTo(0)); }
public void TestDifferentLengthSource(byte[] data1, byte[] data2) { HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(data1, data2); Assert.That(hd.SourceStatus, Is.EqualTo(Const.UNEQUAL_LENGTH)); Assert.That(distance, Is.Not.EqualTo(0)); }
public void GetDistance_WhenCalled_ReturnDistance(int x, int y, int d) { var helper = new HammingDistance(); var result = helper.GetDistance(x, y); Assert.That(result, Is.EqualTo(d)); }
/// <summary> /// Show simple main menu /// </summary> /// <param name="source1">data from first argument parameters</param> /// <param name="source2">data from second argument parameters</param> /// <returns>TRUE if user want to do another calculation /// FALSE if user want to quit the application</returns> private static bool DisplayMenu(string source1, string source2) { //show the menu Console.WriteLine("HAMMING DISTANCE CALCULATOR"); Console.WriteLine(""); Console.WriteLine("Input Sources"); Console.WriteLine(""); Console.WriteLine("*. Input String Manually"); // get data directly from keyboard input Console.WriteLine("*. Input from Full Path of Text File (Must text file - *.txt)"); // get data from text file content Console.WriteLine("*. Input from Full Path of File (any file format except text file)"); // get data from converting the whole file into byte array Console.WriteLine(""); // No arguments, set the sources based on user input if (string.IsNullOrEmpty(source1) && string.IsNullOrEmpty(source2)) { Console.Write("Input Source 1 : "); source1 = Console.ReadLine(); Console.Write("Input Source 2 : "); source2 = Console.ReadLine(); } else { Console.WriteLine("Input Source 1 : {0}", source1); Console.WriteLine("Input Source 1 : {0}", source2); } if (!string.IsNullOrEmpty(source1) && !string.IsNullOrEmpty(source2)) { // init hamming distance, calculate based by sources var HammingDistanceObject = new HammingDistance(); double distance = HammingDistanceObject.GetHammingDistance(source1, source2); // distance should be >= 0 if (distance >= 0) { Console.WriteLine("\nDistance is : " + distance); Console.WriteLine("Calc. Time is : " + HammingDistanceObject.ProcessTime.Duration()); } else // else, found some error during calculate the distance { Console.WriteLine("\nGet Hamming Distance Failed!"); Console.WriteLine("Source Status : " + HammingDistanceObject.SourceStatus); } } else { Console.WriteLine("\nInsufficient arguments"); } // press key to do another calculation, otherwise quite application Console.Write("\nPress ENTER to retry, otherwise quit application.."); if (Console.ReadKey().Key != ConsoleKey.Enter) { return(false); } return(true); }
public void FindDistancePerKeySize() { string source = "abcdefghabcdefgh"; int correctKeySize = 8; int hammingDistance = 0; var result = HammingDistance.FindDistancePerKeySize(2, 10, source); Assert.AreEqual(result[correctKeySize], hammingDistance); }
public void FindDistancePerKeySizeWithInvalidBlockNumber() { try { string source = "abcdef"; var result = HammingDistance.FindDistancePerKeySize(2, 10, source, 3); Assert.Fail(); } catch (ArgumentException) { return; } }
public void HammingDistanceOfInequalString() { string str1 = "1"; string str2 = "12"; try { HammingDistance.Calculate(str1, str2); Assert.Fail(); } catch (ArgumentException) { return; } }
public void TestZeroDistanceByHugeFiles(string filePath1, string filePath2, int fileSizeInMB) { //Check if files is exist with the desired size FileValidator(filePath1, filePath2, fileSizeInMB); // init object and do calculation HammingDistance hd = new HammingDistance(); double distance = hd.GetHammingDistance(filePath1, filePath2); // ideally, the timespan for calculation is 1% per size of file. // e.g if size is 1000 mbs the timespan should be less than 10 seconds // int desiredTime = fileSizeInMB / 100; int desiredTime = fileSizeInMB / 50; // to be safe, create 2% instead Assert.That(distance, Is.GreaterThanOrEqualTo(0)); Assert.That(hd.ProcessTime, Is.LessThan(TimeSpan.FromSeconds(desiredTime))); }
public void CalculatesDifferentImagesForBitArray() { var imageHandler = new ImageDCTHashCalculator(); var imageHashService = new ImageHashService(imageHandler); var hashJpg = new BitArray(64); var hashJpgOther = new BitArray(64); using (var jpgStream = new FileStream(@"IMG_0.jpg", FileMode.Open, FileAccess.Read)) { imageHashService.CalculateImageHash(jpgStream, hashJpg); } using (var jpgStream = new FileStream(@"IMG_18.jpg", FileMode.Open, FileAccess.Read)) { imageHashService.CalculateImageHash(jpgStream); } Assert.InRange(HammingDistance.Calculate(hashJpg, hashJpgOther), 10, 100); }
public void ShouldReturnHammingDistanceOf2() { var result = HammingDistance.Calculate(InputRam, InputMom); Assert.AreEqual(2, result); }
public void NotEqualLength() { HammingDistance hammingDistance = new HammingDistance(); }
public void Setup() { hammingDistance = new HammingDistance(); }
public void CalculatesForStrings(string a, string b, int expected) { Assert.Equal(expected, HammingDistance.Calculate(a, b)); }
public void HammingDistanceTestMethod() { HammingDistance hammingDistance = new HammingDistance(); Assert.AreEqual(2, hammingDistance.HammingDistanceSolution(1, 4)); }
public void CalculatesForLong(long a, long b, int expected) { Assert.Equal(expected, HammingDistance.Calculate(a, b)); }
public void CalculatesForBitArrays(BitArray a, BitArray b, int expected) { Assert.Equal(expected, HammingDistance.Calculate(a, b)); }
public string[] BreakXorFile(Base64 data, int startKeySize = 2, int endKeySize = 60, int numberOfBlocks = 2) { int take = 10; Hex source = data; var possibleKeySizes = HammingDistance.FindDistancePerKeySize(startKeySize, endKeySize, source.ToString(), numberOfBlocks).OrderBy(x => x.Value).Select(x => x.Key).Take(take); foreach (var possibleKeySize in possibleKeySizes) { StringBuilder sb = new StringBuilder(); var transposedBlocks = source.CreateAndTransposeBlocks(possibleKeySize); var decryptedBlocks = new List <string>(); bool foundOne = false; foreach (var block in transposedBlocks) { var decrypted = this.TryDecrypt(block); var c = CharacterCounter.FindKey(decrypted); if (c == '\0') { if (foundOne) { sb.Append('?'); decryptedBlocks.Add(decrypted['A']); } else { break; } } else { foundOne = true; sb.Append(c); decryptedBlocks.Add(decrypted[c]); } } string key = sb.ToString(); if (key.Length > 0) { StringBuilder decrypted = new StringBuilder(); for (int i = 0; i < decryptedBlocks[0].Length; i++) { foreach (string block in decryptedBlocks) { if (i < block.Length) { decrypted.Append(block[i]); } } } return(new string[] { key, decrypted.ToString() }); } } return(new string[] { "", "" }); }
public void Check(bool[] a, bool[] b, int expected) { HammingDistance.Calculate(a, b).ShouldBe(expected); }
public void Challenge6_Solution() { var inputFile = new StreamReader("Assets/inputForChallenge6.txt").ReadToEnd(); var inputByteArray = Convert.FromBase64String(inputFile); // Find key size var keySizeEditDistanceList = new Dictionary <byte, double>(); for (byte candidateKeySize = 2; candidateKeySize < 41; candidateKeySize++) { var distanceList = new List <int>(); for (int currentIndex = 0; currentIndex < inputByteArray.Length; currentIndex = currentIndex + candidateKeySize) { var first = inputByteArray.Skip(currentIndex).Take(candidateKeySize).ToArray(); var second = inputByteArray.Skip(currentIndex + candidateKeySize).Take(candidateKeySize).ToArray(); var distance = HammingDistance.Calculate(first, second); distanceList.Add(distance); } var avgDistance = distanceList.Average(); keySizeEditDistanceList.Add(candidateKeySize, avgDistance / candidateKeySize); } var keySize = keySizeEditDistanceList.OrderBy(x => x.Value).First().Key; Assert.AreEqual(29, keySize); // Transpose byte array according to the key size var blockList = new List <byte[]>(); for (int i = 0; i < inputByteArray.Length; i = i + keySize) { blockList.Add(inputByteArray.Skip(i).Take(keySize).ToArray()); } var lastBlock = blockList.Last(); if (lastBlock.Length < keySize) { var expandedLast = new byte[keySize]; for (int i = 0; i < lastBlock.Length; i++) { expandedLast[i] = lastBlock[i]; } blockList.RemoveAt(blockList.Count - 1); blockList.Add(expandedLast); } var transposedBlockList = new List <byte[]>(); for (int i = 0; i < keySize; i++) { var transposedBlockArray = new byte[blockList.Count]; for (int j = 0; j < blockList.Count; j++) { transposedBlockArray[j] = blockList[j][i]; } transposedBlockList.Add(transposedBlockArray); } // Use single byte xor cipher solution for each block to find the repeating key var keyList = new List <byte>(); foreach (var block in transposedBlockList) { var minScore = 0d; byte selectedByteCode = 32; for (byte byteCode = 32; byteCode < 127; byteCode++) // <-- Brute force search for the correct character { var output = Xor.Apply(block, byteCode); var score = SingleByteXorCipher.ScoreAccordingToEnglishLetterFrequency(output); if (score > minScore) { minScore = score; selectedByteCode = byteCode; } } //Console.WriteLine($"minScore: {minScore} selectedByteCode:{Convert.ToChar(selectedByteCode)}"); keyList.Add(selectedByteCode); } var keyByteArray = keyList.ToArray(); Assert.AreEqual("Terminator X: Bring the noise", Encoding.Default.GetString(keyByteArray)); // Decrypt text var decryptedByteArray = new byte[inputByteArray.Length]; for (int i = 0; i < inputByteArray.Length; i++) { decryptedByteArray[i] = (byte)(inputByteArray[i] ^ keyByteArray[i % keySize]); } var decryptedText = Encoding.UTF8.GetString(decryptedByteArray); Console.WriteLine(decryptedText); }