public void ShouldGFSboxCorrectlyDecryptCs2(string expectedText, AlgoArrayResponse algoArrayResponse)
{
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
algoArrayResponse.IV,
algoArrayResponse.Key,
algoArrayResponse.CipherText
);
var result = _subjectCs2.ProcessPayload(param);
Assert.IsTrue(result.Success, nameof(result.Success));
Assert.AreEqual(algoArrayResponse.PlainText, result.Result, expectedText);
}
public void ShouldVarKeyCorrectlyNewEngineEncrypt(string expectedText, AlgoArrayResponse algoArrayResponse)
{
var param = new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
algoArrayResponse.IV,
algoArrayResponse.Key,
algoArrayResponse.PlainText
);
var result = _newSubject.ProcessPayload(param);
Assert.IsTrue(result.Success, nameof(result.Success));
Assert.AreEqual(algoArrayResponse.CipherText, result.Result, nameof(algoArrayResponse.CipherText));
}
/*
* Seed = random n bits, where n is digest size.
*
* For 100 iterations (j = 0)
* MD[0] = MD[1] = MD[2] = Seed
*
* For 1000 iterations (i = 3)
* M[i] = MD[i-3] || MD[i-2] || MD[i-1]
* MD[i] = SHA(M[i])
*
* MD[j] = Seed = MD[1002] (last MD from inner loop)
*/
#endregion MonteCarloAlgorithm Pseudocode
public MctResult <AlgoArrayResponse> MctHash(BitString message, MathDomain domain = null, bool isSample = false)
{
if (isSample)
{
NUM_OF_RESPONSES = 3;
}
var responses = new List <AlgoArrayResponse>();
var i = 0;
var j = 0;
try
{
for (i = 0; i < NUM_OF_RESPONSES; i++)
{
BitString innerMessage = ResetDigestList(message);
BitString innerDigest = null;
var iterationResponse = new AlgoArrayResponse
{
Message = innerMessage
};
for (j = 0; j < 1000; j++)
{
var innerResult = _sha.HashMessage(innerMessage);
innerDigest = innerResult.Digest;
AddDigestToList(innerDigest);
innerMessage = GetNextMessage();
}
iterationResponse.Digest = innerDigest;
responses.Add(iterationResponse);
message = innerDigest;
}
}
catch (Exception ex)
{
ThisLogger.Debug($"i count {i}, j count {j}");
ThisLogger.Error(ex);
return(new MctResult <AlgoArrayResponse>(ex.Message));
}
return(new MctResult <AlgoArrayResponse>(responses));
}
/*
* INPUT: The initial Msg of 128 bits long
*
* Initial Outputlen = (floor(maxoutlen/8) )*8
* //makes maxoutlen a multiple of 8 and remains within the range specified.
*
* {
* Output0 = Msg;
* for (j=0; j<100; j++) {
* for (i=1; i<1001; i++) {
* M[i] = 128 leftmost bits of Output[i-1];
* Output[i] = SHAKE(M[i],Outputlen);
* If (i == 1000){
* Outputlen[j] = Outputlen;
* }
* Rightmost_Output_bits = rightmost 16 bits of Output[i];
* Range = (maxoutbytes – minoutbytes + 1);
* Outputlen = minoutbytes + (Rightmost_Output_bits mod Range);
* }
* Output[j] = Output[1000];
* OUTPUT: Outputlen[j], Output[j]
* }
* }
*/
#endregion MonteCarloAlgorithm Pseudocode
public MctResult <AlgoArrayResponse> MctHash(BitString message, MathDomain domain, bool isSample = false)
{
if (isSample)
{
NUM_OF_RESPONSES = 3;
}
var responses = new List <AlgoArrayResponse>();
var i = 0;
var j = 0;
var min = domain.GetDomainMinMax().Minimum;
var max = domain.GetDomainMinMax().Maximum;
var minBytes = min / 8;
var maxBytes = max / 8;
var outputLen = (int)System.Math.Floor((double)max / 8) * 8;
var range = (max - min) + 8;
//var range = (max - min) + min;
var innerMessage = message.GetDeepCopy();
// Might not have 128 bits to pull from so we pad with 0
innerMessage = BitString.ConcatenateBits(innerMessage, BitString.Zeroes(128));
innerMessage = BitString.MSBSubstring(innerMessage, 0, 128);
try
{
for (i = 0; i < NUM_OF_RESPONSES; i++)
{
var innerDigest = new BitString(0);
var iterationResponse = new AlgoArrayResponse()
{
};
iterationResponse.Message = innerMessage;
for (j = 0; j < 1000; j++)
{
var innerResult = _sha.HashMessage(innerMessage, outputLen);
innerDigest = innerResult.Digest.GetDeepCopy();
// Will always have 16 bits to pull from
var rightmostBits = BitString.Substring(innerDigest, 0, 16).Bits;
outputLen = min + (8 * GetIntFromBits(rightmostBits)) % range;
innerMessage = innerDigest.GetDeepCopy();
// Might not have 128 bits to pull from so we pad with 0
innerMessage = BitString.ConcatenateBits(innerMessage, BitString.Zeroes(128));
innerMessage = BitString.MSBSubstring(innerMessage, 0, 128);
}
iterationResponse.Digest = innerDigest.GetDeepCopy();
responses.Add(iterationResponse);
}
}
catch (Exception ex)
{
ThisLogger.Debug($"i count {i}, j count {j}");
ThisLogger.Error(ex);
return(new MctResult <AlgoArrayResponse>($"{ex.Message}; {outputLen}"));
}
return(new MctResult <AlgoArrayResponse>(responses));
}
/*
* INPUT: The initial Single-Tuple of a random length between 0 and 65536 bits.
*
* MCT(Tuple, MaxOutLen, MinOutLen, OutLenIncrement)
* {
* Range = (MaxOutLen – MinOutLen + 1);
* OutputLen = MaxOutLen;
* Customization = "";
*
* T[0][0] = Tuple;
*
* for (j = 0; j < 100; j++)
* {
* for (i = 1; i < 1001; i++)
* {
* workingBits = Left(T[i-1][0] || ZeroBits(288), 288);
* tupleSize = Left(workingBits, 3) % 4 + 1; // never more than 4 tuples to a round
* for (k = 0; k < tupleSize; k++)
* {
* T[i][k] = Substring of workingBits from (k * 288 / tupleSize) to ((k+1) * 288 / tupleSize - 1);
* }
* Output[i] = TupleHash(T[i], OutputLen, Customization);
* Rightmost_Output_bits = Right(Output[i], 16);
* OutputLen = MinOutLen + (floor((Rightmost_Output_bits % Range) / OutLenIncrement) * OutLenIncrement);
* Customization = BitsToString(T[i][0] || Rightmost_Output_bits);
* }
*
* OutputJ[j] = Output[1000];
* }
*
* return OutputJ;
* }
*/
#endregion MonteCarloAlgorithm Pseudocode
public MCTResultTuple <AlgoArrayResponse> MCTHash(HashFunction function, IEnumerable <BitString> tuple, MathDomain domain, bool hexCustomization, bool isSample)
{
_hexCustomization = hexCustomization;
if (isSample)
{
NUM_OF_RESPONSES = 3;
}
var responses = new List <AlgoArrayResponse>();
var i = 0;
var j = 0;
var min = domain.GetDomainMinMax().Minimum;
var max = domain.GetDomainMinMax().Maximum;
var increment = domain.GetDomainMinMax().Increment;
var minBytes = min / 8;
var maxBytes = max / 8;
var outputLen = max;
var customization = "";
var range = (max - min) + 1;
var innerTuple = GetDeepCopy(tuple);
try
{
for (i = 0; i < NUM_OF_RESPONSES; i++)
{
var innerDigest = new BitString(0);
var iterationResponse = new AlgoArrayResponse()
{
};
iterationResponse.Tuple = innerTuple;
iterationResponse.Customization = customization;
for (j = 0; j < 1000; j++)
{
// Might not have 144 bits to pull from so we pad with 0
var innerBitString = BitString.ConcatenateBits(innerTuple.ElementAt(0), BitString.Zeroes(288))
.GetMostSignificantBits(288);
var innerTupleSize = innerBitString.GetMostSignificantBits(3).Bits.ToInt() % 4 + 1;
innerTuple = new List <BitString>();
for (int k = 0; k < innerTupleSize; k++)
{
innerTuple.Add(BitString.MSBSubstring(innerBitString, k * 288 / innerTupleSize, 288 / innerTupleSize));
}
function.DigestLength = outputLen;
var innerResult = _iTupleHash.HashMessage(function, innerTuple, customization);
innerDigest = innerResult.Digest.GetDeepCopy();
// Will always have 16 bits to pull from
var rightmostBitString = BitString.Substring(innerDigest, 0, 16);
var rightmostBits = rightmostBitString.Bits;
outputLen = min + (int)System.Math.Floor((double)(rightmostBits.ToInt() % range) / increment) * increment;
customization = GetStringFromBytes(BitString.ConcatenateBits(innerTuple.ElementAt(0), rightmostBitString).ToBytes());
innerTuple = new List <BitString>();
innerTuple.Add(innerDigest.GetDeepCopy());
}
iterationResponse.Digest = innerDigest.GetDeepCopy();
responses.Add(iterationResponse);
}
}
catch (Exception ex)
{
ThisLogger.Debug($"i count {i}, j count {j}");
ThisLogger.Error(ex);
return(new MCTResultTuple <AlgoArrayResponse>($"{ex.Message}; {outputLen}"));
}
return(new MCTResultTuple <AlgoArrayResponse>(responses));
}
