public void ShouldCallGetMinMaxFromSegmentsForEachSegment(int numberOfSegments)
{
int min = 0;
int max = 100;
_mockDomainSegment
.SetupGet(s => s.RangeMinMax)
.Returns(new RangeMinMax
{
Minimum = min,
Maximum = max
});
while (_subject.DomainSegments.Count() < numberOfSegments)
{
_subject.AddSegment(_mockDomainSegment.Object);
}
_subject.GetDomainMinMax();
_mockDomainSegment.VerifyGet(v => v.RangeMinMax, Times.Exactly(numberOfSegments));
}
/*
* INPUT: The initial Msg is the length of the digest size
*
* MCT(Msg, MaxOutLen, MinOutLen, OutLenIncrement, MaxBlockSize, MinBlockSize)
* {
* Range = (MaxOutLen – MinOutLen + 1);
* OutputLen = MaxOutLen;
* BlockRange = (MaxBlockSize – MinBlockSize + 1);
* BlockSize = MinBlockSize;
* Customization = "";
*
* Output[0] = Msg;
* for (j = 0; j < 100; j++)
* {
* for (i = 1; i < 1001; i++)
* {
* InnerMsg = Left(Output[i-1] || ZeroBits(128), 128);
* Output[i] = ParallelHash(InnerMsg, OutputLen, BlockSize, FunctionName, Customization);
* Rightmost_Output_bits = Right(Output[i], 16);
* OutputLen = MinOutLen + (floor((Rightmost_Output_bits % Range) / OutLenIncrement) * OutLenIncrement);
* BlockSize = MinBlockSize + Right(Rightmost_Output_bits, 8) % BlockRange;
* Customization = BitsToString(InnerMsg || Rightmost_Output_bits);
* }
*
* OutputJ[j] = Output[1000];
* }
*
* return OutputJ;
* }
*/
#endregion MonteCarloAlgorithm Pseudocode
public MctResult <AlgoArrayResponseWithCustomization> MCTHash(HashFunction function, BitString message, MathDomain outputLength, MathDomain blockSizeDomain, bool hexCustomization, bool isSample)
{
_hexCustomization = hexCustomization;
if (isSample)
{
NUM_OF_RESPONSES = 3;
}
var responses = new List <AlgoArrayResponseWithCustomization>();
var i = 0;
var j = 0;
var min = outputLength.GetDomainMinMax().Minimum;
var max = outputLength.GetDomainMinMax().Maximum;
var increment = outputLength.GetDomainMinMax().Increment;
var minBlockSize = blockSizeDomain.GetDomainMinMax().Minimum;
var maxBlockSize = blockSizeDomain.GetDomainMinMax().Maximum;
var outputLen = max;
var blockSize = minBlockSize;
var blockSizeRange = (maxBlockSize - minBlockSize) + 1;
var customization = "";
var range = (max - min) + 1;
var innerMessage = message.GetDeepCopy();
try
{
for (i = 0; i < NUM_OF_RESPONSES; i++)
{
var innerDigest = new BitString(0);
var iterationResponse = new AlgoArrayResponseWithCustomization()
{
};
iterationResponse.Message = innerMessage;
iterationResponse.Customization = customization;
iterationResponse.BlockSize = blockSize;
for (j = 0; j < 1000; j++)
{
// Might not have 128 bits to pull from so we pad with 0
innerMessage = BitString.ConcatenateBits(innerMessage, BitString.Zeroes(128))
.GetMostSignificantBits(128);
function.DigestLength = outputLen;
var innerResult = _iParallelHash.HashMessage(function, innerMessage, blockSize, customization);
innerDigest = innerResult.Digest.GetDeepCopy();
// Will always have 16 bits to pull from
var rightmostBitString = innerDigest.GetLeastSignificantBits(16);
var rightmostBits = rightmostBitString.Bits;
outputLen = min + (int)System.Math.Floor((double)(rightmostBits.ToInt() % range) / increment) * increment;
blockSize = minBlockSize + rightmostBitString.GetLeastSignificantBits(8).Bits.ToInt() % blockSizeRange;
customization = GetStringFromBytes(BitString.ConcatenateBits(innerMessage, rightmostBitString).ToBytes());
innerMessage = 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 MctResult <AlgoArrayResponseWithCustomization>($"{ex.Message}; {outputLen}"));
}
return(new MctResult <AlgoArrayResponseWithCustomization>(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));
}
/*
* INPUT: The initial Msg is the length of the digest size
*
* MCT(Msg, MaxOutLen, MinOutLen, OutLenIncrement)
* {
* Range = (MaxOutLen – MinOutLen + 1);
* OutputLen = MaxOutLen;
* FunctionName = "";
* Customization = "";
*
* Output[0] = Msg;
* for (j = 0; j < 100; j++)
* {
* for (i = 1; i < 1001; i++)
* {
* InnerMsg = Left(Output[i-1] || ZeroBits(128), 128);
* Output[i] = CSHAKE(InnerMsg, OutputLen, FunctionName, Customization);
* Rightmost_Output_bits = Right(Output[i], 16);
* OutputLen = MinOutLen + (floor((Rightmost_Output_bits % Range) / OutLenIncrement) * OutLenIncrement);
* Customization = BitsToString(InnerMsg || Rightmost_Output_bits);
* }
*
* OutputJ[j] = Output[1000];
* }
*
* return OutputJ;
* }
*/
#endregion MonteCarloAlgorithm Pseudocode
public MctResult <AlgoArrayResponseWithCustomization> MCTHash(HashFunction function, BitString message, MathDomain domain, bool customizationHex, bool isSample)
{
_customizationHex = customizationHex;
if (isSample)
{
NUM_OF_RESPONSES = 3;
}
var responses = new List <AlgoArrayResponseWithCustomization>();
var i = 0;
var j = 0;
var min = domain.GetDomainMinMax().Minimum;
var max = domain.GetDomainMinMax().Maximum;
var increment = domain.GetDomainMinMax().Increment;
//var outputLen = (int)System.Math.Floor((double)max / 8) * 8;
var outputLen = max;
var customization = "";
var functionName = "";
var range = (max - min) + 1;
var innerMessage = message.GetDeepCopy();
try
{
for (i = 0; i < NUM_OF_RESPONSES; i++)
{
var innerDigest = new BitString(0);
var iterationResponse = new AlgoArrayResponseWithCustomization()
{
};
iterationResponse.Message = innerMessage;
iterationResponse.Customization = customization;
for (j = 0; j < 1000; j++)
{
// 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);
function.DigestLength = outputLen;
var innerResult = _iCSHAKE.HashMessage(function, innerMessage, customization, functionName);
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 + (8 * rightmostBits.ToInt()) % range;
outputLen = min + (int)System.Math.Floor((double)(rightmostBits.ToInt() % range) / increment) * increment;
customization = GetStringFromBytes(BitString.ConcatenateBits(innerMessage, rightmostBitString).ToBytes());
innerMessage = 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 MctResult <AlgoArrayResponseWithCustomization>($"{ex.Message}; {outputLen}"));
}
return(new MctResult <AlgoArrayResponseWithCustomization>(responses));
}
