public void ToBuffer_ShouldReturnValidResult()
{
// Arrange.
var cascadingKeyLengthInBytes = 1666;
var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
var firstLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var secondLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var thirdLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var fourthLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
using (var target = CascadingSymmetricKey.New(derivationMode, firstLayerAlgorithm, secondLayerAlgorithm, thirdLayerAlgorithm, fourthLayerAlgorithm))
{
// Act.
using (var buffer = target.ToBuffer())
{
buffer.Access(plaintext =>
{
// Assert.
plaintext.Should().NotBeNullOrEmpty();
plaintext.Length.Should().Be(cascadingKeyLengthInBytes);
plaintext.Count(value => value == 0x00).Should().NotBe(plaintext.Length);
});
}
}
}
private static void Encrypt_ShouldBeReversible_UsingCascadingSymmetricKey(CascadingSymmetricKey key)
{
using (var randomnessProvider = RandomNumberGenerator.Create())
{
// Arrange.
var target = new SymmetricStringProcessor(randomnessProvider);
var plaintextObject = "䆟`ಮ䷆ʘ‣⦸⏹ⰄͶa✰ṁ亡Zᨖ0༂⽔9㗰";
// Act.
var ciphertextResult = target.Encrypt(plaintextObject, key);
// Assert.
ciphertextResult.Should().NotBeNullOrEmpty();
ciphertextResult.Count(value => value == 0x00).Should().NotBe(ciphertextResult.Length);
// Act.
var plaintextResult = target.Decrypt(ciphertextResult, key);
// Assert.
plaintextResult.Should().NotBeNullOrEmpty();
plaintextResult.Length.Should().Be(plaintextObject.Length);
plaintextResult.Count(value => value == 0x00).Should().NotBe(plaintextResult.Length);
for (var i = 0; i < plaintextResult.Length; i++)
{
// Assert.
plaintextResult[i].Should().Be(plaintextObject[i]);
}
}
}
private static void Encrypt_ShouldBeReversible_UsingCascadingSymmetricKey_WithTwoLayers(SecureSymmetricKeyDerivationMode derivationMode, SymmetricAlgorithmSpecification firstLayerAlgorithm, SymmetricAlgorithmSpecification secondLayerAlgorithm)
{
using (var key = CascadingSymmetricKey.New(derivationMode, firstLayerAlgorithm, secondLayerAlgorithm))
{
Encrypt_ShouldBeReversible_UsingCascadingSymmetricKey(key);
}
}
/* =================================================================================================================
* Twofish and Threefish are out-of-scope for MVP-01.
* =================================================================================================================
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForThreefish1024Cbc_InTruncationMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Threefish1024Cbc;
* var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForThreefish1024Cbc_InXorLayeringMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Threefish1024Cbc;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayering;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForThreefish1024Cbc_InXorLayeringWithSubstitutionMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Threefish1024Cbc;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayeringWithSubstitution;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForThreefish256Ecb_InTruncationMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Threefish256Ecb;
* var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForThreefish256Ecb_InXorLayeringMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Threefish256Ecb;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayering;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForThreefish256Ecb_InXorLayeringWithSubstitutionMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Threefish256Ecb;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayeringWithSubstitution;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForTwofish128Cbc_InTruncationMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Twofish128Cbc;
* var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForTwofish128Cbc_InXorLayeringMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Twofish128Cbc;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayering;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForTwofish128Cbc_InXorLayeringWithSubstitutionMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Twofish128Cbc;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayeringWithSubstitution;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForTwofish192Ecb_InTruncationMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Twofish192Ecb;
* var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForTwofish192Ecb_InXorLayeringMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Twofish192Ecb;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayering;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }
*
* [TestMethod]
* public void Encrypt_ShouldBeReversible_UsingSecureSymmetricKey_ForTwofish192Ecb_InXorLayeringWithSubstitutionMode()
* {
* // Arrange.
* var algorithm = SymmetricAlgorithmSpecification.Twofish192Ecb;
* var derivationMode = SecureSymmetricKeyDerivationMode.XorLayeringWithSubstitution;
*
* // Assert.
* Encrypt_ShouldBeReversible_UsingSecureSymmetricKey(algorithm, derivationMode);
* }*/
private static void Encrypt_ShouldBeReversible_UsingCascadingSymmetricKey(CascadingSymmetricKey key)
{
using (var randomnessProvider = RandomNumberGenerator.Create())
{
// Arrange.
var binarySerializer = new BinaryPassThroughSerializer();
var target = new SymmetricProcessor <Byte[]>(randomnessProvider, binarySerializer);
var plaintextObject = new Byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 };
// Act.
var ciphertextResult = target.Encrypt(plaintextObject, key);
// Assert.
ciphertextResult.Should().NotBeNullOrEmpty();
ciphertextResult.Count(value => value == 0x00).Should().NotBe(ciphertextResult.Length);
// Act.
var plaintextResult = target.Decrypt(ciphertextResult, key);
// Assert.
plaintextResult.Should().NotBeNullOrEmpty();
plaintextResult.Length.Should().Be(plaintextObject.Length);
plaintextResult.Count(value => value == 0x00).Should().NotBe(plaintextResult.Length);
for (var i = 0; i < plaintextResult.Length; i++)
{
// Assert.
plaintextResult[i].Should().Be(plaintextObject[i]);
}
}
}
public void Encrypt_ShouldBeReversible_UsingCascadingSymmetricKey_WithTwoLayers()
{
// Arrange.
var derivationMode = SecureSymmetricKeyDerivationMode.XorLayering;
var firstLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var secondLayerAlgorithm = SymmetricAlgorithmSpecification.Aes256Cbc;
using (var key = CascadingSymmetricKey.New(derivationMode, firstLayerAlgorithm, secondLayerAlgorithm))
{
// Assert.
Encrypt_ShouldBeReversible_UsingCascadingSymmetricKey(key);
}
}
public void ToBuffer_ShouldBeReversible_WithTwoLayers()
{
// Arrange.
var depth = 2;
var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
var firstLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var secondLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
using (var target = CascadingSymmetricKey.New(derivationMode, firstLayerAlgorithm, secondLayerAlgorithm))
{
// Assert.
ToBuffer_ShouldBeReversible(target, depth);
}
}
public void New_ShouldReturnValidKey_ForValidArguments()
{
// Arrange.
var derivationMode = SecureSymmetricKeyDerivationMode.Truncation;
var firstLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var secondLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var thirdLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var fourthLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
using (var target = CascadingSymmetricKey.New(derivationMode, firstLayerAlgorithm, secondLayerAlgorithm, thirdLayerAlgorithm, fourthLayerAlgorithm))
{
// Assert.
target.Should().NotBeNull();
}
}
public void New_ShouldRaiseArgumentOutOfRangeException_ForUnspecifiedDerivationMode()
{
// Arrange.
var derivationMode = SecureSymmetricKeyDerivationMode.Unspecified;
var firstLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var secondLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var thirdLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
var fourthLayerAlgorithm = SymmetricAlgorithmSpecification.Aes128Cbc;
// Act.
var action = new Action(() =>
{
using (var target = CascadingSymmetricKey.New(derivationMode, firstLayerAlgorithm, secondLayerAlgorithm, thirdLayerAlgorithm, fourthLayerAlgorithm))
{
return;
}
});
// Assert.
action.Should().Throw <ArgumentOutOfRangeException>();
}
private static void ToBuffer_ShouldBeReversible(CascadingSymmetricKey target, Int32 depth)
{
using (var randomnessProvider = RandomNumberGenerator.Create())
{
// Arrange.
var processor = new SymmetricStringProcessor(randomnessProvider);
var plaintextObject = "䆟`ಮ䷆ʘ‣⦸⏹ⰄͶa✰ṁ亡Zᨖ0༂⽔9㗰";
var ciphertext = processor.Encrypt(plaintextObject, target);
// Act.
using (var buffer = target.ToBuffer())
{
using (var parityKey = CascadingSymmetricKey.FromBuffer(buffer))
{
// Arrange.
var result = processor.Decrypt(ciphertext, parityKey);
// Assert.
result.Should().Be(plaintextObject);
}
}
}
}