Add an RSAFactory to the RSA test suite.

bartonjs · bartonjs · commit bd6672eab428 · 2015-07-28T09:07:11.000-07:00
Implementors will need to define an IRSAProvider and assign it via a field initializer (s_provider) for the RSAFactory class.  This was chosen over RSA.Create() for two reasons:
1) RSA.Create() isn't part of the contract yet.
2) There will be 3 RSA implementations, but only two of them capable of being returned by RSA.Create(), so an alternate factory is required for long-term support of CAPI testing.
diff --git a/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/EncryptDecrypt.cs b/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/EncryptDecrypt.cs
@@ -32,10 +32,10 @@ public static void DecryptSavedAnswer()
 
             byte[] output;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA1024Params);
-                output = rsa.Decrypt(cipherBytes, true);
+                output = rsa.Decrypt(cipherBytes, RSAEncryptionPadding.OaepSHA1);
             }
 
             Assert.Equal(TestData.HelloBytes, output);
@@ -66,10 +66,10 @@ public static void DecryptSavedAnswerUnusualExponent()
 
             byte[] output;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.UnusualExponentParameters);
-                output = rsa.Decrypt(cipherBytes, true);
+                output = rsa.Decrypt(cipherBytes, RSAEncryptionPadding.OaepSHA1);
             }
 
             Assert.Equal(TestData.HelloBytes, output);
@@ -81,10 +81,10 @@ public static void RsaCryptRoundtrip()
             byte[] crypt;
             byte[] output;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
-                crypt = rsa.Encrypt(TestData.HelloBytes, true);
-                output = rsa.Decrypt(crypt, true);
+                crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);
+                output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);
             }
 
             Assert.NotEqual(crypt, output);
@@ -96,13 +96,13 @@ public static void RsaDecryptAfterExport()
         {
             byte[] output;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
-                byte[] crypt = rsa.Encrypt(TestData.HelloBytes, true);
+                byte[] crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);
 
                 // Export the key, this should not clear/destroy the key.
                 RSAParameters ignored = rsa.ExportParameters(true);
-                output = rsa.Decrypt(crypt, true);
+                output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);
             }
 
             Assert.Equal(TestData.HelloBytes, output);
@@ -113,7 +113,7 @@ public static void LargeKeyCryptRoundtrip()
         {
             byte[] output;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 try
                 {
@@ -125,11 +125,11 @@ public static void LargeKeyCryptRoundtrip()
                     return;
                 }
 
-                byte[] crypt = rsa.Encrypt(TestData.HelloBytes, true);
+                byte[] crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);
 
                 Assert.Equal(rsa.KeySize, crypt.Length * 8);
 
-                output = rsa.Decrypt(crypt, true);
+                output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);
             }
 
             Assert.Equal(TestData.HelloBytes, output);
@@ -141,12 +141,12 @@ public static void UnusualExponentCryptRoundtrip()
             byte[] crypt;
             byte[] output;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.UnusualExponentParameters);
 
-                crypt = rsa.Encrypt(TestData.HelloBytes, true);
-                output = rsa.Decrypt(crypt, true);
+                crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);
+                output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);
             }
 
             Assert.NotEqual(crypt, output);
diff --git a/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/ImportExport.cs b/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/ImportExport.cs
@@ -14,7 +14,7 @@ public static void ExportAutoKey()
             RSAParameters publicParams;
             int keySize;
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 keySize = rsa.KeySize;
 
@@ -53,7 +53,7 @@ public static void PaddedExport()
             RSAParameters diminishedDPParamaters = TestData.DiminishedDPParamaters;
             RSAParameters exported;
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(diminishedDPParamaters);
                 exported = rsa.ExportParameters(true);
