public void RSASignVerifyData(RSACryptoServiceProviderProxyTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.RSASignVerifyData", theoryData);
try
{
var proxy = new RSACryptoServiceProviderProxy(theoryData.RsaCryptoServiceProvider);
var signatureProxy = proxy.SignData(theoryData.Input, theoryData.HashAlgorithm);
var signatureRsa = theoryData.RsaCryptoServiceProvider.SignData(theoryData.Input, theoryData.HashAlgorithm);
IdentityComparer.AreBytesEqual(signatureProxy, signatureRsa, context);
if (!proxy.VerifyData(theoryData.Input, theoryData.HashAlgorithm, signatureRsa))
{
context.AddDiff("!proxy.VerifyData(theoryData.Input, theoryData.HashAlgorithm, signatureRsa)");
}
if (!theoryData.RsaCryptoServiceProvider.VerifyData(theoryData.Input, theoryData.HashAlgorithm, signatureProxy))
{
context.AddDiff("!theoryData.RsaCryptoServiceProvider.VerifyData(theoryData.Input, theoryData.HashAlgorithm, signatureProxy)");
}
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
private void SignData(RSACryptoServiceProviderProxy rsaCspProxy, ExpectedException ee)
{
try
{
rsaCspProxy.SignData(input, _hashAlgorithm);
ee.ProcessNoException();
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RsaKeyWrapProvider"/> class used for wrap key and unwrap key.
/// <param name="key">The <see cref="SecurityKey"/> that will be used for crypto operations.</param>
/// <param name="algorithm">The KeyWrap algorithm to apply.</param>
/// <param name="willUnwrap">Whether this <see cref="RsaKeyWrapProvider"/> is required to create decrypts then set this to true.</param>
/// <exception cref="ArgumentNullException">'key' is null.</exception>
/// <exception cref="ArgumentNullException">'algorithm' is null.</exception>
/// <exception cref="ArgumentException">The keysize doesn't match the algorithm.</exception>
/// <exception cref="ArgumentException">If <see cref="SecurityKey"/> and algorithm pair are not supported.</exception>
/// <exception cref="InvalidOperationException">Failed to create RSA algorithm with provided key and algorithm.</exception>
/// </summary>
public RsaKeyWrapProvider(SecurityKey key, string algorithm, bool willUnwrap)
{
if (key == null)
{
throw LogHelper.LogArgumentNullException(nameof(key));
}
if (string.IsNullOrEmpty(algorithm))
{
throw LogHelper.LogArgumentNullException(nameof(algorithm));
}
if (!IsSupportedAlgorithm(key, algorithm))
{
throw LogHelper.LogExceptionMessage(new ArgumentException(string.Format(CultureInfo.InvariantCulture, LogMessages.IDX10661, algorithm, key)));
}
Algorithm = algorithm;
Key = key;
var rsaAlgorithm = Utility.ResolveRsaAlgorithm(key, algorithm, willUnwrap);
#if NETSTANDARD1_4
if (rsaAlgorithm != null && rsaAlgorithm.rsa != null)
{
_rsa = rsaAlgorithm.rsa;
_disposeRsa = rsaAlgorithm.dispose;
return;
}
#else
if (rsaAlgorithm != null)
{
if (rsaAlgorithm.rsaCryptoServiceProvider != null)
{
_rsaCryptoServiceProvider = rsaAlgorithm.rsaCryptoServiceProvider;
_disposeRsa = rsaAlgorithm.dispose;
return;
}
if (rsaAlgorithm.rsaCryptoServiceProviderProxy != null)
{
_rsaCryptoServiceProviderProxy = rsaAlgorithm.rsaCryptoServiceProviderProxy;
_disposeRsa = rsaAlgorithm.dispose;
return;
}
}
#endif
throw LogHelper.LogExceptionMessage(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, LogMessages.IDX10661, algorithm, key)));
}
private void SignData(RSACryptoServiceProviderProxy rsaCspProxy, ExpectedException ee)
{
try
{
#if NETCOREAPP1_0
rsaCspProxy.SignData(input, _hashAlgorithm.Name);
#else
rsaCspProxy.SignData(input, _hashAlgorithm);
#endif
ee.ProcessNoException();
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
}
public void RSADecryptValue(RSACryptoServiceProviderProxyTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.RSADecryptValue", theoryData);
try
{
var proxy = new RSACryptoServiceProviderProxy(theoryData.RsaCryptoServiceProvider);
proxy.DecryptValue(theoryData.Input);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
public void RSAVerifyData(RSACryptoServiceProviderProxyTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.RSAVerifyData", theoryData);
try
{
var proxy = new RSACryptoServiceProviderProxy(theoryData.RsaCryptoServiceProvider);
proxy.VerifyData(theoryData.Input, theoryData.HashAlgorithm, theoryData.Signature);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
private void ResolveAsymmetricAlgorithm(SecurityKey key, string algorithm, bool willCreateSignatures)
{
if (key == null)
{
throw LogHelper.LogArgumentNullException("key");
}
if (string.IsNullOrWhiteSpace(algorithm))
{
throw LogHelper.LogArgumentNullException("algorithm");
}
_hashAlgorithm = GetHashAlgorithmString(algorithm);
RsaAlgorithm rsaAlgorithm = Utility.ResolveRsaAlgorithm(key, algorithm, willCreateSignatures);
if (rsaAlgorithm != null)
{
if (rsaAlgorithm.rsaCryptoServiceProvider != null)
{
_rsaCryptoServiceProvider = rsaAlgorithm.rsaCryptoServiceProvider;
_disposeRsa = rsaAlgorithm.dispose;
return;
}
else if (rsaAlgorithm.rsaCryptoServiceProviderProxy != null)
{
_rsaCryptoServiceProviderProxy = rsaAlgorithm.rsaCryptoServiceProviderProxy;
_disposeRsa = rsaAlgorithm.dispose;
return;
}
else
{
throw LogHelper.LogExceptionMessage(new ArgumentOutOfRangeException(nameof(key), String.Format(CultureInfo.InvariantCulture, LogMessages.IDX10641, key)));
}
}
ECDsaAlgorithm ecdsaAlgorithm = Utility.ResolveECDsaAlgorithm(key, algorithm, willCreateSignatures);
if (ecdsaAlgorithm != null && ecdsaAlgorithm.ecdsaCng != null)
{
_ecdsa = ecdsaAlgorithm.ecdsaCng;
_ecdsa.HashAlgorithm = new CngAlgorithm(_hashAlgorithm);
_disposeEcdsa = ecdsaAlgorithm.dispose;
return;
}
throw LogHelper.LogExceptionMessage(new ArgumentOutOfRangeException(nameof(key), String.Format(CultureInfo.InvariantCulture, LogMessages.IDX10641, key)));
}
public void RSAEncryptDecryptValue(RSACryptoServiceProviderProxyTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.RSAEncryptDecryptValue", theoryData);
try
{
var proxy = new RSACryptoServiceProviderProxy(theoryData.RsaCryptoServiceProvider);
var cipherTextProxy = proxy.EncryptValue(theoryData.Input);
var cipherTextRsa = theoryData.RsaCryptoServiceProvider.EncryptValue(theoryData.Input);
IdentityComparer.AreBytesEqual(
proxy.DecryptValue(cipherTextProxy),
theoryData.RsaCryptoServiceProvider.DecryptValue(cipherTextRsa),
context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}