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