public override SymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
var key = param.Key.ToBytes();
var actualBitsToProcess = param.Payload.BitLength;
param.Payload = BitString.PadToModulus(param.Payload, _engine.BlockSizeBits);
// OFB always utilizes engine in encrypt mode
var engineParam = new EngineInitParameters(BlockCipherDirections.Encrypt, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var numberOfBlocks = GetNumberOfBlocks(param.Payload.BitLength);
var outBuffer = GetOutputBuffer(param.Payload.BitLength);
if (numberOfBlocks < PARTITIONS)
{
throw new ArgumentOutOfRangeException(nameof(param.Payload), $"Ofb-I mode requires a minimum of {PARTITIONS} blocks");
}
var ivs = SetupIvs(param.Iv);
ProcessPayload(param, ivs, numberOfBlocks, outBuffer);
return(new SymmetricCipherResult(
new BitString(outBuffer).GetMostSignificantBits(actualBitsToProcess)
));
}
private void Decrypt(IModeBlockCipherParameters param, int numberOfBlocks, byte[] outBuffer)
{
var payload = param.Payload.GetDeepCopy();
var iv = param.Iv.ToBytes();
// CS1 needs to decrypt the final full block then inject the last padded bits of the plaintext into the ciphertext starting at the end of the penultimate block
// CS2/3 need to decrypt the second to the last block (which happens to be the last full block) and append that amount to pad onto the payload
var transformedPayloadBytes =
_ciphertextStealingTransform.HandleFinalFullPayloadBlockDecryption(payload, _engine, numberOfBlocks,
param.Payload.BitLength);
// Decrypt the (modified) payload using the standard CBC mode.
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
_engine.ProcessSingleBlock(transformedPayloadBytes, outBuffer, i);
// XOR IV onto current block outBuffer
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
outBuffer[i * _engine.BlockSizeBytes + j] ^= iv[j];
}
// Update Iv with current block's payload values
Array.Copy(transformedPayloadBytes, i * _engine.BlockSizeBytes, iv, 0, _engine.BlockSizeBytes);
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
public override SymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
var key = param.Key.ToBytes();
var engineParam = new EngineInitParameters(param.Direction, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var numberOfBlocks = GetNumberOfBlocks(param.Payload.BitLength);
var outBuffer = GetOutputBuffer(param.Payload.BitLength);
if (param.Direction == BlockCipherDirections.Encrypt)
{
Encrypt(param, numberOfBlocks, outBuffer);
}
else
{
Decrypt(param, numberOfBlocks, outBuffer);
}
var output = new BitString(outBuffer);
return(new SymmetricCipherResult(output.GetMostSignificantBits(param.Payload.BitLength)));
}
private void Decrypt(IModeBlockCipherParameters param, int numberOfBlocks, byte[] outBuffer)
{
var payLoad = param.Payload.ToBytes();
var iv = param.Iv.GetDeepCopy().ToBytes();
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
_engine.ProcessSingleBlock(payLoad, outBuffer, i);
// XOR IV onto current block outBuffer
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
outBuffer[i * _engine.BlockSizeBytes + j] ^= iv[j];
}
// Update Iv with current block's payLoad values
Array.Copy(payLoad, i * _engine.BlockSizeBytes, iv, 0, _engine.BlockSizeBytes);
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
private void Encrypt(IModeBlockCipherParameters param, int numberOfBlocks, byte[] outBuffer)
{
var iv = param.Iv.GetDeepCopy().ToBytes();
// Pad the last partial plaintext block with 0 until it reaches the block size.
var paddedPayload = BitString.PadToModulus(param.Payload, _engine.BlockSizeBits).ToBytes();
// Encrypt the whole padded plaintext using the standard CBC mode.
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
// XOR IV onto current block payload
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
paddedPayload[i * _engine.BlockSizeBytes + j] ^= iv[j];
}
_engine.ProcessSingleBlock(paddedPayload, outBuffer, i);
// Update Iv with current block's outBuffer values
Array.Copy(outBuffer, i * _engine.BlockSizeBytes, iv, 0, _engine.BlockSizeBytes);
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
_ciphertextStealingTransform.TransformCiphertext(outBuffer, _engine, numberOfBlocks, param.Payload.BitLength);
}
private void ProcessPayload(
IModeBlockCipherParameters param,
int numberOfBlocks,
byte[] outBuffer,
List <BitString> ivs
)
{
var payLoad = param.Payload.ToBytes();
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
var iv = _counter.GetNextIV();
ivs.Add(iv);
var ivBytes = iv.ToBytes();
var ivOutBuffer = new byte[ivBytes.Length];
_engine.ProcessSingleBlock(ivBytes, ivOutBuffer, 0);
// XOR processed IV onto current block payload
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
outBuffer[i * _engine.BlockSizeBytes + j] =
(byte)(payLoad[i * _engine.BlockSizeBytes + j] ^ ivOutBuffer[j]);
}
}
}
private void ProcessPayload(IModeBlockCipherParameters param, int numberOfBlocks, byte[] outBuffer)
{
var payLoad = param.Payload.ToBytes();
// CBC-MAC by definition always uses an empty IV, so ignore the one provided
var iv = new byte[_engine.BlockSizeBits];
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
// XOR current block payload onto IV
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
iv[j] ^= payLoad[i * _engine.BlockSizeBytes + j];
}
_engine.ProcessSingleBlock(iv, outBuffer, 0);
// Update Iv with current block's outBuffer values
Array.Copy(outBuffer, 0, iv, 0, _engine.BlockSizeBytes);
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
private void ProcessPayload(IModeBlockCipherParameters param, int numberOfBlocks, byte[] outBuffer)
{
// Concatenate payload to block boundary
var bitsInLastBlock = param.Payload.BitLength % _engine.BlockSizeBits;
var payLoad = param.Payload.GetDeepCopy().ConcatenateBits(BitString.Zeroes(_engine.BlockSizeBits - bitsInLastBlock)).ToBytes();
var iv = param.Iv.GetDeepCopy().ToBytes();
var ivOutBuffer = new byte[iv.Length];
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
_engine.ProcessSingleBlock(iv, ivOutBuffer, 0);
// XOR processed IV onto current block payload
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
outBuffer[i * _engine.BlockSizeBytes + j] =
(byte)(payLoad[i * _engine.BlockSizeBytes + j] ^ ivOutBuffer[j]);
}
// update next block IV to the processed IV of this block
Array.Copy(ivOutBuffer, iv, iv.Length);
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
private void Decrypt(IModeBlockCipherParameters param, int numberOfSegments, byte[] outBuffer)
{
var payLoad = param.Payload.GetDeepCopy().ToBytes();
var iv = param.Iv.GetDeepCopy().ToBytes();
var ivOutBuffer = new byte[iv.Length];
// For each segment
for (int i = 0; i < numberOfSegments; i++)
{
_engine.ProcessSingleBlock(iv, ivOutBuffer, 0);
// XORs the current segment of payload onto the first segment of the ivOutBuffer
_shiftRegisterStrategy.SetSegmentInProcessedBlock(payLoad, i, ivOutBuffer);
// Sets the outbuffer segment equal to the first segment of the ivOutBuffer
_shiftRegisterStrategy.SetOutBufferSegmentFromIvXorPayload(ivOutBuffer, i, outBuffer);
// Sets up the iv for the next segment
_shiftRegisterStrategy.SetNextRoundIv(payLoad, i, iv);
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
public override SymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
var key = param.Key.ToBytes();
var actualBitsToProcess = param.Payload.BitLength;
param.Payload = BitString.PadToNextByteBoundry(param.Payload);
// CFB always utilizes engine in encrypt mode
var engineParam = new EngineInitParameters(BlockCipherDirections.Encrypt, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var numberOfSegments = actualBitsToProcess / _shiftRegisterStrategy.ShiftSize;
var outBuffer = GetOutputBuffer(param.Payload.BitLength);
if (param.Direction == BlockCipherDirections.Encrypt)
{
Encrypt(param, numberOfSegments, outBuffer);
}
else
{
Decrypt(param, numberOfSegments, outBuffer);
}
return(new SymmetricCipherResult(
new BitString(outBuffer).GetMostSignificantBits(actualBitsToProcess)
));
}
private void ProcessPayload(IModeBlockCipherParameters param, BitString[] ivs, int numberOfBlocks, byte[] outBuffer)
{
var payLoad = param.Payload.ToBytes();
var iv = param.Iv.GetDeepCopy().ToBytes();
var ivOutBuffer = new byte[iv.Length];
// For each block
for (int i = 0; i < numberOfBlocks; i++)
{
_engine.ProcessSingleBlock(iv, ivOutBuffer, 0);
// XOR processed IV onto current block payload
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
outBuffer[i * _engine.BlockSizeBytes + j] =
(byte)(payLoad[i * _engine.BlockSizeBytes + j] ^ ivOutBuffer[j]);
}
// track current ivOutBuffer to use as next i % 3 iv input.
for (int j = 0; j < _engine.BlockSizeBytes; j++)
{
ivs[i % PARTITIONS][j] = ivOutBuffer[j];
}
// the next round IV to use
iv = ivs[(i + 1) % PARTITIONS].ToBytes();
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
public override SymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
if (param.Payload.BitLength / _engine.BlockSizeBits < PARTITIONS)
{
throw new ArgumentException($"CBCI mode needs at least {PARTITIONS} blocks of data");
}
var payloads = TdesPartitionHelpers.TriPartitionBitString(param.Payload);
var ivs = TdesPartitionHelpers.SetupIvs(param.Iv);
var key = param.Key.ToBytes();
var engineParam = new EngineInitParameters(param.Direction, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var outBuffer = GetOutputBuffer(param.Payload.BitLength);
if (param.Direction == BlockCipherDirections.Encrypt)
{
Encrypt(param, payloads, ivs, outBuffer);
}
else
{
Decrypt(param, payloads, ivs, outBuffer);
}
return(new SymmetricCipherResult(
new BitString(outBuffer).GetMostSignificantBits(param.Payload.BitLength)
));
}
private void ProcessPayload(IModeBlockCipherParameters param, int numberOfBlocks, byte[] outBuffer)
{
var payLoad = param.Payload.ToBytes();
for (int i = 0; i < numberOfBlocks; i++)
{
_engine.ProcessSingleBlock(payLoad, outBuffer, i);
}
}
private MCTResult <AlgoArrayResponse> Encrypt(IModeBlockCipherParameters param)
{
var responses = new List <AlgoArrayResponse>();
var i = 0;
var j = 0;
try
{
for (i = 0; i < 100; i++)
{
var iIterationResponse = new AlgoArrayResponse
{
IV = param.Iv,
Key = param.Key,
PlainText = param.Payload
};
BitString jCipherText = null;
BitString previousCipherText = null;
BitString copyPreviousCipherText = null;
var ivCopiedBytes = iIterationResponse.IV.ToBytes();
param.Iv = new BitString(ivCopiedBytes);
for (j = 0; j < 1000; j++)
{
var jResult = _algo.ProcessPayload(param);
jCipherText = jResult.Result;
if (j == 0)
{
previousCipherText = iIterationResponse.IV;
}
param.Payload = previousCipherText;
copyPreviousCipherText = previousCipherText;
previousCipherText = jCipherText;
}
iIterationResponse.CipherText = jCipherText;
responses.Add(iIterationResponse);
param.Key = _keyMaker.MixKeys(param.Key, previousCipherText, copyPreviousCipherText);
param.Iv = previousCipherText;
}
}
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));
}
private MCTResult <AlgoArrayResponse> Decrypt(IModeBlockCipherParameters param)
{
List <AlgoArrayResponse> responses = new List <AlgoArrayResponse>();
int i = 0;
int j = 0;
try
{
for (i = 0; i < 100; i++)
{
AlgoArrayResponse iIterationResponse = new AlgoArrayResponse()
{
IV = param.Iv,
Key = param.Key,
CipherText = param.Payload
};
BitString jPlainText = null;
BitString previousPlainText = null;
BitString copyPreviousPlainText = null;
var ivCopiedBytes = iIterationResponse.IV.ToBytes();
param.Iv = new BitString(ivCopiedBytes);
for (j = 0; j < 1000; j++)
{
var jResult = _algo.ProcessPayload(param);
jPlainText = jResult.Result;
if (j == 0)
{
previousPlainText = iIterationResponse.IV.ConcatenateBits(jPlainText.GetMostSignificantBits(param.Payload.BitLength - param.Iv.BitLength));
}
param.Payload = previousPlainText;
copyPreviousPlainText = previousPlainText;
previousPlainText = jPlainText;
}
iIterationResponse.PlainText = jPlainText;
responses.Add(iIterationResponse);
param.Key = _keyMaker.MixKeys(param.Key, previousPlainText, copyPreviousPlainText);
param.Iv = previousPlainText.GetMostSignificantBits(param.Iv.BitLength);
}
}
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));
}
private MCTResult <AlgoArrayResponse> Encrypt(IModeBlockCipherParameters param)
{
if (param.Payload.BitLength != 192)
{
throw new ArgumentException("Data must be 192 bits");
}
var ivs = TdesPartitionHelpers.SetupIvs(param.Iv);
var pts = TdesPartitionHelpers.TriPartitionBitString(param.Payload);
var responses = new List <AlgoArrayResponse> {
new AlgoArrayResponse {
IV = ivs[0],
Keys = param.Key,
PlainText = param.Payload
}
};
var lastCipherTexts = new List <BitString>();
var indexAtWhichToStartSaving = NUMBER_OF_ITERATIONS - NUMBER_OF_OUTPUTS_TO_SAVE;
for (var i = 0; i < NumberOfCases; i++)
{
for (var j = 0; j < NUMBER_OF_ITERATIONS; j++)
{
for (var k = 0; k < PARTITIONS; k++)
{
var result = _algo.ProcessPayload(new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
responses[i].Keys,
ivs[k].XOR(pts[k])
)).Result;
pts[k] = ivs[k].GetDeepCopy();
ivs[k] = result.GetDeepCopy();
}
if (j >= indexAtWhichToStartSaving)
{
lastCipherTexts.Insert(0, ivs[NUMBER_OF_ITERATIONS - 1 - j].GetDeepCopy());
}
}
responses.Last().CipherText = ivs[0].ConcatenateBits(ivs[1]).ConcatenateBits(ivs[2]);
responses.Add(new AlgoArrayResponse
{
IV = ivs[0],
Keys = _keyMaker.MixKeys(new TDESKeys(responses[i].Keys.GetDeepCopy()), lastCipherTexts.ToList()).ToOddParityBitString(),
PlainText = pts[0].ConcatenateBits(pts[1].ConcatenateBits(pts[2]))
});
}
responses.RemoveAt(responses.Count() - 1);
return(new MCTResult <AlgoArrayResponse>(responses));
}
private MCTResult <AlgoArrayResponse> Encrypt(IModeBlockCipherParameters param)
{
var ivs = TdesPartitionHelpers.SetupIvs(param.Iv);
var responses = new List <AlgoArrayResponse> {
new AlgoArrayResponse {
IV = ivs[0],
Keys = param.Key.GetDeepCopy(),
PlainText = param.Payload.GetDeepCopy()
}
};
var lastCipherTexts = new List <BitString>();
var indexAtWhichToStartSaving = NUMBER_OF_ITERATIONS - NUMBER_OF_OUTPUTS_TO_SAVE;
for (var i = 0; i < NumberOfCases; i++)
{
var encryptionOutputs = new List <BitString>();
var cipherText = new BitString(0);
var encryptionInput = new BitString(0);
var key = responses.Last().Keys.GetDeepCopy();
for (var j = 0; j < NUMBER_OF_ITERATIONS; j++)
{
encryptionInput = j < PARTITIONS ? ivs[j] : encryptionOutputs[j - PARTITIONS];
var encryptionOutput = _algo.ProcessPayload(new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt, key, encryptionInput
)).Result;
encryptionOutputs.Add(encryptionOutput.GetDeepCopy());
cipherText = param.Payload.XOR(encryptionOutput);
if (j >= indexAtWhichToStartSaving)
{
lastCipherTexts.Insert(0, cipherText.GetDeepCopy());
}
param.Payload = encryptionInput.GetDeepCopy();
}
responses.Last().CipherText = cipherText.GetDeepCopy();
ivs = TdesPartitionHelpers.SetupIvs(encryptionOutputs[9995].XOR(cipherText));
responses.Add(new AlgoArrayResponse
{
IV = ivs[0],
Keys = _keyMaker.MixKeys(new TDESKeys(responses[i].Keys.GetDeepCopy()), lastCipherTexts.ToList()).ToOddParityBitString(),
PlainText = responses.Last().PlainText.XOR(encryptionInput)
});
}
responses.RemoveAt(responses.Count() - 1);
return(new MCTResult <AlgoArrayResponse>(responses));
}
public MCTResult <AlgoArrayResponse> ProcessMonteCarloTest(IModeBlockCipherParameters param)
{
switch (param.Direction)
{
case BlockCipherDirections.Encrypt:
return(Encrypt(param));
case BlockCipherDirections.Decrypt:
return(Decrypt(param));
default:
throw new ArgumentException(nameof(param.Direction));
}
}
private MCTResult <AlgoArrayResponse> Decrypt(IModeBlockCipherParameters param)
{
List <AlgoArrayResponse> responses = new List <AlgoArrayResponse>();
int i = 0;
int j = 0;
try
{
for (i = 0; i < _OUTPUT_ITERATIONS; i++)
{
AlgoArrayResponse iIterationResponse = new AlgoArrayResponse()
{
IV = param.Iv,
Key = param.Key,
CipherText = param.Payload
};
responses.Add(iIterationResponse);
List <BitString> previousPlainTexts = new List <BitString>();
param.Iv = param.Iv.GetDeepCopy();
param.Payload = param.Payload.GetDeepCopy();
for (j = 0; j < _INNER_ITERATIONS_PER_OUTPUT; j++)
{
var jResult = _algo.ProcessPayload(param);
var jPlainText = jResult.Result.GetDeepCopy();
previousPlainTexts.Add(jPlainText);
iIterationResponse.PlainText = jPlainText;
param.Payload = GetNextPayload(j, iIterationResponse.IV, previousPlainTexts);
BitString iv = param.Iv.GetDeepCopy();
BitString key = param.Key.GetDeepCopy();
BitString payload = param.Payload.GetDeepCopy();
SetupNextOuterLoopValues(ref iv, ref key, ref payload, j, previousPlainTexts);
param.Iv = iv.GetDeepCopy();
param.Key = key.GetDeepCopy();
param.Payload = payload.GetDeepCopy();
}
}
}
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));
}
private Common.Symmetric.MCTResult <AlgoArrayResponse> Encrypt(IModeBlockCipherParameters param)
{
var responses = new List <AlgoArrayResponse> {
new AlgoArrayResponse {
IV = param.Iv,
Keys = param.Key,
PlainText = param.Payload
}
};
int numberOfOutputsToSave = 192 / Shift;
var indexAtWhichToStartSaving = NUMBER_OF_ITERATIONS - numberOfOutputsToSave;
for (var i = 0; i < NumberOfCases; i++)
{
Debug.WriteLineIf((i + 1) % 10 == 0, $"Running MCT Encryption round {i + 1} out of {NumberOfCases}");
var lastResponse = responses.Last();
var tempText = lastResponse.PlainText.GetDeepCopy();
var tempIv = lastResponse.IV.GetDeepCopy();
BitString prevTempIv = null;
var lastCipherTexts = new List <BitString>();
BitString output = null;
var keysForThisRound = responses[i].Keys;
for (var j = 0; j < NUMBER_OF_ITERATIONS; j++)
{
prevTempIv = tempIv.GetDeepCopy();
output = _algo.ProcessPayload(new ModeBlockCipherParameters(
BlockCipherDirections.Encrypt,
tempIv,
keysForThisRound,
tempText
)).Result;
tempText = prevTempIv.MSBSubstring(0, Shift);
if (j >= indexAtWhichToStartSaving)
{
lastCipherTexts.Insert(0, output.GetDeepCopy());
}
}
lastResponse.CipherText = output;
responses.Add(new AlgoArrayResponse()
{
Keys = _keyMaker.MixKeys(new TDESKeys(lastResponse.Keys.GetDeepCopy()), lastCipherTexts).ToOddParityBitString(),
PlainText = prevTempIv.GetDeepCopy().MSBSubstring(0, Shift),
IV = tempIv.GetDeepCopy()
});
}
responses.RemoveAt(responses.Count() - 1);
return(new Common.Symmetric.MCTResult <AlgoArrayResponse>(responses));
}
private Common.Symmetric.MCTResult <AlgoArrayResponse> Decrypt(IModeBlockCipherParameters param)
{
var responses = new List <AlgoArrayResponse> {
new AlgoArrayResponse {
IV = param.Iv.GetDeepCopy(),
Keys = param.Key.GetDeepCopy(),
CipherText = param.Payload.GetDeepCopy()
}
};
var indexAtWhichToStartSaving = NUMBER_OF_ITERATIONS - NUMBER_OF_OUTPUTS_TO_SAVE;
for (var i = 0; i < NumberOfCases; i++)
{
var tempCipherText = responses.Last().CipherText.GetDeepCopy();
var tempIv = responses.Last().IV.GetDeepCopy();
BitString prevTempIv = null;
SymmetricCipherResult decryptionResult = null;
var lastPlainTexts = new List <BitString>();
for (var j = 0; j < NUMBER_OF_ITERATIONS; j++)
{
prevTempIv = tempIv.GetDeepCopy();
decryptionResult = _algo.ProcessPayload(new ModeBlockCipherParameters(
BlockCipherDirections.Decrypt,
tempIv,
responses[i].Keys,
tempCipherText
));
tempCipherText = prevTempIv.GetDeepCopy();
if (j >= indexAtWhichToStartSaving)
{
lastPlainTexts.Insert(0, decryptionResult.Result.GetDeepCopy());
}
}
responses.Last().PlainText = decryptionResult.Result.GetDeepCopy();
responses.Add(new AlgoArrayResponse()
{
Keys = _keyMaker.MixKeys(new TDESKeys(responses.Last().Keys.GetDeepCopy()), lastPlainTexts).ToOddParityBitString(),
CipherText = responses.Last().CipherText.GetDeepCopy().XOR(prevTempIv),
IV = tempIv.GetDeepCopy()
});
}
responses.RemoveAt(responses.Count() - 1);
return(new Common.Symmetric.MCTResult <AlgoArrayResponse>(responses));
}
private void Encrypt(
IModeBlockCipherParameters param,
BitString[] payloads,
BitString[] ivs,
byte[] outBuffer
)
{
byte[] iv = null;
// for each partition
for (int i = 0; i < PARTITIONS; i++)
{
iv = ivs[i].ToBytes();
var payload = payloads[i].ToBytes();
var tempOutBuffer = new byte[payload.Length];
var numberOfBlocks = GetNumberOfBlocks(payloads[i].BitLength);
// For each block
for (int j = 0; j < numberOfBlocks; j++)
{
// XOR IV onto current block payload
for (int k = 0; k < _engine.BlockSizeBytes; k++)
{
payload[j * _engine.BlockSizeBytes + k] ^= iv[k];
}
_engine.ProcessSingleBlock(payload, tempOutBuffer, j);
var outBufferIndex = ((j * PARTITIONS) + i) * _engine.BlockSizeBytes;
Array.Copy(
tempOutBuffer,
j * _engine.BlockSizeBytes,
outBuffer,
outBufferIndex,
_engine.BlockSizeBytes
);
// Update Iv with current block's outBuffer values
Array.Copy(tempOutBuffer, j * _engine.BlockSizeBytes, iv, 0, _engine.BlockSizeBytes);
}
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
private Common.Symmetric.MCTResult <AlgoArrayResponse> Encrypt(IModeBlockCipherParameters param)
{
List <AlgoArrayResponse> responses = new List <AlgoArrayResponse>();
List <BitString> lastCipherTexts = new List <BitString>();
for (int outerLoop = 0; outerLoop < NumberOfCases; outerLoop++)
{
AlgoArrayResponse iIterationResponse = new AlgoArrayResponse()
{
IV = param.Iv,
Keys = param.Key,
PlainText = param.Payload
};
BitString jCipherText = null;
BitString previousCipherText = null;
var ivCopiedBytes = iIterationResponse.IV.ToBytes();
param.Iv = new BitString(ivCopiedBytes);
for (int innerLoop = 0; innerLoop < NUMBER_OF_ITERATIONS; innerLoop++)
{
var jResult = _algo.ProcessPayload(param);
jCipherText = jResult.Result;
SaveOutputForKeyMixing(jResult.Result.GetDeepCopy(), lastCipherTexts);
if (innerLoop == 0)
{
previousCipherText = iIterationResponse.IV;
}
param.Payload = previousCipherText;
previousCipherText = jCipherText;
}
// Inner loop complete, save response
iIterationResponse.CipherText = jCipherText;
responses.Add(iIterationResponse);
// Setup next loop values
param.Key =
_keyMaker.MixKeys(new TDESKeys(iIterationResponse.Keys.GetDeepCopy()), lastCipherTexts)
.ToOddParityBitString();
}
return(new Common.Symmetric.MCTResult <AlgoArrayResponse>(responses));
}
private MCTResult <AlgoArrayResponse> Decrypt(IModeBlockCipherParameters param)
{
List <AlgoArrayResponse> responses = new List <AlgoArrayResponse>();
int i = 0;
int j = 0;
try
{
for (i = 0; i < 100; i++)
{
AlgoArrayResponse iIterationResponse = new AlgoArrayResponse()
{
Key = param.Key,
CipherText = param.Payload
};
BitString jPlainText = null;
BitString previousPlainText = null;
BitString copyPreviousPlainText = null;
for (j = 0; j < 1000; j++)
{
var jResult = _algo.ProcessPayload(param);
jPlainText = jResult.Result;
param.Payload = jPlainText;
copyPreviousPlainText = previousPlainText;
previousPlainText = jPlainText;
}
iIterationResponse.PlainText = jPlainText;
responses.Add(iIterationResponse);
param.Key = _keyMaker.MixKeys(param.Key, previousPlainText, copyPreviousPlainText);
}
}
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));
}
public override SymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
var key = param.Key.ToBytes();
// OFB always utilizes engine in encrypt mode
var engineParam = new EngineInitParameters(BlockCipherDirections.Encrypt, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var numberOfBlocks = GetNumberOfBlocks(param.Payload.BitLength);
var outBuffer = GetOutputBuffer(param.Payload.BitLength);
ProcessPayload(param, numberOfBlocks, outBuffer);
return(new SymmetricCipherResult(
new BitString(outBuffer).GetMostSignificantBits(param.Payload.BitLength)
));
}
public override SymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
var key = param.Key.ToBytes();
var engineParam = new EngineInitParameters(param.Direction, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var numberOfBlocks = GetNumberOfBlocks(param.Payload.BitLength);
var outBuffer = GetOutputBuffer(_engine.BlockSizeBits);
// Same logic regardless of encrypt/decrypt
ProcessPayload(param, numberOfBlocks, outBuffer);
return(new SymmetricCipherResult(
new BitString(outBuffer)
));
}
public override SymmetricCounterResult ProcessPayload(IModeBlockCipherParameters param)
{
CheckPayloadRequirements(param.Payload);
var ivs = new List <BitString>();
var key = param.Key.ToBytes();
var actualBitsToProcess = param.Payload.BitLength;
param.Payload = BitString.PadToModulus(param.Payload, _engine.BlockSizeBits);
// CTR always utilizes engine in encrypt mode
var engineParam = new EngineInitParameters(BlockCipherDirections.Encrypt, key, param.UseInverseCipherMode);
_engine.Init(engineParam);
var numberOfBlocks = GetNumberOfBlocks(param.Payload.BitLength);
var outBuffer = GetOutputBuffer(param.Payload.BitLength);
ProcessPayload(param, numberOfBlocks, outBuffer, ivs);
return(new SymmetricCounterResult(new BitString(outBuffer).GetMostSignificantBits(actualBitsToProcess), ivs));
}
private void Decrypt(IModeBlockCipherParameters param, int numberOfSegments, BitString[] ivs, byte[] outBuffer)
{
var payLoad = param.Payload.ToBytes();
var ivOutBuffer = new byte[_engine.BlockSizeBytes];
var iv = ivs[0].ToBytes();
// For each segment
for (int i = 0; i < numberOfSegments; i++)
{
_engine.ProcessSingleBlock(iv, ivOutBuffer, 0);
// XORs the current segment of payload onto the first segment of the ivOutBuffer
_shiftRegisterStrategy.SetSegmentInProcessedBlock(payLoad, i, ivOutBuffer);
// Sets the outbuffer segment equal to the first segment of the ivOutBuffer
_shiftRegisterStrategy.SetOutBufferSegmentFromIvXorPayload(ivOutBuffer, i, outBuffer);
// Sets up the iv for the next segment
if (i + 1 < PARTITIONS)
{
iv = ivs[(i + 1) % PARTITIONS].ToBytes();
}
else
{
iv = new BitString(iv)
.MSBSubstring(_shiftRegisterStrategy.ShiftSize, 64 - _shiftRegisterStrategy.ShiftSize)
.ConcatenateBits(
new BitString(payLoad)
.MSBSubstring((i + 1 - PARTITIONS) * _shiftRegisterStrategy.ShiftSize,
_shiftRegisterStrategy.ShiftSize)
).ToBytes();
}
}
// Update the Param.Iv for the next call
for (int i = 0; i < _engine.BlockSizeBytes; i++)
{
param.Iv[i] = iv[i];
}
}
public abstract TSymmetricCipherResult ProcessPayload(IModeBlockCipherParameters param);
private Common.Symmetric.MCTResult <Common.Symmetric.TDES.AlgoArrayResponse> Decrypt(IModeBlockCipherParameters param)
{
var responses = new List <Common.Symmetric.TDES.AlgoArrayResponse>();
var lastPlainTexts = new List <BitString>();
for (var outerLoop = 0; outerLoop < NumberOfCases; outerLoop++)
{
var iIterationResponse = new Common.Symmetric.TDES.AlgoArrayResponse
{
Keys = param.Key,
CipherText = param.Payload
};
BitString jPlainText = null;
for (var innerLoop = 0; innerLoop < NUMBER_OF_ITERATIONS; innerLoop++)
{
var jResult = _algo.ProcessPayload(param);
jPlainText = jResult.Result;
SaveOutputForKeyMixing(jResult.Result.GetDeepCopy(), lastPlainTexts);
param.Payload = jPlainText;
}
// Inner loop complete, save response
iIterationResponse.PlainText = jPlainText;
responses.Add(iIterationResponse);
// Setup next loop values
param.Key =
_keyMaker.MixKeys(new TDESKeys(iIterationResponse.Keys.GetDeepCopy()), lastPlainTexts)
.ToOddParityBitString();
}
return(new Common.Symmetric.MCTResult <Common.Symmetric.TDES.AlgoArrayResponse>(responses));
}