@@ -69,7 +69,7 @@ public static void LargeKeyImportExport()
         {
             RSAParameters imported = TestData.RSA16384Params;
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 try
                 {
@@ -106,7 +106,7 @@ public static void UnusualExponentImportExport()
             RSAParameters unusualExponentParameters = TestData.UnusualExponentParameters;
             RSAParameters exported;
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(unusualExponentParameters);
                 exported = rsa.ExportParameters(true);
@@ -120,7 +120,7 @@ public static void UnusualExponentImportExport()
         [Fact]
         public static void ImportReset()
         {
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 RSAParameters exported = rsa.ExportParameters(true);
                 RSAParameters imported;
@@ -152,7 +152,7 @@ public static void MultiExport()
         {
             RSAParameters imported = TestData.RSA1024Params;
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(imported);
 
@@ -187,7 +187,7 @@ public static void PublicOnlyPrivateExport()
                 Exponent = TestData.RSA1024Params.Exponent,
             };
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(imported);
                 Assert.Throws<CryptographicException>(() => rsa.ExportParameters(true));
@@ -202,7 +202,7 @@ public static void ImportNoExponent()
                 Modulus = TestData.RSA1024Params.Modulus,
             };
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 Assert.Throws<CryptographicException>(() => rsa.ImportParameters(imported));
             }
@@ -216,7 +216,7 @@ public static void ImportNoModulus()
                 Exponent = TestData.RSA1024Params.Exponent,
             };
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 Assert.Throws<CryptographicException>(() => rsa.ImportParameters(imported));
             }
@@ -230,7 +230,7 @@ public static void ImportNoDP()
             RSAParameters imported = TestData.RSA1024Params;
             imported.DP = null;
 
-            using (RSA rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 Assert.Throws<CryptographicException>(() => rsa.ImportParameters(imported));
             }
diff --git a/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/KeyGeneration.cs b/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/KeyGeneration.cs
@@ -46,12 +46,12 @@ private static void GenerateKey(Func<RSA, int> getSize)
         {
             int keySize;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 keySize = getSize(rsa);
             }
 
-            using (var rsa = new RSACryptoServiceProvider(keySize))
+            using (RSA rsa = RSAFactory.Create(keySize))
             {
                 Assert.Equal(keySize, rsa.KeySize);
 
diff --git a/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/RSAFactory.cs b/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/RSAFactory.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace System.Security.Cryptography.Rsa.Tests
+{
+    public interface IRSAProvider
+    {
+        RSA Create();
+        RSA Create(int keySize);
+    }
+
+    public static partial class RSAFactory
+    {
+        public static RSA Create()
+        {
+            return s_provider.Create();
+        }
+
+        public static RSA Create(int keySize)
+        {
+            return s_provider.Create(keySize);
+        }
+    }
+}
diff --git a/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/SignVerify.cs b/src/Common/tests/Cryptography/AlgorithmImplementations/RSA/SignVerify.cs
@@ -1,7 +1,6 @@
 ﻿// Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using Test.IO.Streams;
@@ -147,10 +146,10 @@ public static void ExpectSignature_SHA256_1024_Stream()
             byte[] signature;
 
             using (Stream stream = new PositionValueStream(10))
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA1024Params);
-                signature = rsa.SignData(stream, "SHA256");
+                signature = rsa.SignData(stream, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
             }
 
             Assert.Equal(expectedSignature, signature);
@@ -287,11 +286,11 @@ public static void SignAndVerify_SHA256_1024()
         [Fact]
         public static void NegativeVerify_WrongAlgorithm()
         {
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA2048Params);
-                byte[] signature = rsa.SignData(TestData.HelloBytes, "SHA1");
-                bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, "SHA256", signature);
+                byte[] signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
+                bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
 
                 Assert.False(signatureMatched);
             }
@@ -300,27 +299,27 @@ public static void NegativeVerify_WrongAlgorithm()
         [Fact]
         public static void NegativeVerify_WrongSignature()
         {
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA2048Params);
-                byte[] signature = rsa.SignData(TestData.HelloBytes, "SHA1");
+                byte[] signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
 
                 // Invalidate the signature.
                 signature[0] = (byte)~signature[0];
 
-                bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, "SHA1", signature);
+                bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
                 Assert.False(signatureMatched);
             }
         }
 
         [Fact]
         public static void NegativeVerify_TamperedData()
         {
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA2048Params);
-                byte[] signature = rsa.SignData(TestData.HelloBytes, "SHA1");
-                bool signatureMatched = rsa.VerifyData(Array.Empty<byte>(), "SHA1", signature);
+                byte[] signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
+                bool signatureMatched = rsa.VerifyData(Array.Empty<byte>(), signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
                 Assert.False(signatureMatched);
             }
         }
@@ -330,16 +329,16 @@ public static void NegativeVerify_BadKeysize()
         {
             byte[] signature;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA2048Params);
