private void Decrypt (ICryptoTransform trans, byte[] input, byte[] output)
{
int bs = trans.InputBlockSize;
int full = input.Length / bs;
int partial = input.Length % bs;
int pos = 0;
for (int i=0; i < full; i++) {
trans.TransformBlock (input, pos, bs, output, pos);
pos += bs;
}
if (partial > 0) {
byte[] final = trans.TransformFinalBlock (input, pos, partial);
Array.Copy (final, 0, output, pos, partial);
}
}
private void InvalidInput_Base64Transform(ICryptoTransform transform)
{
byte[] data_4bytes = Text.Encoding.ASCII.GetBytes("aaaa");
Assert.Throws<ArgumentNullException>("inputBuffer", () => transform.TransformBlock(null, 0, 0, null, 0));
Assert.Throws<ArgumentOutOfRangeException>("inputOffset", () => transform.TransformBlock(Array.Empty<byte>(), -1, 0, null, 0));
Assert.Throws<ArgumentNullException>("dst", () => transform.TransformBlock(data_4bytes, 0, 4, null, 0));
Assert.Throws<ArgumentException>(null, () => transform.TransformBlock(Array.Empty<byte>(), 0, 1, null, 0));
Assert.Throws<ArgumentException>(null, () => transform.TransformBlock(Array.Empty<byte>(), 1, 0, null, 0));
Assert.Throws<ArgumentNullException>("inputBuffer", () => transform.TransformFinalBlock(null, 0, 0));
Assert.Throws<ArgumentOutOfRangeException>("inputOffset", () => transform.TransformFinalBlock(Array.Empty<byte>(), -1, 0));
Assert.Throws<ArgumentOutOfRangeException>("inputOffset", () => transform.TransformFinalBlock(Array.Empty<byte>(), -1, 0));
Assert.Throws<ArgumentException>(null, () => transform.TransformFinalBlock(Array.Empty<byte>(), 1, 0));
}
public override void Initialize ()
{
_ct = _algo.CreateEncryptor ();
_k1 = new byte[_algo.BlockSize >> 3];
_k2 = new byte[_k1.Length];
_state = new byte[_k1.Length];
_buf = new byte[_k1.Length];
_bufFilled = 0;
byte[] R = (_algo.BlockSize == 64 ? R_64 : R_128);
_ct.TransformBlock (new byte[_k1.Length], 0, _k1.Length, _k1, 0);
int msb = MSB_1 (_k1);
LeftShift_1 (_k1);
if (msb != 0) {
for (int i = 0; i < _k1.Length; i++)
_k1[i] ^= R[i];
}
Buffer.BlockCopy (_k1, 0, _k2, 0, _k2.Length);
LeftShift_1 (_k2);
if (MSB_1 (_k1) != 0) {
for (int i = 0; i < _k2.Length; i++)
_k2[i] ^= R[i];
}
}
public void CheckCBC(ICryptoTransform encryptor, ICryptoTransform decryptor,
byte[] plaintext, byte[] expected)
{
if ((plaintext.Length % encryptor.InputBlockSize) != 0) {
throw new ArgumentException("Must have complete blocks");
}
byte[] ciphertext = new byte[plaintext.Length];
for (int i=0; i < plaintext.Length; i += encryptor.InputBlockSize) {
encryptor.TransformBlock(plaintext, i, encryptor.InputBlockSize, ciphertext, i);
}
for (int i=0; i<32; i++) {
AssertEquals("CBC-" + i, expected[i], ciphertext[i]);
}
byte[] roundtrip = new byte[plaintext.Length];
for (int i=0; i < ciphertext.Length; i += decryptor.InputBlockSize) {
decryptor.TransformBlock(ciphertext, i, decryptor.InputBlockSize, roundtrip, i);
}
for (int i=0; i<32; i++) {
AssertEquals("CBC-rt-" + i, roundtrip[i], plaintext[i]);
}
}
static byte[] TransformBlocks(ICryptoTransform cryptoTransform, byte[] input)
{
byte[] result = new byte[input.Length];
int num = 0;
while (num < input.Length)
{
cryptoTransform.TransformBlock(input, num, 16, result, num);
num += 16;
}
while (result[0] == (byte)0)
{
result = ((IEnumerable <byte>)result).Skip <byte>(1).ToArray <byte>();
}
return(result);
}
public byte[] Decrypt(ArraySegment <byte> input)
{
byte[] numArray = input.Array != null ? new byte[input.Count] : throw new ArgumentException("The input must have a valid array.", nameof(input));
int outputOffset = 0;
int num1 = input.Offset + input.Count;
for (int offset = input.Offset; offset < num1; offset += _blockSize)
{
int num2 = _decryptor.TransformBlock(input.Array, offset, _blockSize, numArray, outputOffset);
outputOffset += num2;
}
if (Log.IsDebugEnabled)
{
Log.DebugFormat("Decrypt [{0}] => [{1}]", input.ToHexString(), numArray.ToHexString());
}
return(numArray);
}
public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
{
if (inputCount != InputBlockSize)
{
throw new ArgumentException("Input count does not match input block size");
}
var output = new byte[OutputBlockSize];
var length = _aesEcbTransform.TransformBlock(inputBuffer, inputOffset, inputCount, output, 0);
var outputPlusPreviousBlock = Utils.Xor(output, _previousBlock).ToArray();
Array.Copy(outputPlusPreviousBlock, 0, outputBuffer, outputOffset, length);
Array.Copy(inputBuffer, inputOffset, _previousBlock, 0, length);
return(length);
}
public static byte[] Decrypt(byte[] toDecrypt, byte[] key)
{
byte[] unusedIV = new byte[16];
Aes128CounterMode counterMode = new Aes128CounterMode(0, 1);
ICryptoTransform decryptor = counterMode.CreateDecryptor(key, unusedIV);
byte[] decrypted = new byte[toDecrypt.Length * 2];
int bytesWritten = decryptor.TransformBlock(toDecrypt, 0, toDecrypt.Length, decrypted, 0);
if (bytesWritten == decrypted.Length)
{
return(decrypted);
}
byte[] resizedEncrypted = new byte[bytesWritten];
Array.Copy(decrypted, resizedEncrypted, bytesWritten);
return(resizedEncrypted);
}
public static void TransformWithTooShortOutputBuffer(bool encrypt, bool blockAlignedOutput)
{
using (RC2 alg = RC2Factory.Create())
using (ICryptoTransform xform = encrypt ? alg.CreateEncryptor() : alg.CreateDecryptor())
{
// 1 block, plus maybe three bytes
int outputPadding = blockAlignedOutput ? 0 : 3;
byte[] output = new byte[alg.BlockSize / 8 + outputPadding];
// 3 blocks of 0x00
byte[] input = new byte[3 * (alg.BlockSize / 8)];
Assert.Throws <ArgumentOutOfRangeException>(
() => xform.TransformBlock(input, 0, input.Length, output, 0));
Assert.Equal(new byte[output.Length], output);
}
}
async Task SendEncryptedMessage(byte[] msg)
{
if (localSecret == null)
{
MemoryStream mstream = new MemoryStream();
BinaryWriter mwriter = new BinaryWriter(mstream);
mwriter.Write(msg.Length);
mwriter.Write(msg);
int alignedSize = (int)mstream.Length;
alignedSize += 16 - (alignedSize % 16); //Align to 16-byte boundary
mstream.Position = 0;
msg = new byte[alignedSize];
mstream.Read(msg, 0, msg.Length);
encryptor.TransformBlock(msg, 0, msg.Length, msg, 0);
}
await clearStream.SendMessage(msg);
}
private static bool InPlaceDecrypt <T>() where T : SymmetricAlgorithm, new()
{
// setup the encryption algorithm
T algorithm = new T();
algorithm.GenerateKey();
algorithm.GenerateIV();
algorithm.Padding = PaddingMode.None;
algorithm.Mode = CipherMode.CBC;
// create data to encrypt
byte[] original = new byte[algorithm.BlockSize];
byte[] originalCopy = new byte[algorithm.BlockSize];
for (int i = 0; i < original.Length; i++)
{
original[i] = (byte)((i * 21) % Byte.MaxValue);
originalCopy[i] = original[i];
}
// encrypt it to a second array, and then in place
byte[] encrypted = new byte[algorithm.BlockSize];
ICryptoTransform externalEncryptor = algorithm.CreateEncryptor();
externalEncryptor.TransformBlock(original, 0, original.Length, encrypted, 0);
ICryptoTransform inplaceEncryptor = algorithm.CreateEncryptor();
inplaceEncryptor.TransformBlock(original, 0, original.Length, original, 0);
if (!Util.CompareBytes(encrypted, original))
{
Console.Error.WriteLine("In place and external encryption differ");
return(false);
}
// now decrypt to a second array, and then in place
byte[] roundTrip = new byte[algorithm.BlockSize];
ICryptoTransform externalDecryptor = algorithm.CreateDecryptor();
externalDecryptor.TransformBlock(encrypted, 0, encrypted.Length, roundTrip, 0);
ICryptoTransform inplaceDecryptor = algorithm.CreateDecryptor();
inplaceDecryptor.TransformBlock(original, 0, original.Length, original, 0);
return(Util.CompareBytes(roundTrip, original) &&
Util.CompareBytes(original, originalCopy));
}
public override void NextBlock(Span <byte> buf)
{
var bounce = ArrayPool <byte> .Shared.Rent(_ecbNoPad.OutputBlockSize);
_ecbNoPad.TransformBlock(_ctr, 0, _ctr.Length, bounce, 0);
byte acc = 1;
for (var i = _ctr.Length - 1; i >= 0; i--)
{
var sum = _ctr[i] + acc;
_ctr[i] = (byte)sum;
acc = (byte)((sum >> 8) & 1);
}
bounce.AsSpan(0, _ecbNoPad.OutputBlockSize).CopyTo(buf);
ArrayPool <byte> .Shared.Return(bounce);
}
public byte[] CreateDataPacket(byte[] data)
{
if (ValidSequence >= 20_000_000)
{
throw new Exception("A key exchange should have happened by this point");
}
int blocks = (data.Length + 15 + m_hmacLength) >> 4;
byte[] cipherKey = new byte[blocks * 16];
for (int x = 0; x < blocks; x++)
{
Array.Copy(IV, 0, cipherKey, x * 16, 10);
cipherKey[x * 16 + 10] = KeyID;
cipherKey[x * 16 + 11] = (byte)(ValidSequence >> 16);
cipherKey[x * 16 + 12] = (byte)(ValidSequence >> 8);
cipherKey[x * 16 + 13] = (byte)(ValidSequence);
cipherKey[x * 16 + 14] = (byte)(x >> 8);
cipherKey[x * 16 + 15] = (byte)(x);
}
if (m_encrypt.TransformBlock(cipherKey, 0, cipherKey.Length, cipherKey, 0) != cipherKey.Length)
{
throw new Exception("Error");
}
byte[] packet = new byte[4 + m_hmacLength + data.Length];
packet[0] = KeyID;
packet[1] = (byte)(ValidSequence >> 16);
packet[2] = (byte)(ValidSequence >> 8);
packet[3] = (byte)(ValidSequence);
Array.Copy(data, 0, packet, 4, data.Length);
byte[] hash = m_hmac.ComputeHash(packet, 0, data.Length + 4);
Array.Copy(hash, 0, packet, data.Length + 4, m_hmacLength);
for (int x = 0; x < data.Length + m_hmacLength; x++)
{
packet[4 + x] ^= cipherKey[x];
}
ValidSequence++;
return(packet);
}
private static byte[] Crypt(byte[] data, int offset, byte[] orgkey, bool encrypt)
{
Rijndael aes = Rijndael.Create();
byte[] aeskey = new byte[16];
orgkey.CopyTo(aeskey, 0);
byte[] iv = new byte[16]; // empty - not used for ECB
int aesLen = 0;
SwapBytes(aeskey, aeskey.Length, 0);
aesLen = data.Length - offset;
aesLen -= aesLen % 16;
SwapBytes(data, aesLen, offset);
aes.Mode = CipherMode.ECB;
aes.KeySize = 128;
aes.Padding = PaddingMode.None;
if (encrypt)
{
ICryptoTransform encryptor = aes.CreateEncryptor(aeskey, iv);
if (aesLen > 0)
{
encryptor.TransformBlock(data, offset, aesLen, data, offset);
}
}
else
{
ICryptoTransform decryptor = aes.CreateDecryptor(aeskey, iv);
if (aesLen > 0)
{
decryptor.TransformBlock(data, offset, aesLen, data, offset);
}
}
SwapBytes(data, aesLen, offset);
// Apply XOR to the rest of buffer
for (int i = 0; i < data.Length - aesLen - offset; i++)
{
data[offset + aesLen + i] ^= XorKey[i];
}
return(data);
}
public ValueBuffer CreateMask(ReadOnlySpan <byte> sample)
{
if (sample.Length < MaskLength)
{
throw new ArgumentOutOfRangeException(nameof(sample));
}
var buffer = new byte[sample.Length];
sample.CopyTo(buffer);
encryptor.TransformBlock(buffer, 0, buffer.Length, buffer, 0);
var mask = buffer.AsSpan().Slice(0, MaskLength);
return(new ValueBuffer(mask));
}
public void Modern_Rijndael()
{
Random r = new Random();
byte[] key;
byte[] iv;
for (int keylen = 16; keylen < 32; keylen += 8)
{
for (int blocklen = 128; blocklen < 256; blocklen += 64)
{
key = new byte[keylen];
iv = new byte[blocklen / 8];
r.NextBytes(key);
r.NextBytes(iv);
Ciphers.Modern.Rijndael rij = new Ciphers.Modern.Rijndael();
rij.BlockLength = blocklen;
rij.Key = key;
rij.IV = iv;
byte[] test = new byte[blocklen / 8];
r.NextBytes(test);
byte[] cipher = rij.Encrypt(test);
byte[] checkcipher = new byte[test.Length];
using (RijndaelManaged rm = new RijndaelManaged())
{
rm.BlockSize = blocklen;
rm.Key = key;
rm.IV = iv;
ICryptoTransform encryptor = rm.CreateEncryptor(key, iv);
encryptor.TransformBlock(test, 0, test.Length, checkcipher, 0);
}
CollectionAssert.AreEqual(checkcipher, cipher);
byte[] clear = rij.Decrypt(cipher);
CollectionAssert.AreEqual(test, clear);
}
}
}
private static string CryptoTransform(ICryptoTransform transform, string txt, bool compressarray)
{
using (transform)
{
// Verify that multiple blocks can not be transformed.
if (!transform.CanTransformMultipleBlocks)
{
// Initializie the offset size.
var inputOffset = 0;
// Iterate through inputBytes transforming by blockSize.
var inputBlockSize = transform.InputBlockSize;
//var encoding = Encoding.GetEncoding(1252);
//var encoding = Encoding.GetEncoding(1251);
var encoding = Encoding.ASCII;
var inputBytes = encoding.GetBytes(txt);
byte[] outputBytes = null;
while (inputBytes.Length - inputOffset > inputBlockSize)
{
transform.TransformBlock(inputBytes, inputOffset, inputBytes.Length - inputOffset, outputBytes, 0);
inputOffset += transform.InputBlockSize;
}
// Transform the final block of data.
outputBytes = transform.TransformFinalBlock(inputBytes, inputOffset, inputBytes.Length - inputOffset);
if (compressarray)
{
outputBytes = CompressArray(outputBytes);
}
if (outputBytes == null || outputBytes.Length == 0)
{
return(string.Empty);
}
var result = encoding.GetString(outputBytes, 0, outputBytes.Length);
return(result);
}
}
return(null);
}
public void Decrypt(byte[] input, int offset, int length, Stream output)
{
int blockSize = _rijndael.BlockSize / 8;
if (length < blockSize)
{
return;
}
byte[] tmp = new byte[blockSize];
Array.Copy(input, offset, tmp, 0, blockSize);
_rijndael.IV = tmp;
ICryptoTransform cryptoTransform = _rijndael.CreateDecryptor();
int count = length - blockSize;
if (count % blockSize == 0)
{
count = count / blockSize;
}
else
{
count = count / blockSize + 1;
}
byte[] buf = new byte[blockSize];
int off = offset + blockSize;
try
{
for (int i = 0; i < count - 1; ++i)
{
cryptoTransform.TransformBlock(input, off, blockSize, buf, 0);
off += blockSize;
if (i != 0)
{
output.Write(buf, 0, blockSize);
}
}
buf = cryptoTransform.TransformFinalBlock(input, off, offset + length - off);
output.Write(buf, 0, buf.Length);
}
catch { }
cryptoTransform.Dispose();
}
/// <summary>Takes in a byte array and returns the data in a unencrypted
/// format.</summary>
/// <param name="EncryptedData">The data to decrypt.</param>
/// <returns>The unencrypted data.</param> */
public byte[] DecryptData(byte[] EncryptedData)
{
Brunet.Util.MemBlock iv_ref = Brunet.Util.MemBlock.Reference(EncryptedData, 0, BlockSizeByte);
ICryptoTransform dec = (ICryptoTransform)_decryptors[iv_ref];
if (dec == null)
{
byte[] iv = new byte[BlockSizeByte];
iv_ref.CopyTo(iv, 0);
dec = _sa.CreateDecryptor(_sa.Key, iv);
}
else
{
_decryptors.Remove(iv_ref);
}
int count = EncryptedData.Length - BlockSizeByte;
iv_ref = Brunet.Util.MemBlock.Reference(EncryptedData, count, BlockSizeByte);
_decryptors[iv_ref] = dec;
if ((count % BlockSizeByte) > 0 || count == 0)
{
throw new CryptographicException("Invalid input block size.");
}
byte[] output = new byte[count];
dec.TransformBlock(EncryptedData, BlockSizeByte, count, output, 0);
byte padding = output[count - 1];
int length = count - padding;
for (int i = length; i < count; i++)
{
if (output[i] != padding)
{
throw new CryptographicException(String.Format("Bad padding at position {0}.", i));
}
}
byte[] res = new byte[length];
Buffer.BlockCopy(output, 0, res, 0, length);
return(res);
}
/// <summary>
/// Implement the ICryptoTransform method.
/// </summary>
public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer,
int outputOffset)
{
// Pass the data stream to the hash algorithm for generating the Auth Code.
// This does not change the inputBuffer. Do this before decryption for read mode.
if (!_writeMode)
{
#if !OS_WINDOWS
incrementalHash.AppendData(inputBuffer, inputOffset, inputCount);
#else
_hmacsha1.TransformBlock(inputBuffer, inputOffset, inputCount, inputBuffer, inputOffset);
#endif
}
// Encrypt with AES in CTR mode. Regards to Dr Brian Gladman for this.
int ix = 0;
while (ix < inputCount)
{
if (_encrPos == ENCRYPT_BLOCK)
{
/* increment encryption nonce */
int j = 0;
while (++_counterNonce[j] == 0)
{
++j;
}
/* encrypt the nonce to form next xor buffer */
_encryptor.TransformBlock(_counterNonce, 0, _blockSize, _encryptBuffer, 0);
_encrPos = 0;
}
outputBuffer[ix + outputOffset] = (byte)(inputBuffer[ix + inputOffset] ^ _encryptBuffer[_encrPos++]);
//
ix++;
}
if (_writeMode)
{
// This does not change the buffer.
#if !OS_WINDOWS
incrementalHash.AppendData(outputBuffer, outputOffset, inputCount);
#else
_hmacsha1.TransformBlock(outputBuffer, outputOffset, inputCount, outputBuffer, outputOffset);
#endif
}
return(inputCount);
}
private void decrypt(block b)
{
byte[] iv = new byte[16];
b.Aes.IV = iv; //takes a copy
Array.Copy(_enc, b.Offset + 0x3d0, iv, 0, 16); //get iv from encrypted header
//decrypt the header to get the key
using (ICryptoTransform cryptor = b.Aes.CreateDecryptor())
cryptor.TransformBlock(_enc, b.Offset, 0x400, _dec, b.Offset);
b.Aes.IV = iv;
using (ICryptoTransform cryptor = b.Aes.CreateDecryptor())
cryptor.TransformBlock(_enc, b.DataOffset, 0x7c00, _dec, b.DataOffset);
b.IsDirty = false;
}
public static string DESdeCript(string dados, string chave)
{
byte[] bytes = Encoding.ASCII.GetBytes(chave);
byte[] numArray = new byte[8];
for (int index = 0; index < dados.Length / 2; ++index)
{
numArray[index] = (byte)Convert.ToInt32(dados.Substring(index * 2, 2), 16);
}
DES des = (DES) new DESCryptoServiceProvider();
des.Key = bytes;
des.Mode = CipherMode.ECB;
ICryptoTransform decryptor = des.CreateDecryptor();
new CryptoStream((Stream) new MemoryStream(), decryptor, CryptoStreamMode.Write).Write(numArray, 0, numArray.Length);
decryptor.TransformBlock(numArray, 0, 8, numArray, 0);
return(new ASCIIEncoding().GetString(numArray));
}
/// <summary>
/// Create and return an Initialization Vector (IV) using a given sequence-number and encryptor.
/// </summary>
/// <param name="encryptor">the ICryptoTransform to use to do the encryption</param>
/// <param name="seqNumBytes">a byte-array that is the sequence-number</param>
/// <returns>a byte-array that comprises the Initialization Vector (IV)</returns>
private byte[] GenerateIV(ICryptoTransform encryptor, byte[] seqNumBytes)
{
// generating an IV by encrypting the sequence number with the random IV and encrypting symmetric key
byte[] iv = new byte[SecurityParameters.RecordIVLength];
Buffer.BlockCopy(seqNumBytes, 0, iv, 0, 8);
byte padding = (byte)((encryptor.OutputBlockSize - (9 % encryptor.OutputBlockSize)) % encryptor.OutputBlockSize);
for (int i = 8; i < iv.Length; i++)
{
iv[i] = padding;
}
// Compute the hash value for the region of the input byte-array (iv), starting at index 0,
// and copy the resulting hash value back into the same byte-array.
encryptor.TransformBlock(iv, 0, iv.Length, iv, 0);
return(iv);
}
public int ProcessBlock(byte[] block, byte[] result)
{
if (_blockTransform == null)
{
throw new BlockCipherNotInitiatedException();
}
if (_transformBuffer == null || block.Length > _transformBuffer.Length)
{
_transformBuffer = new byte[block.Length];
}
int bytes = _blockTransform.TransformBlock(block, 0, block.Length, _transformBuffer, 0);
Array.Copy(_transformBuffer, result, _transformBuffer.Length);
return(bytes);
}
private void IncrementNonce()
{
EncryptedNonceOffset = 0;
unchecked
{
int i = 15;
do
{
Nonce[i]++;
if (Nonce[i] != 0 || i == 0)
{
break;
}
i--;
}while (true);
Transform.TransformBlock(Nonce, 0, Nonce.Length, EncryptedNonce, 0);
}
}
private void Ctr(uint seq, byte[] inBytes, byte[] outBytes, int offset)
{
int count = (inBytes.Length + 15) / 16;
byte[] ctrBytes = new byte[count * 16];
byte[] seqBytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)seq));
Buffer.BlockCopy(seqBytes, 0, _cipherCounter, _cipherNonce.Length, seqBytes.Length);
for (int b = 0; b < count; b++)
{
byte[] blkBytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(b));
Buffer.BlockCopy(blkBytes, 0, _cipherCounter, _cipherNonce.Length + blkBytes.Length, blkBytes.Length);
_cryptoAlgorithm.TransformBlock(_cipherCounter, 0, 16, ctrBytes, b * 16);
}
for (int i = 0; i < inBytes.Length; i++)
{
outBytes[offset + i] = (byte)(ctrBytes[i] ^ inBytes[i]);
}
}
public override void Decrypt(byte[] src, int offset, int len)
{
if (this.KeyExchange.Key == null)
{
return;
}
if (offset == src.Length)
{
return;
}
byte[] buf = new byte[len + 16];//more 16 bytes to ensure it decrypts completely
dec = aes.CreateDecryptor(this.KeyExchange.Key, new byte[16]);
src.CopyTo(buf, 0);
dec.TransformBlock(buf, offset, len + 16, buf, offset);
Array.Copy(buf, offset, src, offset, len);
}
public static void Decrypt(ICryptoTransform trans, byte[] input, byte[] output)
{
int bs = trans.InputBlockSize;
int full = input.Length / bs;
int partial = input.Length % bs;
int pos = 0;
for (int i = 0; i < full; i++)
{
trans.TransformBlock(input, pos, bs, output, pos);
pos += bs;
}
if (partial > 0)
{
byte[] final = trans.TransformFinalBlock(input, pos, partial);
Array.Copy(final, 0, output, pos, partial);
}
}
public byte[] Decrypt(byte[] src, int offset)
{
if (aesKey == null)
{
return(src);
}
if (offset == src.Length)
{
return(src);
}
ICryptoTransform crypt = aes.CreateDecryptor(aesKey, new byte[16]);
int len = src.Length - offset;
byte[] buf = new byte[src.Length];
src.CopyTo(buf, 0);
crypt.TransformBlock(src, offset, len, buf, offset);
return(buf);
}
public static byte[] CreateEncryptedAnswerBlob(string answer, List <Direction> moveSequence)
{
byte[] key = MoveSequenceToKey(moveSequence);
AesManaged aes = new AesManaged();
aes.Key = key;
aes.IV = PuzzleIV;
ICryptoTransform encryptor = aes.CreateEncryptor();
System.Text.UnicodeEncoding encoding = new System.Text.UnicodeEncoding();
byte[] answerBuffer = encoding.GetBytes(answer);
byte[] encAnswer = new byte[answerBuffer.Length];
encryptor.TransformBlock(answerBuffer, 0, answerBuffer.Length, encAnswer, 0);
return(encAnswer);
}
public static string CreateOTP(YubikeySettings key, Form1 form)
{
string tokenID = ModHex.Encode(key.TokenID);
// Assemble key unencrypted data
byte[] keyBytes = new byte[16];
for (int i = 0; i < key.PrivateID.Length; ++i)
{
keyBytes[i] = key.PrivateID[i];
}
keyBytes[6] = (byte)(key.SessionCounter & 0xff);
keyBytes[7] = (byte)((key.SessionCounter >> 8) & 0xff);
form.SessionCounter = key.SessionCounter.ToString();
TimeSpan diff = DateTime.Now - key.StartTime;
int timer = (int)((((uint)(diff.TotalSeconds / TS_SEC) & 0x00FFFFFF) + key.TimeStamp) & 0x00FFFFFF);
form.Timestamp = timer.ToString();
keyBytes[8] = (byte)(timer & 0xff);
keyBytes[9] = (byte)((timer >> 8) & 0xff);
keyBytes[10] = (byte)((timer >> 16) & 0xff);
keyBytes[11] = key.UseCounter++;
form.UseCounter = keyBytes[11].ToString();
byte[] buffer = new byte[2];
RNGCryptoServiceProvider.Create().GetBytes(buffer);
form.Random = (((int)buffer[1] << 8) + (int)buffer[0]).ToString();
keyBytes[12] = buffer[0];
keyBytes[13] = buffer[1];
CRC(keyBytes);
using (Rijndael aes = Rijndael.Create())
{
aes.Padding = PaddingMode.None;
aes.Mode = CipherMode.ECB;
using (ICryptoTransform xform = aes.CreateEncryptor(key.Secret, new byte[16]))
{
byte[] plainBytes = new byte[16];
xform.TransformBlock(keyBytes, 0, keyBytes.Length, plainBytes, 0);
string otp = tokenID + ModHex.Encode(plainBytes);
return(otp);
}
}
}
public int TransformDataUnit(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset, uint dataUnit)
{
byte[] encryptedTweak = new byte[0x10];
byte[] tweak = _tweakBytes;
// Update tweak with data unit number
Array.Copy(BitConverter.GetBytes(dataUnit), tweak, 4);
// Encrypt tweak
_tweakEncryptor.TransformBlock(tweak, 0, tweak.Length, encryptedTweak, 0);
byte[] encryptedTweakOrig = new byte[0x10];
Array.Copy(encryptedTweak, encryptedTweakOrig, 0x10);
int blocks = inputCount / BlockSize;
// Apply first part of tweak (input-tweak) to input buffer all at once
for (int i = 0; i < blocks; i++)
{
for (int y = 0; y < BlockSize; y++)
{
outputBuffer[outputOffset + (i * BlockSize) + y] = (byte)(inputBuffer[inputOffset + (i * BlockSize) + y] ^ encryptedTweak[y % encryptedTweak.Length]);
}
encryptedTweak = MultiplyTweak(encryptedTweak);
}
// AES transform the data...
var transformedBytes = _dataTransform.TransformBlock(outputBuffer, outputOffset, inputCount, outputBuffer, outputOffset);
// Reset tweak back to original encrypted tweak and then apply output-tweak
Array.Copy(encryptedTweakOrig, encryptedTweak, 0x10);
for (int i = 0; i < blocks; i++)
{
for (int y = 0; y < BlockSize; y++)
{
outputBuffer[outputOffset + (i * BlockSize) + y] = (byte)(outputBuffer[outputOffset + (i * BlockSize) + y] ^ encryptedTweak[y % encryptedTweak.Length]);
}
encryptedTweak = MultiplyTweak(encryptedTweak);
}
return(transformedBytes);
}
/* The Base64-encoded content in this file has been encrypted via AES-128 in ECB mode under the key
*
* "YELLOW SUBMARINE".
* (case-sensitive, without the quotes; exactly 16 characters; I like "YELLOW SUBMARINE" because it's exactly 16 bytes long, and now you do too).
*
* Decrypt it. You know the key, after all.
*/
static void Main(string[] args)
{
//http://cryptopals.com/static/challenge-data/7.txt
byte[] inbytes = Convert.FromBase64String(getWebStuff("http://cryptopals.com/static/challenge-data/7.txt").Result);
byte[] outbytes = new byte[inbytes.Length];
byte[] block;
byte[] key = Encoding.ASCII.GetBytes("YELLOW SUBMARINE");
AesCryptoServiceProvider acsp = new AesCryptoServiceProvider();
acsp.Mode = CipherMode.ECB;
acsp.KeySize = key.Length * 8; // 16 bytes * 8 bits/byte = 128 although this is superfluous since AES-128 means 128 bit key
acsp.Padding = PaddingMode.PKCS7; // Default padding mode for PKCS7; I tried none but discovered that the input data is in fact padded
MemoryStream inst = new MemoryStream(inbytes);
MemoryStream outs = new MemoryStream(outbytes);
BinaryReader rea = new BinaryReader(inst);
BinaryWriter writer = new BinaryWriter(outs);
ICryptoTransform decr = acsp.CreateDecryptor(key, null);
block = new byte[decr.InputBlockSize];
int index = 0;
int oindex = 0;
// Decrypt block by block, when we find that we are near the end of the stream
// of input data, perform a final transform.
while ((index = (int)rea.BaseStream.Position) < (int)rea.BaseStream.Length)
{
if (((int)rea.BaseStream.Length - index) <= decr.InputBlockSize)
{
// Append last block to output byte stream
// by rewinding the output stream pointer oblock bytes
// from the end and writing the oblock to the output bytes
block = rea.ReadBytes(decr.InputBlockSize);
byte[] oblock = decr.TransformFinalBlock(block, 0, decr.InputBlockSize);
writer.BaseStream.Seek(-(long)oblock.Length, SeekOrigin.End);
writer.Write(oblock);
continue;
}
block = rea.ReadBytes(decr.InputBlockSize);
decr.TransformBlock(block, 0, decr.InputBlockSize, outbytes, oindex);
oindex = index;
}
System.Console.WriteLine(Encoding.ASCII.GetString(outbytes));
System.Console.ReadKey();
}
// similar to previous case but here we try to skip several blocks
// i.e. encdata.Length versus decdata.Length
public void DontDecryptMultipleBlock(CipherMode mode, PaddingMode padding)
{
SymmetricAlgorithm algo = Algorithm;
algo.Mode = mode;
algo.Padding = padding;
ICryptoTransform enc = algo.CreateEncryptor();
byte[] plaintext = new byte[BlockSize * 7];
byte[] encdata = new byte[BlockSize * 8];
int len = enc.TransformBlock(plaintext, 0, plaintext.Length, encdata, 0);
Assert.AreEqual(plaintext.Length, len, "encdata");
ICryptoTransform dec = algo.CreateDecryptor();
byte[] decdata = new byte[BlockSize];
dec.TransformBlock(encdata, 0, encdata.Length, decdata, 0);
}
public void CheckCBC(ICryptoTransform encryptor, ICryptoTransform decryptor,
byte[] plaintext, byte[] expected)
{
if ((plaintext.Length % encryptor.InputBlockSize) != 0) {
throw new ArgumentException("Must have complete blocks");
}
byte[] ciphertext = new byte[plaintext.Length];
for (int i=0; i < plaintext.Length; i += encryptor.InputBlockSize) {
encryptor.TransformBlock(plaintext, i, encryptor.InputBlockSize, ciphertext, i);
}
Assert.AreEqual (expected, ciphertext, "CBC");
byte[] roundtrip = new byte[plaintext.Length];
for (int i=0; i < ciphertext.Length; i += decryptor.InputBlockSize) {
decryptor.TransformBlock(ciphertext, i, decryptor.InputBlockSize, roundtrip, i);
}
Assert.AreEqual (plaintext, roundtrip, "CBC-rt");
}
public Packet RecvPacket(ICryptoTransform decryptor)
{
if (decryptor == null)
{
Packet packet = new Packet();
uint packet_length = reader.ReadUInt32();
byte padding_length = reader.ReadByte();
byte[] payload = reader.ReadBytes(packet_length - padding_length - 1);
byte[] padding = reader.ReadBytes(padding_length);
packet.SetPayload(payload);
return packet;
}
else
{
int blocksize = Math.Max(decryptor.InputBlockSize, 8);
MemoryStream ms_packet = new MemoryStream();
NetworkByteWriter writer_packet = new NetworkByteWriter(ms_packet);
byte[] buffer = new byte[blocksize];
bool first = true;
int more = 0;
while (true)
{
// read a block
int ret = reader.ReadBytes(buffer, 0, blocksize);
// must be a real block size;
if (ret != blocksize) return null;
decryptor.TransformBlock(buffer, 0, buffer.Length, buffer, 0);
writer_packet.WriteBytes(buffer);
if (first) // it's first time, need parse packet_length and padding_length
{
NetworkByteReader reader_buffer = new NetworkByteReader(new MemoryStream(buffer));
uint packet_length_t = reader_buffer.ReadUInt32();
first = false;
more = (int)packet_length_t + 4 - blocksize;
if (more % blocksize != 0) return null;
}
else
{
more -= blocksize;
}
if (more <= 0) break;
}
byte[] mac = reader.ReadBytes(20);
ms_packet.Seek(0, SeekOrigin.Begin);
NetworkByteReader reader_packet = new NetworkByteReader(ms_packet);
Packet packet = new Packet();
uint packet_length = reader_packet.ReadUInt32();
byte padding_length = reader_packet.ReadByte();
byte[] payload = reader_packet.ReadBytes(packet_length - padding_length - 1);
byte[] padding = reader_packet.ReadBytes(padding_length);
packet.SetPayload(payload);
return packet;
}
}
private static void Collect(this List<byte> l, ICryptoTransform transform, Stream input, int count)
{
byte[] buffer = new byte[count];
int numRead = input.Read(buffer, 0, count);
Assert.Equal(count, numRead);
byte[] buffer2 = new byte[count];
int numBytesWritten = transform.TransformBlock(buffer, 0, count, buffer2, 0);
Array.Resize(ref buffer2, numBytesWritten);
l.AddRange(buffer2);
}
/// <summary>
/// Create and return an Initialization Vector (IV) using a given sequence-number and encryptor.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="seqNumBytes"></param>
/// <returns></returns>
private byte[] GenerateIV(ICryptoTransform encryptor, byte[] seqNumBytes)
{
// generating an IV by encrypting the sequence number with the random IV and encrypting symmetric key
byte[] iv = new byte[SecurityParameters.RecordIVLength];
Buffer.BlockCopy(seqNumBytes, 0, iv, 0, 8);
byte padding = (byte)((encryptor.OutputBlockSize - (9 % encryptor.OutputBlockSize)) % encryptor.OutputBlockSize);
for (int i = 8; i < iv.Length; i++)
{
iv[i] = padding;
}
// Compute the hash value for the region of the input byte-array (iv), starting at index 0,
// and copy the resulting hash value back into the same byte-array.
encryptor.TransformBlock(iv, 0, iv.Length, iv, 0);
return iv;
}
static byte[] AESCTREncrypt(ICryptoTransform aes, byte[] buffer, int bufferLen, byte[] ivec, byte[] evec, ref int blockOffset, ref int blockIndex)
{
byte[] ret = new byte[bufferLen];
for (int i = 0 ; i < bufferLen ; i++)
{
if (blockOffset == 0) //calculate the encrypted block
{
//increment the ivec as if it were a 128-bit big endian number
byte[] newIvec = (byte[])ivec.Clone();
long val = BitConverter.ToInt64(ivec, 8);
val = IPAddress.HostToNetworkOrder(IPAddress.NetworkToHostOrder(val) + blockIndex);
byte[] valarray = BitConverter.GetBytes(val);
valarray.CopyTo(newIvec, 8);
aes.TransformBlock(newIvec, 0, newIvec.Length, evec, 0);
blockIndex++;
}
ret[i] = (byte)(buffer[i] ^ evec[blockOffset]);
blockOffset = (blockOffset + 1) % aes.OutputBlockSize;
}
return ret;
}
private byte[] GenerateIV(ICryptoTransform encryptor, byte[] seqNumBytes)
{
// generating an IV by encrypting the sequence number with the random IV and encrypting symmetric key
byte[] iv = new byte[SecurityParameters.RecordIVLength];
Buffer.BlockCopy(seqNumBytes, 0, iv, 0, 8);
byte padding = (byte)((encryptor.OutputBlockSize - (9 % encryptor.OutputBlockSize)) % encryptor.OutputBlockSize);
for (int i = 8; i < iv.Length; i++)
{
iv[i] = padding;
}
encryptor.TransformBlock(iv, 0, iv.Length, iv, 0);
return iv;
}
static void Encrypt(byte[] data, int offset, int len, ICryptoTransform key, byte[] iv, int startCounter, byte[] temp512)
{
var buf = temp512;
var block = startCounter;
const int numBlocks = 32;
for (var pos = 0; pos < len; pos += 16 * numBlocks)
{
var blocks = numBlocks;
if (pos + 16 * numBlocks > len)
blocks = (len - pos + 15) / 16;
for (var i = 0; i < blocks; i++)
{
Buffer.BlockCopy(iv, 0, buf, i * 16, 14);
buf[i * 16 + 14] = (byte)(block >> 8);
buf[i * 16 + 15] = (byte)block;
++block;
}
key.TransformBlock(buf, 0, blocks * 16, buf, 0);
var end = Math.Min(pos + numBlocks * 16, len);
for (int i = pos, j = 0; i < end; i++, j++)
{
data[offset + i] ^= buf[j];
}
}
}
public static ulong[] GetH(ICryptoTransform key)
{
var bytes = new byte[16];
key.TransformBlock(bytes, 0, 16, bytes, 0);
int offset = 0;
var h1 = Utils.ReadUInt64(bytes, ref offset);
var h2 = Utils.ReadUInt64(bytes, ref offset);
Utils.ClearArray(bytes);
return Construct(h1, h2);
}
public void CheckECBRoundtrip(ICryptoTransform encryptor, ICryptoTransform decryptor,
byte[] plaintext, byte[] expected)
{
byte[] ciphertext = new byte[plaintext.Length];
encryptor.TransformBlock(plaintext, 0, plaintext.Length, ciphertext, 0);
Assert.AreEqual (expected, ciphertext, "ECB");
byte[] roundtrip = new byte[plaintext.Length];
decryptor.TransformBlock(ciphertext, 0, ciphertext.Length, roundtrip, 0);
Assert.AreEqual (plaintext, roundtrip, "ECB-rt-len");
}
void TransformMultiByte(byte[] input, byte[] output, ICryptoTransform transform)
{
if (input.Length != output.Length)
{
throw new Exception("Input and output size must match");
}
if (testmode)
{
Buffer.BlockCopy(input, 0, output, 0, output.Length);
return;
}
int ib = transform.InputBlockSize;
if (transform.CanTransformMultipleBlocks)
{
transform.TransformBlock(input, 0, output.Length, output, 0);
}else {
for (int i = 0; i < output.Length; i += ib)
{
transform.TransformBlock(input, i, ib, output, i);
}
}
}
private static byte[] TransformRecordBytes(BulkCipherAlgorithmType cipherType, ICryptoTransform transform, byte[] input)
{
if (cipherType != BulkCipherAlgorithmType.AEAD) {
// In case of non-AEAD cipher algorithm, check that data matches block size
if (input.Length % transform.InputBlockSize != 0) {
throw new Exception("Input data size doesn't match block size");
}
}
int blockCount = input.Length / transform.InputBlockSize;
if (cipherType == BulkCipherAlgorithmType.AEAD) {
// Make sure there is enough data at TransformFinalBlock, because
// decryption requires that the authentication tag is present
if (blockCount > 0) {
blockCount--;
}
}
byte[] output = new byte[blockCount * transform.OutputBlockSize];
if (transform.CanTransformMultipleBlocks) {
transform.TransformBlock(input, 0, blockCount*transform.InputBlockSize, output, 0);
} else {
for (int i=0; i<blockCount; i++) {
transform.TransformBlock(input, i*transform.InputBlockSize,
transform.InputBlockSize,
output, i*transform.OutputBlockSize);
}
}
if (cipherType == BulkCipherAlgorithmType.AEAD) {
int currentPosition = blockCount*transform.InputBlockSize;
// Transfer the last block when encrypting or authentication tag when decrypting
byte[] finalBytes = transform.TransformFinalBlock(input, currentPosition, input.Length-currentPosition);
if (finalBytes == null) {
return null;
} else if (finalBytes.Length > 0) {
byte[] finalOutput = new byte[output.Length + finalBytes.Length];
Buffer.BlockCopy(output, 0, finalOutput, 0, output.Length);
Buffer.BlockCopy(finalBytes, 0, finalOutput, output.Length, finalBytes.Length);
output = finalOutput;
}
}
return output;
}
public void CheckECBRoundtrip(ICryptoTransform encryptor, ICryptoTransform decryptor,
byte[] plaintext, byte[] expected)
{
byte[] ciphertext = new byte[plaintext.Length];
int n = encryptor.TransformBlock(plaintext, 0, plaintext.Length, ciphertext, 0);
AssertEquals("ECB-len", n, expected.Length);
for (int i=0; i < ciphertext.Length; i++) {
AssertEquals("ECB-encrypt-" + i, ciphertext[i], expected[i]);
}
byte[] roundtrip = new byte[plaintext.Length];
n = decryptor.TransformBlock(ciphertext, 0, ciphertext.Length, roundtrip, 0);
AssertEquals("ECB-rt-len", n, plaintext.Length);
for (int i=0; i < roundtrip.Length; i++) {
AssertEquals("ECB-rt-" + i, roundtrip[i], plaintext[i]);
}
}
private void DecryptBytes(ICryptoTransform decryptor, byte[] cipherBytes,
out byte[] plainBytes, out byte[] mac, out byte[] padding)
{
if (cipherBytes.Length % decryptor.InputBlockSize != 0)
{
throw new NetMQSecurityException(NetMQSecurityErrorCode.EncryptedFrameInvalidLength, "Invalid block size for cipher bytes");
}
byte[] frameBytes = new byte[cipherBytes.Length];
int dataLength;
int paddingSize;
if (SecurityParameters.BulkCipherAlgorithm != BulkCipherAlgorithm.Null)
{
decryptor.TransformBlock(cipherBytes, 0, cipherBytes.Length, frameBytes, 0);
paddingSize = frameBytes[frameBytes.Length - 1] + 1;
if (paddingSize > decryptor.InputBlockSize)
{
// somebody tamper the message, we don't want throw the exception yet because
// of timing issue, we need to throw the exception after the mac check,
// therefore we will change the padding size to the size of the block
paddingSize = decryptor.InputBlockSize;
}
dataLength = frameBytes.Length - paddingSize - SecurityParameters.MACLength;
// data length can be zero if somebody tamper with the padding
if (dataLength < 0)
{
dataLength = 0;
}
}
else
{
dataLength = frameBytes.Length - SecurityParameters.MACLength;
frameBytes = cipherBytes;
paddingSize = 0;
}
plainBytes = new byte[dataLength];
Buffer.BlockCopy(frameBytes, 0, plainBytes, 0, dataLength);
mac = new byte[SecurityParameters.MACLength];
Buffer.BlockCopy(frameBytes, dataLength, mac, 0, SecurityParameters.MACLength);
padding = new byte[paddingSize];
Buffer.BlockCopy(frameBytes, dataLength + SecurityParameters.MACLength, padding, 0, paddingSize);
}
private byte[] EncryptBytes(ICryptoTransform encryptor, ContentType contentType, ulong seqNum,
int frameIndex, byte[] plainBytes)
{
byte[] mac;
if (SecurityParameters.MACAlgorithm != MACAlgorithm.Null)
{
byte[] versionAndType = new byte[] { (byte)contentType, m_protocolVersion[0], m_protocolVersion[1] };
byte[] seqNumBytes = BitConverter.GetBytes(seqNum);
byte[] messageSize = BitConverter.GetBytes(plainBytes.Length);
byte[] frameIndexBytes = BitConverter.GetBytes(frameIndex);
m_encryptionHMAC.Initialize();
m_encryptionHMAC.TransformBlock(seqNumBytes, 0, seqNumBytes.Length, seqNumBytes, 0);
m_encryptionHMAC.TransformBlock(versionAndType, 0, versionAndType.Length, versionAndType, 0);
m_encryptionHMAC.TransformBlock(messageSize, 0, messageSize.Length, messageSize, 0);
m_encryptionHMAC.TransformBlock(frameIndexBytes, 0, frameIndexBytes.Length, frameIndexBytes, 0);
m_encryptionHMAC.TransformFinalBlock(plainBytes, 0, plainBytes.Length);
mac = m_encryptionHMAC.Hash;
}
else
{
mac = new byte[0];
}
int length = plainBytes.Length + SecurityParameters.MACLength;
byte padding = 0;
if (SecurityParameters.BulkCipherAlgorithm != BulkCipherAlgorithm.Null)
{
padding = (byte)((encryptor.OutputBlockSize -
(plainBytes.Length + SecurityParameters.MACLength + 1) % encryptor.OutputBlockSize) %
encryptor.OutputBlockSize);
length += padding + 1;
}
byte[] cipherBytes = new byte[length];
Buffer.BlockCopy(plainBytes, 0, cipherBytes, 0, plainBytes.Length);
Buffer.BlockCopy(mac, 0, cipherBytes, plainBytes.Length, SecurityParameters.MACLength);
if (SecurityParameters.BulkCipherAlgorithm != BulkCipherAlgorithm.Null)
{
for (int i = plainBytes.Length + SecurityParameters.MACLength; i < cipherBytes.Length; i++)
{
cipherBytes[i] = padding;
}
encryptor.TransformBlock(cipherBytes, 0, cipherBytes.Length, cipherBytes, 0);
}
return cipherBytes;
}
void TransformBlocksFast(byte[] bufIn, byte[] bufOut, ICryptoTransform transformer)
{
for (int i = 0; i < bufIn.Length / BlockSize; i++)
transformer.TransformBlock(bufIn, i * BlockSize, BlockSize, bufOut, i * BlockSize);
}
public void decrypt(byte[] criptedData, byte[] destination)
{
tfDecryptor = tf.CreateDecryptor(tf.Key,tf.IV);
for (int i = 0;i<criptedData.Length/16;i++)
tfDecryptor.TransformBlock(criptedData,i*16,16,destination,i*16);
}
internal static byte[] GenericTransform(ICryptoTransform transform,
byte[] data)
{
List<byte> byteList = new List<byte>();
byte[] outputBytes;
int inputLength = data.Length;
int inputBlockSize = transform.InputBlockSize;
if (typeof(FromBase64Transform).IsInstanceOfType(transform)) {
// workaround for apparent bug where FromBase64Transform.InputBlockSize
// returns 1 when it should return 4
inputBlockSize = 4;
}
int inputOffset = 0;
outputBytes = new byte[transform.OutputBlockSize];
if (!transform.CanTransformMultipleBlocks) {
while (inputLength - inputOffset > inputBlockSize) {
transform.TransformBlock(data, inputOffset, inputBlockSize,
outputBytes, 0);
byteList.AddRange(outputBytes);
inputOffset += inputBlockSize;
}
}
outputBytes = transform.TransformFinalBlock(data, inputOffset,
inputLength - inputOffset);
byteList.AddRange(outputBytes);
byte[] result = byteList.ToArray();
ClearByteList(byteList);
return result;
}
public void encrypt(byte[] plainData, byte[] destination)
{
tfEncryptor = tf.CreateEncryptor(tf.Key,tf.IV);
for (int i = 0;i<plainData.Length/16;i++)
tfEncryptor.TransformBlock(plainData,i*16,16,destination,i*16);
}
/// <summary>
/// Does the actual work of pulling the filestreams in
/// and passing the blocks into the crytoprovider
/// </summary>
/// <param name="filenames">An array of String objects, each containing a filename</param>
/// <param name="cryptoInterface">An <see cref="ICryptoTransform"/> interface pointing to a cryptoprovider</param>
/// <param name="blockSize">Size in bytes of the transform block / read buffer</param>
protected void ComputeHashes(String[] filenames, ICryptoTransform cryptoInterface, int blockSize)
{
for (int loop = 0; loop <= filenames.GetUpperBound(0); loop++)
{
using (FileStream inputFile = new FileStream(filenames[loop], FileMode.Open, FileAccess.Read))
{
byte[] readBuffer = new byte[(int)blockSize];
byte[] copyBuffer;
long fileLength = inputFile.Length;
int bytesRead = 0;
long totalBytesRead = 0;
while (totalBytesRead < fileLength)
{
bytesRead = inputFile.Read(readBuffer, 0, (int)blockSize);
if (bytesRead == blockSize) { copyBuffer = readBuffer; }
else
{
copyBuffer = new byte[bytesRead];
Array.Copy(readBuffer, copyBuffer, bytesRead);
}
totalBytesRead += bytesRead;
if (totalBytesRead == fileLength && loop == filenames.GetUpperBound(0))
{
// Last block of the last file
cryptoInterface.TransformFinalBlock(copyBuffer, 0, copyBuffer.Length);
}
else
{
cryptoInterface.TransformBlock(copyBuffer, 0, copyBuffer.Length, copyBuffer, 0);
}
// Report progress and
// check for cancellation request
OnHashBlockProcessed(new HasherEventArgs(HasherEventReportType.ProgressReport,
filenames.Length,
loop + 1,
totalBytesRead,
fileLength));
if (this.cancelRequested == true)
{
throw new OperationCanceledException();
}
}
}
}
// Report hash computed
OnHashComputed(new HasherEventArgs(HasherEventReportType.Completed, null, null, null, null));
}
private void TransformBlock_One (ICryptoTransform ct, int expected)
{
byte[] data = new byte[ct.InputBlockSize];
Assert.AreEqual (expected, ct.TransformBlock (data, 0, ct.InputBlockSize, data, 0));
}
private static int TransformBlock16Rounds(ICryptoTransform instance, byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
{
int res = 0;
for (int i = 0; i < 16; ++i)
{
res = instance.TransformBlock(inputBuffer, inputOffset, inputCount, outputBuffer, outputOffset);
}
return inputCount;
}
