public void ShouldNumCorrectly(string xStr, int expected)
{
var x = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(xStr).Reverse());
var result = _subject.Num(x);
Assert.AreEqual((BigInteger)expected, result);
}
public void ShouldReturnBitStringInCorrectOrderLt8Characters(string testString)
{
var expectation = testString.Reverse().ToArray();
var result = MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(testString);
var bs = new BitString(result);
Assert.AreEqual(expectation, bs.ToString());
}
public void ShouldReturnMostSignificantBitArrayFromLeastSignificantByteArray(string label, byte[] lsBytes, bool[] expectedLeastSignificantBits)
{
var result = MsbLsbConversionHelpers.LeastSignificantByteArrayToMostSignificantBitArray(lsBytes);
for (int i = 0; i < result.Length; i++)
{
Assert.AreEqual(expectedLeastSignificantBits[i], result[i]);
}
}
public void ShouldCorrectlyInc_s(int s, string onesAndZeroes, string expectationOnesAndZeroes)
{
BitString X = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(onesAndZeroes));
BitString expectation = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(expectationOnesAndZeroes));
var result = _subject.inc_s(s, X);
Assert.AreEqual(expectation, result);
}
public void ShouldMonteCarloTestDecrypt128BitKey()
{
string keyString = "d3057c24774e4420c5dd6d66eeb04912";
string ivString = "cdb7d2e7a5e85f2b5e6a08d89b2c9bdd";
var key = new BitString(keyString);
var iv = new BitString(ivString);
var sanityCheckFirstKey = new BitString(keyString);
var sanityCheckFirstIv = new BitString(ivString);
var cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var firstExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedKey = new BitString("0679aba4f75ae4e820fd2d2caa297854");
var secondExpectedIv = new BitString("d57cd7808014a0c8e520404a44993146");
var secondExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var secondExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedKey = new BitString("d5f29f0400854d31f2ddcdd5c32ce3ba");
var lastExpectedIv = new BitString("89b57c371d635d67a83aa3ebb4f4a03d");
var lastExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var lastExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var result = _subject.ProcessMonteCarloTest(new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt, iv, key, cipherText
));
Assert.AreEqual(key, sanityCheckFirstKey, nameof(sanityCheckFirstKey));
Assert.AreEqual(iv, sanityCheckFirstIv, nameof(sanityCheckFirstIv));
var firstPlainText = result.Response[0].PlainText;
Assert.AreEqual(firstExpectedPlainText, firstPlainText, nameof(firstPlainText));
var secondKey = result.Response[1].Key;
var secondIv = result.Response[1].IV;
var secondCipherText = result.Response[1].CipherText;
var secondPlainText = result.Response[1].PlainText;
Assert.AreEqual(secondExpectedKey, secondKey, nameof(secondExpectedKey));
Assert.AreEqual(secondExpectedIv, secondIv, nameof(secondExpectedIv));
Assert.AreEqual(secondExpectedCipherText, secondCipherText, nameof(secondExpectedCipherText));
Assert.AreEqual(secondExpectedPlainText, secondPlainText, nameof(secondExpectedPlainText));
var lastKey = result.Response[result.Response.Count - 1].Key;
var lastIv = result.Response[result.Response.Count - 1].IV;
var lastCipherText = result.Response[result.Response.Count - 1].CipherText;
var lastPlainText = result.Response[result.Response.Count - 1].PlainText;
Assert.AreEqual(lastExpectedKey, lastKey, nameof(lastExpectedKey));
Assert.AreEqual(lastExpectedIv, lastIv, nameof(lastExpectedIv));
Assert.AreEqual(lastExpectedCipherText, lastCipherText, nameof(lastCipherText));
Assert.AreEqual(lastExpectedPlainText, lastPlainText, nameof(lastPlainText));
Assert.IsTrue(result.Success);
}
public void ShouldMonteCarloTestEncrypt128BitKey()
{
string keyString = "19c27cdff233706c4c6176eb63a4568e";
string ivString = "30c6e45842a35240331669e7bd3ee1f3";
var key = new BitString(keyString);
var iv = new BitString(ivString);
var sanityCheckFirstKey = new BitString(keyString);
var sanityCheckFirstIv = new BitString(ivString);
var plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var firstExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var secondExpectedKey = new BitString("d00433b558d5e5b504620846ea9335d9");
var secondExpectedIv = new BitString("c9c64f6aaae695d948037ead89376357");
var secondExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedKey = new BitString("0b677b274bde90ae72844bff9eb0d0b3");
var lastExpectedIv = new BitString("337584c1b9d72ddb72b0a544b0f41dbf");
var lastExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var lastExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var result = _subject.ProcessMonteCarloTest(new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt, iv, key, plainText
));
Assert.AreEqual(key, sanityCheckFirstKey, nameof(sanityCheckFirstKey));
Assert.AreEqual(iv, sanityCheckFirstIv, nameof(sanityCheckFirstIv));
var firstCipherText = result.Response[0].CipherText;
Assert.AreEqual(firstExpectedCipherText, firstCipherText, nameof(firstCipherText));
var secondKey = result.Response[1].Key;
var secondIv = result.Response[1].IV;
var secondPlainText = result.Response[1].PlainText;
var secondCipherText = result.Response[1].CipherText;
Assert.AreEqual(secondExpectedKey, secondKey, nameof(secondExpectedKey));
Assert.AreEqual(secondExpectedIv, secondIv, nameof(secondExpectedIv));
Assert.AreEqual(secondExpectedPlainText, secondPlainText, nameof(secondExpectedPlainText));
Assert.AreEqual(secondExpectedCipherText, secondCipherText, nameof(secondExpectedCipherText));
var lastKey = result.Response[result.Response.Count - 1].Key;
var lastIv = result.Response[result.Response.Count - 1].IV;
var lastPlainText = result.Response[result.Response.Count - 1].PlainText;
var lastCipherText = result.Response[result.Response.Count - 1].CipherText;
Assert.AreEqual(lastExpectedKey, lastKey, nameof(lastExpectedKey));
Assert.AreEqual(lastExpectedIv, lastIv, nameof(lastExpectedIv));
Assert.AreEqual(lastExpectedPlainText, lastPlainText, nameof(lastPlainText));
Assert.AreEqual(lastExpectedCipherText, lastCipherText, nameof(lastCipherText));
Assert.IsTrue(result.Success);
}
public void ShouldMonteCarloTestDecrypt192BitKey()
{
string keyString = "81e26656c1be3dc9b7275ba3d224bac3fd42c4ba1637688d";
string ivString = "ebe322635745494100c2b0bbcafc7a33";
var key = new BitString(keyString);
var iv = new BitString(ivString);
var sanityCheckFirstKey = new BitString(keyString);
var sanityCheckFirstIv = new BitString(ivString);
var cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var firstExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedKey = new BitString("e98067eb3a70d4e54fbe0fbd36aa282e41ab0af9a96d2db9");
var secondExpectedIv = new BitString("f899541ee48e92edbce9ce43bf5a4534");
var secondExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedKey = new BitString("481dac4354c7a602f31d9fd33119cd834f69277fabba5c5f");
var lastExpectedIv = new BitString("40648ac18d340bf6f83887de83cb28db");
var lastExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var result = _subject.ProcessMonteCarloTest(new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt, iv, key, cipherText
));
Assert.AreEqual(key, sanityCheckFirstKey, nameof(sanityCheckFirstKey));
Assert.AreEqual(iv, sanityCheckFirstIv, nameof(sanityCheckFirstIv));
var firstPlainText = result.Response[0].PlainText;
Assert.AreEqual(firstExpectedPlainText, firstPlainText, nameof(firstPlainText));
var secondKey = result.Response[1].Key;
var secondIv = result.Response[1].IV;
var secondCipherText = result.Response[1].CipherText;
var secondPlainText = result.Response[1].PlainText;
Assert.AreEqual(secondExpectedKey, secondKey, nameof(secondExpectedKey));
Assert.AreEqual(secondExpectedIv, secondIv, nameof(secondExpectedIv));
Assert.AreEqual(secondExpectedCipherText, secondCipherText, nameof(secondExpectedCipherText));
Assert.AreEqual(secondExpectedPlainText, secondPlainText, nameof(secondExpectedPlainText));
var lastKey = result.Response[result.Response.Count - 1].Key;
var lastIv = result.Response[result.Response.Count - 1].IV;
var lastCipherText = result.Response[result.Response.Count - 1].CipherText;
var lastPlainText = result.Response[result.Response.Count - 1].PlainText;
Assert.AreEqual(lastExpectedKey, lastKey, nameof(lastExpectedKey));
Assert.AreEqual(lastExpectedIv, lastIv, nameof(lastExpectedIv));
Assert.AreEqual(lastExpectedCipherText, lastCipherText, nameof(lastCipherText));
Assert.AreEqual(lastExpectedPlainText, lastPlainText, nameof(lastPlainText));
Assert.IsTrue(result.Success);
}
public void ShouldMonteCarloTestDecrypt256BitKey()
{
string keyString = "63a8a289c2f89f0246e2c42f264ea27013b51e24bf9416c0a01a481ef2246f17";
string ivString = "6ec27ed42082fb5fb84c27829b03226d";
var key = new BitString(keyString);
var iv = new BitString(ivString);
var sanityCheckFirstKey = new BitString(keyString);
var sanityCheckFirstIv = new BitString(ivString);
var cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var firstExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedKey = new BitString("4c1189c6218791ceba937ff30c4c4bee86b03c7569edf1604cd4a816aa8dbaf7");
var secondExpectedIv = new BitString("95052251d679e7a0eccee00858a9d5e0");
var secondExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedKey = new BitString("9ccc8ef62058690c1265f314c752bdcb6c90e7ceaa9ca313a55ff48862005491");
var lastExpectedIv = new BitString("f2037905c418ed80780ffccdb650bf3c");
var lastExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var lastExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var result = _subject.ProcessMonteCarloTest(new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt, iv, key, cipherText
));
Assert.AreEqual(key, sanityCheckFirstKey, nameof(sanityCheckFirstKey));
Assert.AreEqual(iv, sanityCheckFirstIv, nameof(sanityCheckFirstIv));
var firstPlainText = result.Response[0].PlainText;
Assert.AreEqual(firstExpectedPlainText, firstPlainText, nameof(firstPlainText));
var secondKey = result.Response[1].Key;
var secondIv = result.Response[1].IV;
var secondCipherText = result.Response[1].CipherText;
var secondPlainText = result.Response[1].PlainText;
Assert.AreEqual(secondExpectedKey, secondKey, nameof(secondExpectedKey));
Assert.AreEqual(secondExpectedIv, secondIv, nameof(secondExpectedIv));
Assert.AreEqual(secondExpectedCipherText, secondCipherText, nameof(secondExpectedCipherText));
Assert.AreEqual(secondExpectedPlainText, secondPlainText, nameof(secondExpectedPlainText));
var lastKey = result.Response[result.Response.Count - 1].Key;
var lastIv = result.Response[result.Response.Count - 1].IV;
var lastCipherText = result.Response[result.Response.Count - 1].CipherText;
var lastPlainText = result.Response[result.Response.Count - 1].PlainText;
Assert.AreEqual(lastExpectedKey, lastKey, nameof(lastExpectedKey));
Assert.AreEqual(lastExpectedIv, lastIv, nameof(lastExpectedIv));
Assert.AreEqual(lastExpectedCipherText, lastCipherText, nameof(lastCipherText));
Assert.AreEqual(lastExpectedPlainText, lastPlainText, nameof(lastPlainText));
Assert.IsTrue(result.Success);
}
public void ReverseByteOrderReturnsBytesInReverseOrder(string label, byte[] bytes)
{
var expectedResults = bytes.Reverse().ToArray();
var subject = MsbLsbConversionHelpers.ReverseByteOrder(bytes);
for (int i = 0; i < bytes.Length; i++)
{
Assert.AreEqual(expectedResults[i], subject[i]);
}
}
public void ReverseBitArrayBitsShouldReturnBitArrayInReverseOrder(string label, bool[] bits)
{
var ba = new BitArray(bits);
var subject = MsbLsbConversionHelpers.ReverseBitArrayBits(ba);
for (int i = 0; i < subject.Length; i++)
{
Assert.AreEqual(ba[i], subject[subject.Length - 1 - i]);
}
}
public void ShouldMonteCarloTestEncrypt192BitKey()
{
string keyString = "5f21cf99ae456ed8d65cbc72c0b89759e20cb1091bc69376";
string ivString = "6e26057d460762ac302a9a64272a2944";
var key = new BitString(keyString);
var iv = new BitString(ivString);
var sanityCheckFirstKey = new BitString(keyString);
var sanityCheckFirstIv = new BitString(ivString);
var plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var firstExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var secondExpectedKey = new BitString("579fd63a9d329fa44285e3f834a94747d56c1278a9fc3c3d");
var secondExpectedIv = new BitString("94d95f8af411d01e3760a371b23aaf4b");
var lastExpectedKey = new BitString("ffa875bfb283d86a75801112b048bdd4d2f6e5caafbd9994");
var lastExpectedIv = new BitString("3f597d5af4d9b1a3980cea2b4f60118e");
var lastExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var result = _subject.ProcessMonteCarloTest(new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt, iv, key, plainText
));
Assert.AreEqual(key, sanityCheckFirstKey, nameof(sanityCheckFirstKey));
Assert.AreEqual(iv, sanityCheckFirstIv, nameof(sanityCheckFirstIv));
var firstCipherText = result.Response[0].CipherText;
Assert.AreEqual(firstExpectedCipherText, firstCipherText, nameof(firstCipherText));
var secondKey = result.Response[1].Key;
var secondIv = result.Response[1].IV;
Assert.AreEqual(secondExpectedKey, secondKey, nameof(secondExpectedKey));
Assert.AreEqual(secondExpectedIv, secondIv, nameof(secondExpectedIv));
var lastKey = result.Response[result.Response.Count - 1].Key;
var lastIv = result.Response[result.Response.Count - 1].IV;
var lastPlainText = result.Response[result.Response.Count - 1].PlainText;
var lastCipherText = result.Response[result.Response.Count - 1].CipherText;
Assert.AreEqual(lastExpectedKey, lastKey, nameof(lastExpectedKey));
Assert.AreEqual(lastExpectedIv, lastIv, nameof(lastExpectedIv));
Assert.AreEqual(lastExpectedPlainText, lastPlainText, nameof(lastPlainText));
Assert.AreEqual(lastExpectedCipherText, lastCipherText, nameof(lastCipherText));
Assert.IsTrue(result.Success);
}
public void ShouldMonteCarloTestEncrypt256BitKey()
{
string keyString = "299182240c5ff67364c6b1aac2e3f06858f290650c12c359cb47071920c55903";
string ivString = "5323e8ab1eba7a3212846dabf1493549";
var key = new BitString(keyString);
var iv = new BitString(ivString);
var sanityCheckFirstKey = new BitString(keyString);
var sanityCheckFirstIv = new BitString(ivString);
var plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var firstExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0"));
var secondExpectedKey = new BitString("ebd07fe190d02504be720ebaf56c963e6375cb3ea01105c9fdfe112f826c9b75");
var secondExpectedIv = new BitString("3b875b5bac03c69036b91636a2a9c276");
var lastExpectedKey = new BitString("101dd780875c359a7a4327fe2951e70939db234e72b09c579c12abb01c0f8c1b");
var lastExpectedIv = new BitString("23028f02b4adc4a5d35ed0e120b142bc");
var lastExpectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var lastExpectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1"));
var result = _subject.ProcessMonteCarloTest(new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt, iv, key, plainText
));
Assert.AreEqual(key, sanityCheckFirstKey, nameof(sanityCheckFirstKey));
Assert.AreEqual(iv, sanityCheckFirstIv, nameof(sanityCheckFirstIv));
var firstCipherText = result.Response[0].CipherText;
Assert.AreEqual(firstExpectedCipherText, firstCipherText, nameof(firstCipherText));
var secondKey = result.Response[1].Key;
var secondIv = result.Response[1].IV;
Assert.AreEqual(secondExpectedKey, secondKey, nameof(secondExpectedKey));
Assert.AreEqual(secondExpectedIv, secondIv, nameof(secondExpectedIv));
var lastKey = result.Response[result.Response.Count - 1].Key;
var lastIv = result.Response[result.Response.Count - 1].IV;
var lastPlainText = result.Response[result.Response.Count - 1].PlainText;
var lastCipherText = result.Response[result.Response.Count - 1].CipherText;
Assert.AreEqual(lastExpectedKey, lastKey, nameof(lastExpectedKey));
Assert.AreEqual(lastExpectedIv, lastIv, nameof(lastExpectedIv));
Assert.AreEqual(lastExpectedPlainText, lastPlainText, nameof(lastPlainText));
Assert.AreEqual(lastExpectedCipherText, lastCipherText, nameof(lastCipherText));
Assert.IsTrue(result.Success);
}
public void ShouldReturnJ0With96BitIvWithNoExternalCalls(string hString, string ivString, string expectedString)
{
BitString h = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(hString));
BitString iv = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(ivString));
BitString expectedJ0 = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(expectedString));
var result = _mockSubject.Object.Getj0(h, iv);
Assert.AreEqual(expectedJ0, result, nameof(expectedJ0));
_mockSubject.Verify(
v => v.GHash(It.IsAny <BitString>(), It.IsAny <BitString>()),
Times.Never,
nameof(_mockSubject.Object.GHash)
);
}
public void ShouldMMTDecrypt1Byte128BitKey()
{
BitString key = new BitString("83185129c67311b6fc765639b7bb63c0");
BitString iv = new BitString("84324d79ab6adc655d295ee9f8263725");
BitString cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("10"));
BitString expectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("01"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
iv,
key,
cipherText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedPlainText, result.Result);
}
public void ShouldMMTDecryptMultipleBytes128BitKey()
{
BitString key = new BitString("2a5e39f2de044223a0fcde0327331602");
BitString iv = new BitString("5e343033f92a3c82efdf9a35ac5e3657");
BitString cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1001 1100 00"));
BitString expectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0000 0110 11"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
iv,
key,
cipherText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedPlainText, result.Result);
}
public void ShouldMMTDecrypt1Byte192BitKey()
{
BitString key = new BitString("6ec4710e35f8794eb50109d8a4c63fe8a672691c28c71171");
BitString iv = new BitString("6e63d7b3e89e6d5800827a492c40ba5b");
BitString cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("10"));
BitString expectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("10"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
iv,
key,
cipherText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedPlainText, result.Result);
}
public void ShouldMMTDecryptMultipleBytes192BitKey()
{
BitString key = new BitString("677bb41a620fae519723937ebfe1f7b430970056505d76db");
BitString iv = new BitString("be91c031133b08c35ca153ad7cecb110");
BitString cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1000110010"));
BitString expectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1100100011"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
iv,
key,
cipherText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedPlainText, result.Result);
}
private static BitString ConvertEndianness(BitString message)
{
// For a small example... 60 01 (hex) = 0110 0000 0000 0001 (binary)
// should turn into 06 80 (hex) = 0000 0110 1000 0000 (binary
var messageLen = message.BitLength;
var reversedBits = MsbLsbConversionHelpers.ReverseBitArrayBits(message.Bits);
var normalizedBits = MsbLsbConversionHelpers.ReverseByteOrder(new BitString(reversedBits).ToBytes());
message = new BitString(normalizedBits);
var hex = message.ToHex();
message = new BitString(hex, messageLen, false);
return(message);
}
public void ShouldMMTDecryptMultipleBytes256BitKey()
{
BitString key = new BitString("274e1639d0b7ecc24c3ea8d968092be8b2fe0f313c7b8d1a9c479dc737c95eee");
BitString iv = new BitString("bd8831473e62ce2f92873d8ac4677b77");
BitString cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1111101010"));
BitString expectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0101100011"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
iv,
key,
cipherText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedPlainText, result.Result);
}
public void ShouldMMTDecrypt1Byte256BitKey()
{
BitString key = new BitString("9992afb14c86eaf1f2a2aea3276193c8796abad31d6f18b0e1551104629549b7");
BitString iv = new BitString("8a8f6521669c93d3d5fea9237b929f70");
BitString cipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("00"));
BitString expectedPlainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("00"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
iv,
key,
cipherText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedPlainText, result.Result);
}
public void ShouldMMTEncryptMultipleBytes256BitKey()
{
BitString key = new BitString("ec1272869c97608876ac778400d00a11cc59e45b9f0c8d60d1ebc960f74e628e");
BitString iv = new BitString("61b17b1f9aa2145054d596b4a88e8bbc");
BitString plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1110110000"));
BitString expectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1000011110"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
iv,
key,
plainText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedCipherText, result.Result);
}
public void ShouldMMTEncrypt1Byte128BitKey()
{
BitString key = new BitString("2695b44439192d099f0a31b89f24dc0f");
BitString iv = new BitString("5086c0ed84593ed006919af33d4c8902");
BitString plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("11"));
BitString expectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("11"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
iv,
key,
plainText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedCipherText, result.Result);
}
public void ShouldMMTEncryptMultipleBytes128BitKey()
{
BitString key = new BitString("7df9fff1c14de3e251aecd3a4328a907");
BitString iv = new BitString("3903d581031b6b60c0162185bc223fa9");
BitString plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0100100001"));
BitString expectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0100011111"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
iv,
key,
plainText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedCipherText, result.Result);
}
public void ShouldMMTEncrypt1Byte192BitKey()
{
BitString key = new BitString("d077cf91d6961cea53cea9e4bad61e1e854b74381f03fdd0");
BitString iv = new BitString("9a3c967ae97b977e04f2168d7024614f");
BitString plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("01"));
BitString expectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("10"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
iv,
key,
plainText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedCipherText, result.Result);
}
public void ShouldMMTEncryptMultipleBytes192BitKey()
{
BitString key = new BitString("5ca48a8c95bc37e4b526d5b86da5a7922db2d44b827c6029");
BitString iv = new BitString("460564e43d949ebe559fc3c230919d5e");
BitString plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("1101100100"));
BitString expectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("0011101110"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
iv,
key,
plainText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedCipherText, result.Result);
}
public void ShouldMMTEncrypt1Byte256BitKey()
{
BitString key = new BitString("654ba9cf4cfab4a913e85d8ff8aeed7ba2a56730584b61c071e813500b71ae1f");
BitString iv = new BitString("fc0ed6b5e59f7fe7094697b78d20174e");
BitString plainText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("11"));
BitString expectedCipherText = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0sReversed("00"));
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
iv,
key,
plainText
);
var result = _subject.ProcessPayload(param);
Assert.AreEqual(expectedCipherText, result.Result);
}
public HashResult Hash(BitString message)
{
Md5Init();
var processResult = Md5Process(message);
if (!processResult.Success)
{
return(processResult);
}
var finalResult = Md5Final();
if (finalResult.Success)
{
// Reverse byte order
var stateA = new BitString(_state[0], 32).ToBytes();
stateA = MsbLsbConversionHelpers.ReverseByteOrder(stateA);
var stateB = new BitString(_state[1], 32).ToBytes();
stateB = MsbLsbConversionHelpers.ReverseByteOrder(stateB);
var stateC = new BitString(_state[2], 32).ToBytes();
stateC = MsbLsbConversionHelpers.ReverseByteOrder(stateC);
var stateD = new BitString(_state[3], 32).ToBytes();
stateD = MsbLsbConversionHelpers.ReverseByteOrder(stateD);
// Build result
var digest = new BitString(stateA)
.ConcatenateBits(new BitString(stateB))
.ConcatenateBits(new BitString(stateC))
.ConcatenateBits(new BitString(stateD));
return(new HashResult(digest));
}
else
{
return(finalResult);
}
}
public void ShouldInvokeGHashWithAppropriateValuesWhenIvNot96Bits(string hString, string ivString)
{
BitString h = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(hString));
BitString iv = new BitString(MsbLsbConversionHelpers.GetBitArrayFromStringOf1sAnd0s(ivString));
BitString fakeGHashReturn = new BitString(5);
_mockSubject
.Setup(s => s.GHash(It.IsAny <BitString>(), It.IsAny <BitString>()))
.Returns(fakeGHashReturn);
var result = _mockSubject.Object.Getj0(h, iv);
var expectedS = 128 * 96 - iv.BitLength;
var expectedX = iv.ConcatenateBits(new BitString(new BitArray(expectedS + 64))).ConcatenateBits(BitString.To64BitString(iv.BitLength));
Assert.AreEqual(fakeGHashReturn, result, nameof(result));
_mockSubject.Verify(
v => v.GHash(It.IsAny <BitString>(), It.IsAny <BitString>()),
Times.Once,
nameof(_mockSubject.Object.GHash)
);
}
protected BitString Convert168BitKeyTo192BitKey(BitString origKey)
{
if (origKey.BitLength != 168)
{
throw new ArgumentException("Not a valid key, needs 168 bits");
}
var bsReverse = new BitString(MsbLsbConversionHelpers.ReverseBitArrayBits(origKey.Bits));
var newBs = new BitString(0);
for (var i = 0; i < bsReverse.BitLength; i++)
{
newBs = newBs.ConcatenateBits(new BitString(new BitArray(new[] { bsReverse.Bits[i] })));
if ((i + 1) % 7 == 0)
{
newBs = newBs.ConcatenateBits(BitString.Zero());
}
}
return(newBs);
}
private static BitString ConvertEndianness(BitString message)
{
// This is kinda gross... The message input is in the correct byte order but reversed bit order
// So we must reverse the bits, then reverse the bytes to put everything in the correct order
//
// For a small example... 60 01 (hex) = 0110 0000 0000 0001 (binary)
// should turn into 06 80 (hex) = 0000 0110 1000 0000 (binary
var messageLen = message.BitLength;
// Convert to big endian byte order but little endian bit order
var reversedBits = MsbLsbConversionHelpers.ReverseBitArrayBits(message.Bits);
var normalizedBits = MsbLsbConversionHelpers.ReverseByteOrder(new BitString(reversedBits).ToBytes());
// After the byte conversion make sure the result is the correct length
// The constructor here handles this for us
message = new BitString(normalizedBits);
var hex = message.ToHex();
message = new BitString(hex, messageLen, false);
return(message);
}