-                signature = rsa.SignData(TestData.HelloBytes, "SHA1");
+                signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
             }
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(TestData.RSA1024Params);
-                bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, "SHA1", signature);
+                bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
 
                 Assert.False(signatureMatched);
             }
@@ -619,10 +618,10 @@ private static void ExpectSignature(
             // the signature is deterministic, so we can safely verify it here.
             byte[] signature;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(rsaParameters);
-                signature = rsa.SignData(data, hashAlgorithmName);
+                signature = rsa.SignData(data, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
             }
 
             Assert.Equal(expectedSignature, signature);
@@ -640,10 +639,10 @@ private static void ExpectHashSignature(
             // the signature is deterministic, so we can safely verify it here.
             byte[] signature;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(rsaParameters);
-                signature = rsa.SignHash(dataHash, hashAlgorithmName);
+                signature = rsa.SignHash(dataHash, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
             }
 
             Assert.Equal(expectedSignature, signature);
@@ -663,10 +662,10 @@ private static void VerifySignature(
 
             bool signatureMatched;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(publicOnly);
-                signatureMatched = rsa.VerifyData(data, hashAlgorithmName, signature);
+                signatureMatched = rsa.VerifyData(data, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
             }
 
             Assert.True(signatureMatched);
@@ -686,22 +685,22 @@ private static void VerifyHashSignature(
 
             bool signatureMatched;
 
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(publicOnly);
-                signatureMatched = rsa.VerifyHash(dataHash, hashAlgorithmName, signature);
+                signatureMatched = rsa.VerifyHash(dataHash, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
             }
 
             Assert.True(signatureMatched);
         }
 
         private static void SignAndVerify(byte[] data, string hashAlgorithmName, RSAParameters rsaParameters)
         {
-            using (var rsa = new RSACryptoServiceProvider())
+            using (RSA rsa = RSAFactory.Create())
             {
                 rsa.ImportParameters(rsaParameters);
-                byte[] signature = rsa.SignData(data, hashAlgorithmName);
-                bool signatureMatched = rsa.VerifyData(data, hashAlgorithmName, signature);
+                byte[] signature = rsa.SignData(data, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
+                bool signatureMatched = rsa.VerifyData(data, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
                 Assert.True(signatureMatched);
             }
         }
diff --git a/src/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderProvider.cs b/src/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderProvider.cs
diff --git a/src/System.Security.Cryptography.Csp/tests/System.Security.Cryptography.Csp.Tests.csproj b/src/System.Security.Cryptography.Csp/tests/System.Security.Cryptography.Csp.Tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -32,10 +32,10 @@ public static void DecryptSavedAnswer()`
`32`	`32`
`33`	`33`	`byte[] output;`
`34`	`34`
`35`		`- using (var rsa = new RSACryptoServiceProvider())`
	`35`	`+ using (RSA rsa = RSAFactory.Create())`
`36`	`36`	`{`
`37`	`37`	`rsa.ImportParameters(TestData.RSA1024Params);`
`38`		`- output = rsa.Decrypt(cipherBytes, true);`
	`38`	`+ output = rsa.Decrypt(cipherBytes, RSAEncryptionPadding.OaepSHA1);`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`Assert.Equal(TestData.HelloBytes, output);`
`@@ -66,10 +66,10 @@ public static void DecryptSavedAnswerUnusualExponent()`
`66`	`66`
`67`	`67`	`byte[] output;`
`68`	`68`
`69`		`- using (var rsa = new RSACryptoServiceProvider())`
	`69`	`+ using (RSA rsa = RSAFactory.Create())`
`70`	`70`	`{`
`71`	`71`	`rsa.ImportParameters(TestData.UnusualExponentParameters);`
`72`		`- output = rsa.Decrypt(cipherBytes, true);`
	`72`	`+ output = rsa.Decrypt(cipherBytes, RSAEncryptionPadding.OaepSHA1);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`Assert.Equal(TestData.HelloBytes, output);`
`@@ -81,10 +81,10 @@ public static void RsaCryptRoundtrip()`
`81`	`81`	`byte[] crypt;`
`82`	`82`	`byte[] output;`
`83`	`83`
`84`		`- using (var rsa = new RSACryptoServiceProvider())`
	`84`	`+ using (RSA rsa = RSAFactory.Create())`
`85`	`85`	`{`
`86`		`- crypt = rsa.Encrypt(TestData.HelloBytes, true);`
`87`		`- output = rsa.Decrypt(crypt, true);`
	`86`	`+ crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);`
	`87`	`+ output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`Assert.NotEqual(crypt, output);`
`@@ -96,13 +96,13 @@ public static void RsaDecryptAfterExport()`
`96`	`96`	`{`
`97`	`97`	`byte[] output;`
`98`	`98`
`99`		`- using (var rsa = new RSACryptoServiceProvider())`
	`99`	`+ using (RSA rsa = RSAFactory.Create())`
`100`	`100`	`{`
`101`		`- byte[] crypt = rsa.Encrypt(TestData.HelloBytes, true);`
	`101`	`+ byte[] crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);`
`102`	`102`
`103`	`103`	`// Export the key, this should not clear/destroy the key.`
`104`	`104`	`RSAParameters ignored = rsa.ExportParameters(true);`
`105`		`- output = rsa.Decrypt(crypt, true);`
	`105`	`+ output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`Assert.Equal(TestData.HelloBytes, output);`
`@@ -113,7 +113,7 @@ public static void LargeKeyCryptRoundtrip()`
`113`	`113`	`{`
`114`	`114`	`byte[] output;`
`115`	`115`
`116`		`- using (var rsa = new RSACryptoServiceProvider())`
	`116`	`+ using (RSA rsa = RSAFactory.Create())`
`117`	`117`	`{`
`118`	`118`	`try`
`119`	`119`	`{`
`@@ -125,11 +125,11 @@ public static void LargeKeyCryptRoundtrip()`
`125`	`125`	`return;`
`126`	`126`	`}`
`127`	`127`
`128`		`- byte[] crypt = rsa.Encrypt(TestData.HelloBytes, true);`
	`128`	`+ byte[] crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);`
`129`	`129`
`130`	`130`	`Assert.Equal(rsa.KeySize, crypt.Length * 8);`
`131`	`131`
`132`		`- output = rsa.Decrypt(crypt, true);`
	`132`	`+ output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`Assert.Equal(TestData.HelloBytes, output);`
`@@ -141,12 +141,12 @@ public static void UnusualExponentCryptRoundtrip()`
`141`	`141`	`byte[] crypt;`
`142`	`142`	`byte[] output;`
`143`	`143`
`144`		`- using (var rsa = new RSACryptoServiceProvider())`
	`144`	`+ using (RSA rsa = RSAFactory.Create())`
`145`	`145`	`{`
`146`	`146`	`rsa.ImportParameters(TestData.UnusualExponentParameters);`
`147`	`147`
`148`		`- crypt = rsa.Encrypt(TestData.HelloBytes, true);`
`149`		`- output = rsa.Decrypt(crypt, true);`
	`148`	`+ crypt = rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.OaepSHA1);`
	`149`	`+ output = rsa.Decrypt(crypt, RSAEncryptionPadding.OaepSHA1);`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`Assert.NotEqual(crypt, output);`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public static void ExportAutoKey()`
`14`	`14`	`RSAParameters publicParams;`
`15`	`15`	`int keySize;`
`16`	`16`
`17`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`17`	`+ using (RSA rsa = RSAFactory.Create())`
`18`	`18`	`{`
`19`	`19`	`keySize = rsa.KeySize;`
`20`	`20`
`@@ -53,7 +53,7 @@ public static void PaddedExport()`
`53`	`53`	`RSAParameters diminishedDPParamaters = TestData.DiminishedDPParamaters;`
`54`	`54`	`RSAParameters exported;`
`55`	`55`
`56`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`56`	`+ using (RSA rsa = RSAFactory.Create())`
`57`	`57`	`{`
`58`	`58`	`rsa.ImportParameters(diminishedDPParamaters);`
`59`	`59`	`exported = rsa.ExportParameters(true);`
`@@ -69,7 +69,7 @@ public static void LargeKeyImportExport()`
`69`	`69`	`{`
`70`	`70`	`RSAParameters imported = TestData.RSA16384Params;`
`71`	`71`
`72`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`72`	`+ using (RSA rsa = RSAFactory.Create())`
`73`	`73`	`{`
`74`	`74`	`try`
`75`	`75`	`{`
`@@ -106,7 +106,7 @@ public static void UnusualExponentImportExport()`
`106`	`106`	`RSAParameters unusualExponentParameters = TestData.UnusualExponentParameters;`
`107`	`107`	`RSAParameters exported;`
`108`	`108`
`109`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`109`	`+ using (RSA rsa = RSAFactory.Create())`
`110`	`110`	`{`
`111`	`111`	`rsa.ImportParameters(unusualExponentParameters);`
`112`	`112`	`exported = rsa.ExportParameters(true);`
`@@ -120,7 +120,7 @@ public static void UnusualExponentImportExport()`
`120`	`120`	`[Fact]`
`121`	`121`	`public static void ImportReset()`
`122`	`122`	`{`
`123`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`123`	`+ using (RSA rsa = RSAFactory.Create())`
`124`	`124`	`{`
`125`	`125`	`RSAParameters exported = rsa.ExportParameters(true);`
`126`	`126`	`RSAParameters imported;`
`@@ -152,7 +152,7 @@ public static void MultiExport()`
`152`	`152`	`{`
`153`	`153`	`RSAParameters imported = TestData.RSA1024Params;`
`154`	`154`
`155`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`155`	`+ using (RSA rsa = RSAFactory.Create())`
`156`	`156`	`{`
`157`	`157`	`rsa.ImportParameters(imported);`
`158`	`158`
`@@ -187,7 +187,7 @@ public static void PublicOnlyPrivateExport()`
`187`	`187`	`Exponent = TestData.RSA1024Params.Exponent,`
`188`	`188`	`};`
`189`	`189`
`190`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`190`	`+ using (RSA rsa = RSAFactory.Create())`
`191`	`191`	`{`
`192`	`192`	`rsa.ImportParameters(imported);`
`193`	`193`	`Assert.Throws<CryptographicException>(() => rsa.ExportParameters(true));`
`@@ -202,7 +202,7 @@ public static void ImportNoExponent()`
`202`	`202`	`Modulus = TestData.RSA1024Params.Modulus,`
`203`	`203`	`};`
`204`	`204`
`205`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`205`	`+ using (RSA rsa = RSAFactory.Create())`
`206`	`206`	`{`
`207`	`207`	`Assert.Throws<CryptographicException>(() => rsa.ImportParameters(imported));`
`208`	`208`	`}`
`@@ -216,7 +216,7 @@ public static void ImportNoModulus()`
`216`	`216`	`Exponent = TestData.RSA1024Params.Exponent,`
`217`	`217`	`};`
`218`	`218`
`219`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`219`	`+ using (RSA rsa = RSAFactory.Create())`
`220`	`220`	`{`
`221`	`221`	`Assert.Throws<CryptographicException>(() => rsa.ImportParameters(imported));`
`222`	`222`	`}`
`@@ -230,7 +230,7 @@ public static void ImportNoDP()`
`230`	`230`	`RSAParameters imported = TestData.RSA1024Params;`
`231`	`231`	`imported.DP = null;`
`232`	`232`
`233`		`- using (RSA rsa = new RSACryptoServiceProvider())`
	`233`	`+ using (RSA rsa = RSAFactory.Create())`
`234`	`234`	`{`
`235`	`235`	`Assert.Throws<CryptographicException>(() => rsa.ImportParameters(imported));`
`236`	`236`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,12 +46,12 @@ private static void GenerateKey(Func<RSA, int> getSize)`
`46`	`46`	`{`
`47`	`47`	`int keySize;`
`48`	`48`
`49`		`- using (var rsa = new RSACryptoServiceProvider())`
	`49`	`+ using (RSA rsa = RSAFactory.Create())`
`50`	`50`	`{`
`51`	`51`	`keySize = getSize(rsa);`
`52`	`52`	`}`
`53`	`53`
`54`		`- using (var rsa = new RSACryptoServiceProvider(keySize))`
	`54`	`+ using (RSA rsa = RSAFactory.Create(keySize))`
`55`	`55`	`{`
`56`	`56`	`Assert.Equal(keySize, rsa.KeySize);`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`// Copyright (c) Microsoft. All rights reserved.`
`2`	`2`	`// Licensed under the MIT license. See LICENSE file in the project root for full license information.`
`3`	`3`
`4`		`-using System.Collections;`
`5`	`4`	`using System.Collections.Generic;`
`6`	`5`	`using System.IO;`
`7`	`6`	`using Test.IO.Streams;`
`@@ -147,10 +146,10 @@ public static void ExpectSignature_SHA256_1024_Stream()`
`147`	`146`	`byte[] signature;`
`148`	`147`
`149`	`148`	`using (Stream stream = new PositionValueStream(10))`
`150`		`- using (var rsa = new RSACryptoServiceProvider())`
	`149`	`+ using (RSA rsa = RSAFactory.Create())`
`151`	`150`	`{`
`152`	`151`	`rsa.ImportParameters(TestData.RSA1024Params);`
`153`		`- signature = rsa.SignData(stream, "SHA256");`
	`152`	`+ signature = rsa.SignData(stream, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);`
`154`	`153`	`}`
`155`	`154`
`156`	`155`	`Assert.Equal(expectedSignature, signature);`
`@@ -287,11 +286,11 @@ public static void SignAndVerify_SHA256_1024()`
`287`	`286`	`[Fact]`
`288`	`287`	`public static void NegativeVerify_WrongAlgorithm()`
`289`	`288`	`{`
`290`		`- using (var rsa = new RSACryptoServiceProvider())`
	`289`	`+ using (RSA rsa = RSAFactory.Create())`
`291`	`290`	`{`
`292`	`291`	`rsa.ImportParameters(TestData.RSA2048Params);`
`293`		`- byte[] signature = rsa.SignData(TestData.HelloBytes, "SHA1");`
`294`		`- bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, "SHA256", signature);`
	`292`	`+ byte[] signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
	`293`	`+ bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);`
`295`	`294`
`296`	`295`	`Assert.False(signatureMatched);`
`297`	`296`	`}`
`@@ -300,27 +299,27 @@ public static void NegativeVerify_WrongAlgorithm()`
`300`	`299`	`[Fact]`
`301`	`300`	`public static void NegativeVerify_WrongSignature()`
`302`	`301`	`{`
`303`		`- using (var rsa = new RSACryptoServiceProvider())`
	`302`	`+ using (RSA rsa = RSAFactory.Create())`
`304`	`303`	`{`
`305`	`304`	`rsa.ImportParameters(TestData.RSA2048Params);`
`306`		`- byte[] signature = rsa.SignData(TestData.HelloBytes, "SHA1");`
	`305`	`+ byte[] signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
`307`	`306`
`308`	`307`	`// Invalidate the signature.`
`309`	`308`	`signature[0] = (byte)~signature[0];`
`310`	`309`
`311`		`- bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, "SHA1", signature);`
	`310`	`+ bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
`312`	`311`	`Assert.False(signatureMatched);`
`313`	`312`	`}`
`314`	`313`	`}`
`315`	`314`
`316`	`315`	`[Fact]`
`317`	`316`	`public static void NegativeVerify_TamperedData()`
`318`	`317`	`{`
`319`		`- using (var rsa = new RSACryptoServiceProvider())`
	`318`	`+ using (RSA rsa = RSAFactory.Create())`
`320`	`319`	`{`
`321`	`320`	`rsa.ImportParameters(TestData.RSA2048Params);`
`322`		`- byte[] signature = rsa.SignData(TestData.HelloBytes, "SHA1");`
`323`		`- bool signatureMatched = rsa.VerifyData(Array.Empty<byte>(), "SHA1", signature);`
	`321`	`+ byte[] signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
	`322`	`+ bool signatureMatched = rsa.VerifyData(Array.Empty<byte>(), signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
`324`	`323`	`Assert.False(signatureMatched);`
`325`	`324`	`}`
`326`	`325`	`}`
`@@ -330,16 +329,16 @@ public static void NegativeVerify_BadKeysize()`
`330`	`329`	`{`
`331`	`330`	`byte[] signature;`
`332`	`331`
`333`		`- using (var rsa = new RSACryptoServiceProvider())`
	`332`	`+ using (RSA rsa = RSAFactory.Create())`
`334`	`333`	`{`
`335`	`334`	`rsa.ImportParameters(TestData.RSA2048Params);`
`336`		`- signature = rsa.SignData(TestData.HelloBytes, "SHA1");`
	`335`	`+ signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
`337`	`336`	`}`
`338`	`337`
`339`		`- using (var rsa = new RSACryptoServiceProvider())`
	`338`	`+ using (RSA rsa = RSAFactory.Create())`
`340`	`339`	`{`
`341`	`340`	`rsa.ImportParameters(TestData.RSA1024Params);`
`342`		`- bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, "SHA1", signature);`
	`341`	`+ bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);`
`343`	`342`
`344`	`343`	`Assert.False(signatureMatched);`
`345`	`344`	`}`
`@@ -619,10 +618,10 @@ private static void ExpectSignature(`
`619`	`618`	`// the signature is deterministic, so we can safely verify it here.`
`620`	`619`	`byte[] signature;`
`621`	`620`
`622`		`- using (var rsa = new RSACryptoServiceProvider())`
	`621`	`+ using (RSA rsa = RSAFactory.Create())`
`623`	`622`	`{`
`624`	`623`	`rsa.ImportParameters(rsaParameters);`
`625`		`- signature = rsa.SignData(data, hashAlgorithmName);`
	`624`	`+ signature = rsa.SignData(data, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);`
`626`	`625`	`}`
`627`	`626`
`628`	`627`	`Assert.Equal(expectedSignature, signature);`
`@@ -640,10 +639,10 @@ private static void ExpectHashSignature(`
`640`	`639`	`// the signature is deterministic, so we can safely verify it here.`
`641`	`640`	`byte[] signature;`
`642`	`641`
`643`		`- using (var rsa = new RSACryptoServiceProvider())`
	`642`	`+ using (RSA rsa = RSAFactory.Create())`
`644`	`643`	`{`
`645`	`644`	`rsa.ImportParameters(rsaParameters);`
`646`		`- signature = rsa.SignHash(dataHash, hashAlgorithmName);`
	`645`	`+ signature = rsa.SignHash(dataHash, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);`
`647`	`646`	`}`
`648`	`647`
`649`	`648`	`Assert.Equal(expectedSignature, signature);`
`@@ -663,10 +662,10 @@ private static void VerifySignature(`
`663`	`662`
`664`	`663`	`bool signatureMatched;`
`665`	`664`
`666`		`- using (var rsa = new RSACryptoServiceProvider())`
	`665`	`+ using (RSA rsa = RSAFactory.Create())`
`667`	`666`	`{`
`668`	`667`	`rsa.ImportParameters(publicOnly);`
`669`		`- signatureMatched = rsa.VerifyData(data, hashAlgorithmName, signature);`
	`668`	`+ signatureMatched = rsa.VerifyData(data, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);`
`670`	`669`	`}`
`671`	`670`
`672`	`671`	`Assert.True(signatureMatched);`
`@@ -686,22 +685,22 @@ private static void VerifyHashSignature(`
`686`	`685`
`687`	`686`	`bool signatureMatched;`
`688`	`687`
`689`		`- using (var rsa = new RSACryptoServiceProvider())`
	`688`	`+ using (RSA rsa = RSAFactory.Create())`
`690`	`689`	`{`
`691`	`690`	`rsa.ImportParameters(publicOnly);`
`692`		`- signatureMatched = rsa.VerifyHash(dataHash, hashAlgorithmName, signature);`
	`691`	`+ signatureMatched = rsa.VerifyHash(dataHash, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);`
`693`	`692`	`}`
`694`	`693`
`695`	`694`	`Assert.True(signatureMatched);`
`696`	`695`	`}`
`697`	`696`
`698`	`697`	`private static void SignAndVerify(byte[] data, string hashAlgorithmName, RSAParameters rsaParameters)`
`699`	`698`	`{`
`700`		`- using (var rsa = new RSACryptoServiceProvider())`
	`699`	`+ using (RSA rsa = RSAFactory.Create())`
`701`	`700`	`{`
`702`	`701`	`rsa.ImportParameters(rsaParameters);`
`703`		`- byte[] signature = rsa.SignData(data, hashAlgorithmName);`
`704`		`- bool signatureMatched = rsa.VerifyData(data, hashAlgorithmName, signature);`
	`702`	`+ byte[] signature = rsa.SignData(data, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);`
	`703`	`+ bool signatureMatched = rsa.VerifyData(data, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);`
`705`	`704`	`Assert.True(signatureMatched);`
`706`	`705`	`}`
`707`	`706`	`}`