public void Given_ValidAESKey_When_MapToXMLPOCO_Then_EncodingHelperClassMustBeused()
{
// Arrange
var key = new AesKey()
{
Iv = RandomByteArrayUtils.CreateRandomByteArray(512),
Key = RandomByteArrayUtils.CreateRandomByteArray(1024),
};
var ivMapsTo = "myIVString";
var keyMapsTo = "myIVString";
var converter = new Mock <IKeyDetailsPersistConverter>(MockBehavior.Strict);
converter.Setup(c => c.Encode(key.Iv)).Returns(ivMapsTo);
converter.Setup(c => c.Encode(key.Key)).Returns(keyMapsTo);
// Act
var aesKeyToXmlMapper = new AesKeyToXmlMapper(converter.Object);
var xmlPoco = new EnvCryptKey();
aesKeyToXmlMapper.Map(key, xmlPoco);
// Assert
xmlPoco.Aes.Should().NotBeNull().And.HaveCount(1);
xmlPoco.Aes[0].Iv.Should().Be(ivMapsTo);
xmlPoco.Aes[0].Key.Should().Be(keyMapsTo);
converter.Verify(c => c.Encode(key.Iv), Times.Once);
converter.Verify(c => c.Encode(key.Key), Times.Once);
}
public void Given_RandomBinaryData_When_EncodeAndDecode_Then_BinaryDataMustBeUnchanged()
{
// Arrange
var randomData = RandomByteArrayUtils.CreateRandomByteArray(9999);
// Act
var converter = new KeyDetailsPersistConverter();
var result = converter.Decode(converter.Encode(randomData));
// Assert
result.Should().BeEquivalentTo(randomData);
}
public void Given_ValidRSAKey_When_MapToXMLPOCO_Then_EncodingHelperClassMustBeused()
{
// Arrange
var key = new RsaKey(new RSAParameters()
{
D = RandomByteArrayUtils.CreateRandomByteArray(10),
DP = RandomByteArrayUtils.CreateRandomByteArray(11),
DQ = RandomByteArrayUtils.CreateRandomByteArray(12),
Exponent = RandomByteArrayUtils.CreateRandomByteArray(13),
Modulus = RandomByteArrayUtils.CreateRandomByteArray(14),
InverseQ = RandomByteArrayUtils.CreateRandomByteArray(15),
P = RandomByteArrayUtils.CreateRandomByteArray(16),
Q = RandomByteArrayUtils.CreateRandomByteArray(17),
}, true);
var converter = new Mock <IKeyDetailsPersistConverter>(MockBehavior.Strict);
converter.Setup(c => c.Encode(key.Key.D)).Returns("d");
converter.Setup(c => c.Encode(key.Key.DP)).Returns("dp");
converter.Setup(c => c.Encode(key.Key.DQ)).Returns("dq");
converter.Setup(c => c.Encode(key.Key.Exponent)).Returns("exponent");
converter.Setup(c => c.Encode(key.Key.Modulus)).Returns("modulus");
converter.Setup(c => c.Encode(key.Key.InverseQ)).Returns("inverseQ");
converter.Setup(c => c.Encode(key.Key.P)).Returns("p");
converter.Setup(c => c.Encode(key.Key.Q)).Returns("q");
// Act
var aesKeyToXmlMapper = new RsaKeyToXmlMapper(converter.Object);
var xmlPoco = new EnvCryptKey();
aesKeyToXmlMapper.Map(key, xmlPoco);
// Assert
xmlPoco.Rsa.Should().NotBeNull().And.HaveCount(1);
xmlPoco.Rsa[0].D.Should().Be("d");
xmlPoco.Rsa[0].Dp.Should().Be("dp");
xmlPoco.Rsa[0].Dq.Should().Be("dq");
xmlPoco.Rsa[0].Exponent.Should().Be("exponent");
xmlPoco.Rsa[0].Modulus.Should().Be("modulus");
xmlPoco.Rsa[0].InverseQ.Should().Be("inverseQ");
xmlPoco.Rsa[0].P.Should().Be("p");
xmlPoco.Rsa[0].Q.Should().Be("q");
converter.Verify(c => c.Encode(key.Key.D), Times.Once);
converter.Verify(c => c.Encode(key.Key.DP), Times.Once);
converter.Verify(c => c.Encode(key.Key.DQ), Times.Once);
converter.Verify(c => c.Encode(key.Key.Exponent), Times.Once);
converter.Verify(c => c.Encode(key.Key.Modulus), Times.Once);
converter.Verify(c => c.Encode(key.Key.InverseQ), Times.Once);
converter.Verify(c => c.Encode(key.Key.P), Times.Once);
converter.Verify(c => c.Encode(key.Key.Q), Times.Once);
}
public void Given_ValidRSAKey_When_PublicKeyParametersChanged_Then_HashCodeIsDifferent()
{
// Arrange
var key1 = new RsaKey(new RSAParameters()
{
Exponent = RandomByteArrayUtils.CreateRandomByteArray(5),
Modulus = RandomByteArrayUtils.CreateRandomByteArray(6),
}, true);
var key2 = new RsaKey(new RSAParameters()
{
Exponent = key1.Key.Exponent,
Modulus = RandomByteArrayUtils.CreateRandomByteArray(7),
}, true);
// Act
// Assert
key1.GetHashCode().Should().NotBe(key2.GetHashCode());
}
public void Given_AnyDataToEncrypt_When_Encrypt_Then_AllDataEncryptedTogether(
[Range(0, 10000, 1000)] int actualKeySize)
{
// Arrange
var algo = new Mock <IEncryptionAlgo <AesKey> >();
var key = new AesKey();
algo.Setup(encryptionAlgo => encryptionAlgo.Encrypt(It.IsAny <byte[]>(), key)).Returns(new byte[1]);
var dataToEncrypt = RandomByteArrayUtils.CreateRandomByteArray(actualKeySize);
// Act
var segEncrypter = new AesSegmentEncryptionAlgo(algo.Object);
segEncrypter.Encrypt(dataToEncrypt, key);
// Assert
algo.Verify(a => a.Encrypt(dataToEncrypt, key), Times.Once());
}
private int SetupMethod(int lengthOfByteArray, int maxSegmentSize, out byte[] toEncrypt, out RsaKey rsaKey,
out Mock <IEncryptionAlgo <RsaKey> > algoMock, out RsaSegmentEncryptionAlgo encrypter)
{
// # of segments created
var expectedArraysInList = (int)Math.Ceiling((double)lengthOfByteArray / maxSegmentSize);
toEncrypt = RandomByteArrayUtils.CreateRandomByteArray(lengthOfByteArray);
rsaKey = new RsaKey(new RSAParameters(), true);
var rsaKeyCopy = rsaKey;
algoMock = new Mock <IEncryptionAlgo <RsaKey> >();
algoMock.Setup(algo => algo.Encrypt(It.IsAny <byte[]>(), rsaKeyCopy)).Returns(new byte[] { 0 });
var maxEncryptionSizeCalcMock = new Mock <IRsaMaxEncryptionCalc>();
maxEncryptionSizeCalcMock.Setup(calc => calc.GetMaxBytesThatCanBeEncrypted(rsaKeyCopy))
.Returns(maxSegmentSize);
encrypter = new RsaSegmentEncryptionAlgo(algoMock.Object, maxEncryptionSizeCalcMock.Object);
return(expectedArraysInList);
}
public void Given_ValidRSAKey_When_PrivateKeyParametersChanged_Then_HashCodeIsTheSame()
{
// Arrange
var key1 = new RsaKey(new RSAParameters()
{
Exponent = RandomByteArrayUtils.CreateRandomByteArray(5),
Modulus = RandomByteArrayUtils.CreateRandomByteArray(5),
}, true);
var key2 = new RsaKey(new RSAParameters()
{
Exponent = key1.Key.Exponent,
Modulus = key1.Key.Modulus,
D = RandomByteArrayUtils.CreateRandomByteArray(5),
DP = RandomByteArrayUtils.CreateRandomByteArray(5),
DQ = RandomByteArrayUtils.CreateRandomByteArray(5),
InverseQ = RandomByteArrayUtils.CreateRandomByteArray(5),
P = RandomByteArrayUtils.CreateRandomByteArray(5),
Q = RandomByteArrayUtils.CreateRandomByteArray(5),
}, true);
// Act
// Assert
key1.GetHashCode().Should().Be(key2.GetHashCode(), "hash code only takes public key parameters into account");
}
