public void EncryptAndDecryptPaddingZeros()
{
Action <byte[]> check = plainText =>
{
byte[] cipherText, newPlainText;
using (var algorithm = new SimpleSymmetricAlgorithm {
Mode = CipherMode.ECB, Padding = PaddingMode.Zeros
})
{
algorithm.GenerateKey();
algorithm.GenerateIV();
InternalEncryptAndDecrypt(algorithm, plainText, out cipherText, out newPlainText);
}
for (int i = 0; i < plainText.Length; i++)
{
Assert.Equal(plainText[i], newPlainText[i]);
}
for (int i = plainText.Length; i < newPlainText.Length; i++)
{
Assert.Equal(0, newPlainText[i]);
}
};
foreach (var plainText in BlockSizeMultiplePlainTexts.Union(BlockSizeNonMultiplePlainTexts))
{
check(plainText);
}
}
public void EncryptAndDecryptPaddingNone()
{
Action <byte[]> check = plainText =>
{
byte[] cipherText, newPlainText;
using (var algorithm = new SimpleSymmetricAlgorithm {
Mode = CipherMode.ECB, Padding = PaddingMode.None
})
{
algorithm.GenerateKey();
algorithm.GenerateIV();
InternalEncryptAndDecrypt(algorithm, plainText, out cipherText, out newPlainText);
}
Assert.Equal(plainText, newPlainText);
};
foreach (var plainText in BlockSizeMultiplePlainTexts)
{
check(plainText);
}
foreach (var plainText in BlockSizeNonMultiplePlainTexts)
{
Assert.Throws <CryptographicException>(() => check(plainText));
}
}
public void TransformBlock_Throws_IfParametersAreInvalid()
{
var inputBuffer = new byte[BlockSizeBytes];
var outputBuffer = new byte[BlockSizeBytes];
var inputOffset = 0;
var inputCount = BlockSizeBytes;
var outputOffset = 0;
using var transform = new SimpleSymmetricAlgorithm();
using var encryptor = transform.CreateEncryptor();
Assert.Throws <ArgumentNullException>(nameof(inputBuffer),
() => encryptor.TransformBlock(null !, inputOffset, inputCount, outputBuffer, outputOffset));
Assert.Throws <ArgumentNullException>(nameof(outputBuffer),
() => encryptor.TransformBlock(inputBuffer, inputOffset, inputCount, null !, outputOffset));
Assert.Throws <ArgumentOutOfRangeException>(nameof(inputOffset),
() => encryptor.TransformBlock(inputBuffer, -1, inputCount, outputBuffer, outputOffset));
Assert.Throws <ArgumentOutOfRangeException>(nameof(outputOffset),
() => encryptor.TransformBlock(inputBuffer, inputOffset, inputCount, outputBuffer, -1));
Assert.Throws <ArgumentOutOfRangeException>(nameof(inputCount),
() => encryptor.TransformBlock(inputBuffer, inputOffset, 0, outputBuffer, outputOffset));
Assert.Throws <ArgumentException>(null,
() => encryptor.TransformBlock(inputBuffer, inputCount, inputCount, outputBuffer, outputOffset));
Assert.Throws <CryptographicException>(
() => encryptor.TransformBlock(inputBuffer, inputOffset, inputCount - 1, outputBuffer, outputOffset));
}
public void EncryptAndDecryptPaddingPKCS7()
{
Action <byte[]> check = plainText =>
{
byte[] cipherText, newPlainText, newPlainTextNoDepad;
using (var algorithm = new SimpleSymmetricAlgorithm {
Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
})
{
algorithm.GenerateKey();
algorithm.GenerateIV();
InternalEncryptAndDecrypt(algorithm, plainText, out cipherText, out newPlainText);
algorithm.Padding = PaddingMode.None;
newPlainTextNoDepad = InternalTransform(algorithm.CreateDecryptor, cipherText);
}
int padCount = newPlainTextNoDepad.Length - newPlainText.Length;
byte[] padding = new byte[padCount];
BlockCopy(newPlainTextNoDepad, newPlainText.Length, padding, 0, padCount);
Assert.Equal(plainText, newPlainText);
for (int i = 0; i < plainText.Length; i++)
{
Assert.Equal(plainText[i], newPlainTextNoDepad[i]);
}
if (padCount > 0)
{
Assert.Equal(padCount, padding[padCount - 1]);
for (int i = 0; i < padCount - 1; i++)
{
Assert.Equal(padCount, padding[i]);
}
}
};
foreach (var plainText in BlockSizeMultiplePlainTexts.Union(BlockSizeNonMultiplePlainTexts))
{
check(plainText);
}
}
public void TransformBlockInvalidArgumentsTest()
{
using (var transform = new SimpleSymmetricAlgorithm())
{
using (var encryptor = transform.CreateEncryptor())
{
Assert.Throws <ArgumentNullException>(() => encryptor.TransformBlock(null, 0, BlockSizeBytes, new byte[BlockSizeBytes], 0));
Assert.Throws <ArgumentNullException>(() => encryptor.TransformBlock(new byte[BlockSizeBytes], 0, BlockSizeBytes, null, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => encryptor.TransformBlock(new byte[BlockSizeBytes], -1, BlockSizeBytes, new byte[BlockSizeBytes], 0));
Assert.Throws <ArgumentOutOfRangeException>(() => encryptor.TransformBlock(new byte[BlockSizeBytes], 0, BlockSizeBytes, new byte[BlockSizeBytes], -1));
Assert.Throws <ArgumentOutOfRangeException>(() => encryptor.TransformBlock(new byte[BlockSizeBytes], 0, 0, new byte[BlockSizeBytes], 0));
Assert.Throws <ArgumentException>(() => encryptor.TransformBlock(new byte[BlockSizeBytes], BlockSizeBytes, BlockSizeBytes, new byte[BlockSizeBytes], 0));
Assert.Throws <CryptographicException>(() => encryptor.TransformBlock(new byte[BlockSizeBytes], 0, BlockSizeBytes - 1, new byte[BlockSizeBytes], 0));
}
}
}
public void CheckLifecycle()
{
var crossPaddingTransformParameters =
from p in PaddingModes
from t in TransformModes
select new { PaddingMode = p, TransformMode = t };
var allSupportedParameters =
from c in SupportedCipherModes
from pt in crossPaddingTransformParameters
select new { CipherMode = c, pt.PaddingMode, pt.TransformMode };
var reqiresIVParameters =
from c in CipherModesReqiresIV
from pt in crossPaddingTransformParameters
select new { CipherMode = c, pt.PaddingMode, pt.TransformMode };
using var algorithm = new SimpleSymmetricAlgorithm();
public void CheckLifecycle()
{
var crossPaddingTransformParameters =
from p in PaddingModes
from t in TransformModes
select new { PaddingMode = p, TransformMode = t };
var allSupportedParameters =
from c in SupportedCipherModes
from pt in crossPaddingTransformParameters
select new { CipherMode = c, PaddingMode = pt.PaddingMode, TransformMode = pt.TransformMode };
var reqiresIVParameters =
from c in CipherModesReqiresIV
from pt in crossPaddingTransformParameters
select new { CipherMode = c, PaddingMode = pt.PaddingMode, TransformMode = pt.TransformMode };
using (var algorithm = new SimpleSymmetricAlgorithm())
{
Action <Func <SimpleSymmetricTransform> > checkValid = factory =>
{
var transform = factory();
using (transform)
{
Assert.False(transform.DisposeCalled);
}
Assert.True(transform.DisposeCalled);
};
Action <Type, Func <SimpleSymmetricTransform> > checkInvalid =
(expectedExceptionType, factory) => Assert.Throws(expectedExceptionType, factory);
// All ctor parameters (without CTS)
foreach (var p in allSupportedParameters)
{
checkValid(() =>
new SimpleSymmetricTransform(algorithm.Key, algorithm.IV, algorithm.BlockSize, CipherMode.ECB, p.PaddingMode, p.TransformMode));
}
// IV is null (ECB)
foreach (var p in crossPaddingTransformParameters)
{
checkValid(() =>
new SimpleSymmetricTransform(algorithm.Key, null, algorithm.BlockSize, CipherMode.ECB, p.PaddingMode, p.TransformMode));
}
// CTS is invalid
foreach (var p in crossPaddingTransformParameters)
{
checkInvalid(typeof(CryptographicException), () =>
new SimpleSymmetricTransform(algorithm.Key, algorithm.IV, algorithm.BlockSize, CipherMode.CTS, p.PaddingMode, p.TransformMode));
}
// Key is null
foreach (var p in allSupportedParameters)
{
checkInvalid(typeof(ArgumentNullException), () =>
new SimpleSymmetricTransform(null, algorithm.IV, algorithm.BlockSize, p.CipherMode, p.PaddingMode, p.TransformMode));
}
// IV is null (CBC, CFB, OFB)
foreach (var p in reqiresIVParameters)
{
checkInvalid(typeof(ArgumentNullException), () =>
new SimpleSymmetricTransform(algorithm.Key, null, algorithm.BlockSize, p.CipherMode, p.PaddingMode, p.TransformMode));
}
}
}
