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);
}
