Obsolete outdated constructors on Rfc2898DeriveBytes

vcsjones · web-flow · commit e961b1094466 · 2022-03-25T17:27:20.000-07:00
diff --git a/docs/project/list-of-diagnostics.md b/docs/project/list-of-diagnostics.md
@@ -95,6 +95,7 @@ The PR that reveals the implementation of the `<IncludeInternalObsoleteAttribute
 |  __`SYSLIB0038`__ | SerializationFormat.Binary is obsolete and should not be used. See https://aka.ms/serializationformat-binary-obsolete for more information. |
 |  __`SYSLIB0039`__ | TLS versions 1.0 and 1.1 have known vulnerabilities and are not recommended. Use a newer TLS version instead, or use SslProtocols.None to defer to OS defaults. |
 |  __`SYSLIB0040`__ | EncryptionPolicy.NoEncryption and AllowEncryption significantly reduce security and should not be used in production code. |
+|  __`SYSLIB0041`__ | The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations. |
 
 ## Analyzer Warnings
 
diff --git a/src/libraries/Common/src/System/Obsoletions.cs b/src/libraries/Common/src/System/Obsoletions.cs
@@ -132,5 +132,8 @@ internal static class Obsoletions
 
         internal const string EncryptionPolicyMessage = "EncryptionPolicy.NoEncryption and AllowEncryption significantly reduce security and should not be used in production code.";
         internal const string EncryptionPolicyDiagId = "SYSLIB0040";
+
+        internal const string Rfc2898OutdatedCtorMessage = "The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.";
+        internal const string Rfc2898OutdatedCtorDiagId = "SYSLIB0041";
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs b/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs
@@ -1716,12 +1716,17 @@ public override void GenerateKey() { }
     [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
     public partial class Rfc2898DeriveBytes : System.Security.Cryptography.DeriveBytes
     {
+        [System.ObsoleteAttribute("The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.", DiagnosticId="SYSLIB0041", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
         public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations) { }
         public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { }
+        [System.ObsoleteAttribute("The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.", DiagnosticId="SYSLIB0041", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
         public Rfc2898DeriveBytes(string password, byte[] salt) { }
+        [System.ObsoleteAttribute("The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.", DiagnosticId="SYSLIB0041", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
         public Rfc2898DeriveBytes(string password, byte[] salt, int iterations) { }
         public Rfc2898DeriveBytes(string password, byte[] salt, int iterations, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { }
+        [System.ObsoleteAttribute("The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.", DiagnosticId="SYSLIB0041", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
         public Rfc2898DeriveBytes(string password, int saltSize) { }
+        [System.ObsoleteAttribute("The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.", DiagnosticId="SYSLIB0041", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
         public Rfc2898DeriveBytes(string password, int saltSize, int iterations) { }
         public Rfc2898DeriveBytes(string password, int saltSize, int iterations, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { }
         public System.Security.Cryptography.HashAlgorithmName HashAlgorithm { get { throw null; } }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rfc2898DeriveBytes.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rfc2898DeriveBytes.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Buffers;
 using System.Buffers.Binary;
 using System.Diagnostics;
@@ -29,6 +30,7 @@ public partial class Rfc2898DeriveBytes : DeriveBytes
         /// </summary>
         public HashAlgorithmName HashAlgorithm { get; }
 
+        [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations)
             : this(password, salt, iterations, HashAlgorithmName.SHA1)
         {
@@ -39,11 +41,13 @@ public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations, HashAlgo
         {
         }
 
+        [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public Rfc2898DeriveBytes(string password, byte[] salt)
              : this(password, salt, 1000)
         {
         }
 
+        [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public Rfc2898DeriveBytes(string password, byte[] salt, int iterations)
             : this(password, salt, iterations, HashAlgorithmName.SHA1)
         {
@@ -54,11 +58,13 @@ public Rfc2898DeriveBytes(string password, byte[] salt, int iterations, HashAlgo
         {
         }
 
+        [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public Rfc2898DeriveBytes(string password, int saltSize)
             : this(password, saltSize, 1000)
         {
         }
 
+        [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public Rfc2898DeriveBytes(string password, int saltSize, int iterations)
             : this(password, saltSize, iterations, HashAlgorithmName.SHA1)
         {
diff --git a/src/libraries/System.Security.Cryptography/tests/Rfc2898Tests.cs b/src/libraries/System.Security.Cryptography/tests/Rfc2898Tests.cs
@@ -21,41 +21,51 @@ public class Rfc2898Tests
         [Fact]
         public static void Ctor_NullPasswordBytes()
         {
-            Assert.Throws<NullReferenceException>(() => new Rfc2898DeriveBytes((byte[])null, s_testSalt, DefaultIterationCount));
+            Assert.Throws<NullReferenceException>(() =>
+                new Rfc2898DeriveBytes((byte[])null, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1));
         }
 
         [Fact]
         public static void Ctor_NullPasswordString()
         {
-            Assert.Throws<ArgumentNullException>(() => new Rfc2898DeriveBytes((string)null, s_testSalt, DefaultIterationCount));
+            Assert.Throws<ArgumentNullException>(() =>
+                new Rfc2898DeriveBytes((string)null, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1));
         }
 
         [Fact]
         public static void Ctor_NullSalt()
         {
-            Assert.Throws<ArgumentNullException>(() => new Rfc2898DeriveBytes(TestPassword, null, DefaultIterationCount));
+            AssertExtensions.Throws<ArgumentNullException>("salt", () =>
+                new Rfc2898DeriveBytes(TestPassword, null, DefaultIterationCount, HashAlgorithmName.SHA1));
         }
 
         [Fact]
         public static void Ctor_GenerateNegativeSalt()
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, -1));
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, int.MinValue));
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, int.MinValue / 2));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("saltSize", () =>
+                new Rfc2898DeriveBytes(TestPassword, -1, DefaultIterationCount, HashAlgorithmName.SHA1));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("saltSize", () =>
+                new Rfc2898DeriveBytes(TestPassword, int.MinValue, DefaultIterationCount, HashAlgorithmName.SHA1));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("saltSize", () =>
+                new Rfc2898DeriveBytes(TestPassword, int.MinValue / 2, DefaultIterationCount, HashAlgorithmName.SHA1));
         }
 
         [Fact]
         public static void Ctor_TooFewIterations()
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, 0));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>
+                new Rfc2898DeriveBytes(TestPassword, s_testSalt, 0, HashAlgorithmName.SHA1));
         }
 
         [Fact]
         public static void Ctor_NegativeIterations()
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, -1));
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue));
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue / 2));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>
+                new Rfc2898DeriveBytes(TestPassword, s_testSalt, -1, HashAlgorithmName.SHA1));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>
+                new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue, HashAlgorithmName.SHA1));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>
+                new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue / 2, HashAlgorithmName.SHA1));
         }
 
         [Fact]
@@ -90,7 +100,7 @@ public static void Ctor_SaltCopied()
         {
             byte[] saltIn = (byte[])s_testSalt.Clone();
 
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, saltIn, DefaultIterationCount))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, saltIn, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 byte[] saltOut = deriveBytes.Salt;
 
@@ -110,7 +120,9 @@ public static void Ctor_SaltCopied()
         [Fact]
         public static void Ctor_DefaultIterations()
         {
+#pragma warning disable SYSLIB0041 // Rfc2898DeriveBytes insecure constructor defaults
             using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
+#pragma warning restore SYSLIB0041
             {
                 Assert.Equal(DefaultIterationCount, deriveBytes.IterationCount);
             }
@@ -119,7 +131,7 @@ public static void Ctor_DefaultIterations()
         [Fact]
         public static void Ctor_GenerateEmptySalt()
         {
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, 0, 1))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, 0, 1, HashAlgorithmName.SHA1))
             {
                 Assert.Empty(deriveBytes.Salt);
             }
@@ -128,7 +140,7 @@ public static void Ctor_GenerateEmptySalt()
         [Fact]
         public static void Ctor_IterationsRespected()
         {
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, 1))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, 1, HashAlgorithmName.SHA1))
             {
                 Assert.Equal(1, deriveBytes.IterationCount);
             }
@@ -140,7 +152,7 @@ public static void GetSaltCopies()
             byte[] first;
             byte[] second;
 
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 first = deriveBytes.Salt;
                 second = deriveBytes.Salt;
@@ -155,7 +167,7 @@ public static void MinimumAcceptableInputs()
         {
             byte[] output;
 
-            using (var deriveBytes = new Rfc2898DeriveBytes("", Array.Empty<byte>(), 1))
+            using (var deriveBytes = new Rfc2898DeriveBytes("", Array.Empty<byte>(), 1, HashAlgorithmName.SHA1))
             {
                 output = deriveBytes.GetBytes(1);
                 Assert.Empty(deriveBytes.Salt);
@@ -168,7 +180,7 @@ public static void MinimumAcceptableInputs()
         [Fact]
         public static void GetBytes_ZeroLength()
         {
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(0));
             }
@@ -177,7 +189,7 @@ public static void GetBytes_ZeroLength()
         [Fact]
         public static void GetBytes_NegativeLength()
         {
-            Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt);
+            Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1);
             Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(-1));
             Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(int.MinValue));
             Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(int.MinValue / 2));
@@ -189,7 +201,7 @@ public static void GetBytes_NotIdempotent()
             byte[] first;
             byte[] second;
 
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 first = deriveBytes.GetBytes(32);
                 second = deriveBytes.GetBytes(32);
@@ -212,15 +224,15 @@ public static void GetBytes_StreamLike(int size)
         {
             byte[] first;
 
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 first = deriveBytes.GetBytes(size);
             }
 
             byte[] second = new byte[first.Length];
 
             // Reset
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 byte[] secondFirstHalf = deriveBytes.GetBytes(first.Length / 2);
                 byte[] secondSecondHalf = deriveBytes.GetBytes(first.Length - secondFirstHalf.Length);
@@ -246,15 +258,15 @@ public static void GetBytes_StreamLike_OneAtATime(int size)
         {
             byte[] first;
 
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 first = deriveBytes.GetBytes(size);
             }
 
             byte[] second = new byte[first.Length];
 
             // Reset
-            using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 for (int i = 0; i < second.Length; i++)
                 {
@@ -367,11 +379,13 @@ public static void CheckHashAlgorithmValue(string hashAlgorithmName)
         [Fact]
         public static void CryptDeriveKey_NotSupported()
         {
+#pragma warning disable SYSLIB0041 // Rfc2898DeriveBytes insecure constructor defaults
+#pragma warning disable SYSLIB0033 // Rfc2898DeriveBytes.CryptDeriveKey is obsolete
             using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
             {
-#pragma warning disable SYSLIB0033 // Rfc2898DeriveBytes.CryptDeriveKey is obsolete
                 Assert.Throws<PlatformNotSupportedException>(() => deriveBytes.CryptDeriveKey("RC2", "SHA1", 128, new byte[8]));
 #pragma warning restore SYSLIB0033
+#pragma warning restore SYSLIB0041
             }
         }
 
@@ -381,7 +395,7 @@ public static void GetBytes_ExceedCounterLimit()
             FieldInfo blockField = typeof(Rfc2898DeriveBytes).GetField("_block", BindingFlags.NonPublic | BindingFlags.Instance);
             Assert.NotNull(blockField);
 
-            using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))
+            using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, 1, HashAlgorithmName.SHA1))
             {
                 // Set the internal block counter to be on the last possible block. This should succeed.
                 blockField.SetValue(deriveBytes, uint.MaxValue - 1);
@@ -398,12 +412,12 @@ public static void Ctor_PasswordMutatedAfterCreate()
             byte[] passwordBytes = Encoding.UTF8.GetBytes(TestPassword);
             byte[] derived;
 
-            using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount))
+            using (var deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 derived = deriveBytes.GetBytes(64);
             }
 
-            using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount))
+            using (var deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 passwordBytes[0] ^= 0xFF; // Flipping a byte after the object is constructed should not be observed.
 
@@ -418,7 +432,7 @@ public static void Ctor_PasswordBytes_NotCleared()
             byte[] passwordBytes = Encoding.UTF8.GetBytes(TestPassword);
             byte[] passwordBytesOriginal = passwordBytes.AsSpan().ToArray();
 
-            using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount))
+            using (var deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))
             {
                 Assert.Equal(passwordBytesOriginal, passwordBytes);
             }
@@ -428,7 +442,7 @@ private static void TestKnownValue(string password, byte[] salt, int iterationCo
         {
             byte[] output;
 
-            using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, iterationCount))
+            using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, iterationCount, HashAlgorithmName.SHA1))
             {
                 output = deriveBytes.GetBytes(expected.Length);
             }

Original file line number	Diff line number	Diff line change
`@@ -132,5 +132,8 @@ internal static class Obsoletions`
`132`	`132`
`133`	`133`	`internal const string EncryptionPolicyMessage = "EncryptionPolicy.NoEncryption and AllowEncryption significantly reduce security and should not be used in production code.";`
`134`	`134`	`internal const string EncryptionPolicyDiagId = "SYSLIB0040";`
	`135`	`+`
	`136`	`+ internal const string Rfc2898OutdatedCtorMessage = "The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.";`
	`137`	`+ internal const string Rfc2898OutdatedCtorDiagId = "SYSLIB0041";`
`135`	`138`	`}`
`136`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
	`4`	`+using System;`
`4`	`5`	`using System.Buffers;`
`5`	`6`	`using System.Buffers.Binary;`
`6`	`7`	`using System.Diagnostics;`
`@@ -29,6 +30,7 @@ public partial class Rfc2898DeriveBytes : DeriveBytes`
`29`	`30`	`/// </summary>`
`30`	`31`	`public HashAlgorithmName HashAlgorithm { get; }`
`31`	`32`
	`33`	`+ [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]`
`32`	`34`	`public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations)`
`33`	`35`	`: this(password, salt, iterations, HashAlgorithmName.SHA1)`
`34`	`36`	`{`
`@@ -39,11 +41,13 @@ public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations, HashAlgo`
`39`	`41`	`{`
`40`	`42`	`}`
`41`	`43`
	`44`	`+ [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]`
`42`	`45`	`public Rfc2898DeriveBytes(string password, byte[] salt)`
`43`	`46`	`: this(password, salt, 1000)`
`44`	`47`	`{`
`45`	`48`	`}`
`46`	`49`
	`50`	`+ [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]`
`47`	`51`	`public Rfc2898DeriveBytes(string password, byte[] salt, int iterations)`
`48`	`52`	`: this(password, salt, iterations, HashAlgorithmName.SHA1)`
`49`	`53`	`{`
`@@ -54,11 +58,13 @@ public Rfc2898DeriveBytes(string password, byte[] salt, int iterations, HashAlgo`
`54`	`58`	`{`
`55`	`59`	`}`
`56`	`60`
	`61`	`+ [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]`
`57`	`62`	`public Rfc2898DeriveBytes(string password, int saltSize)`
`58`	`63`	`: this(password, saltSize, 1000)`
`59`	`64`	`{`
`60`	`65`	`}`
`61`	`66`
	`67`	`+ [Obsolete(Obsoletions.Rfc2898OutdatedCtorMessage, DiagnosticId = Obsoletions.Rfc2898OutdatedCtorDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]`
`62`	`68`	`public Rfc2898DeriveBytes(string password, int saltSize, int iterations)`
`63`	`69`	`: this(password, saltSize, iterations, HashAlgorithmName.SHA1)`
`64`	`70`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,41 +21,51 @@ public class Rfc2898Tests`
`21`	`21`	`[Fact]`
`22`	`22`	`public static void Ctor_NullPasswordBytes()`
`23`	`23`	`{`
`24`		`- Assert.Throws<NullReferenceException>(() => new Rfc2898DeriveBytes((byte[])null, s_testSalt, DefaultIterationCount));`
	`24`	`+ Assert.Throws<NullReferenceException>(() =>`
	`25`	`+ new Rfc2898DeriveBytes((byte[])null, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1));`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`[Fact]`
`28`	`29`	`public static void Ctor_NullPasswordString()`
`29`	`30`	`{`
`30`		`- Assert.Throws<ArgumentNullException>(() => new Rfc2898DeriveBytes((string)null, s_testSalt, DefaultIterationCount));`
	`31`	`+ Assert.Throws<ArgumentNullException>(() =>`
	`32`	`+ new Rfc2898DeriveBytes((string)null, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1));`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`[Fact]`
`34`	`36`	`public static void Ctor_NullSalt()`
`35`	`37`	`{`
`36`		`- Assert.Throws<ArgumentNullException>(() => new Rfc2898DeriveBytes(TestPassword, null, DefaultIterationCount));`
	`38`	`+ AssertExtensions.Throws<ArgumentNullException>("salt", () =>`
	`39`	`+ new Rfc2898DeriveBytes(TestPassword, null, DefaultIterationCount, HashAlgorithmName.SHA1));`
`37`	`40`	`}`
`38`	`41`
`39`	`42`	`[Fact]`
`40`	`43`	`public static void Ctor_GenerateNegativeSalt()`
`41`	`44`	`{`
`42`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, -1));`
`43`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, int.MinValue));`
`44`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, int.MinValue / 2));`
	`45`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("saltSize", () =>`
	`46`	`+ new Rfc2898DeriveBytes(TestPassword, -1, DefaultIterationCount, HashAlgorithmName.SHA1));`
	`47`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("saltSize", () =>`
	`48`	`+ new Rfc2898DeriveBytes(TestPassword, int.MinValue, DefaultIterationCount, HashAlgorithmName.SHA1));`
	`49`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("saltSize", () =>`
	`50`	`+ new Rfc2898DeriveBytes(TestPassword, int.MinValue / 2, DefaultIterationCount, HashAlgorithmName.SHA1));`
`45`	`51`	`}`
`46`	`52`
`47`	`53`	`[Fact]`
`48`	`54`	`public static void Ctor_TooFewIterations()`
`49`	`55`	`{`
`50`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, 0));`
	`56`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>`
	`57`	`+ new Rfc2898DeriveBytes(TestPassword, s_testSalt, 0, HashAlgorithmName.SHA1));`
`51`	`58`	`}`
`52`	`59`
`53`	`60`	`[Fact]`
`54`	`61`	`public static void Ctor_NegativeIterations()`
`55`	`62`	`{`
`56`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, -1));`
`57`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue));`
`58`		`- Assert.Throws<ArgumentOutOfRangeException>(() => new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue / 2));`
	`63`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>`
	`64`	`+ new Rfc2898DeriveBytes(TestPassword, s_testSalt, -1, HashAlgorithmName.SHA1));`
	`65`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>`
	`66`	`+ new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue, HashAlgorithmName.SHA1));`
	`67`	`+ AssertExtensions.Throws<ArgumentOutOfRangeException>("iterations", () =>`
	`68`	`+ new Rfc2898DeriveBytes(TestPassword, s_testSalt, int.MinValue / 2, HashAlgorithmName.SHA1));`
`59`	`69`	`}`
`60`	`70`
`61`	`71`	`[Fact]`
`@@ -90,7 +100,7 @@ public static void Ctor_SaltCopied()`
`90`	`100`	`{`
`91`	`101`	`byte[] saltIn = (byte[])s_testSalt.Clone();`
`92`	`102`
`93`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, saltIn, DefaultIterationCount))`
	`103`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, saltIn, DefaultIterationCount, HashAlgorithmName.SHA1))`
`94`	`104`	`{`
`95`	`105`	`byte[] saltOut = deriveBytes.Salt;`
`96`	`106`
`@@ -110,7 +120,9 @@ public static void Ctor_SaltCopied()`
`110`	`120`	`[Fact]`
`111`	`121`	`public static void Ctor_DefaultIterations()`
`112`	`122`	`{`
	`123`	`+#pragma warning disable SYSLIB0041 // Rfc2898DeriveBytes insecure constructor defaults`
`113`	`124`	`using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
	`125`	`+#pragma warning restore SYSLIB0041`
`114`	`126`	`{`
`115`	`127`	`Assert.Equal(DefaultIterationCount, deriveBytes.IterationCount);`
`116`	`128`	`}`
`@@ -119,7 +131,7 @@ public static void Ctor_DefaultIterations()`
`119`	`131`	`[Fact]`
`120`	`132`	`public static void Ctor_GenerateEmptySalt()`
`121`	`133`	`{`
`122`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, 0, 1))`
	`134`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, 0, 1, HashAlgorithmName.SHA1))`
`123`	`135`	`{`
`124`	`136`	`Assert.Empty(deriveBytes.Salt);`
`125`	`137`	`}`
`@@ -128,7 +140,7 @@ public static void Ctor_GenerateEmptySalt()`
`128`	`140`	`[Fact]`
`129`	`141`	`public static void Ctor_IterationsRespected()`
`130`	`142`	`{`
`131`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, 1))`
	`143`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, 1, HashAlgorithmName.SHA1))`
`132`	`144`	`{`
`133`	`145`	`Assert.Equal(1, deriveBytes.IterationCount);`
`134`	`146`	`}`
`@@ -140,7 +152,7 @@ public static void GetSaltCopies()`
`140`	`152`	`byte[] first;`
`141`	`153`	`byte[] second;`
`142`	`154`
`143`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount))`
	`155`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))`
`144`	`156`	`{`
`145`	`157`	`first = deriveBytes.Salt;`
`146`	`158`	`second = deriveBytes.Salt;`
`@@ -155,7 +167,7 @@ public static void MinimumAcceptableInputs()`
`155`	`167`	`{`
`156`	`168`	`byte[] output;`
`157`	`169`
`158`		`- using (var deriveBytes = new Rfc2898DeriveBytes("", Array.Empty<byte>(), 1))`
	`170`	`+ using (var deriveBytes = new Rfc2898DeriveBytes("", Array.Empty<byte>(), 1, HashAlgorithmName.SHA1))`
`159`	`171`	`{`
`160`	`172`	`output = deriveBytes.GetBytes(1);`
`161`	`173`	`Assert.Empty(deriveBytes.Salt);`
`@@ -168,7 +180,7 @@ public static void MinimumAcceptableInputs()`
`168`	`180`	`[Fact]`
`169`	`181`	`public static void GetBytes_ZeroLength()`
`170`	`182`	`{`
`171`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
	`183`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))`
`172`	`184`	`{`
`173`	`185`	`Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(0));`
`174`	`186`	`}`
`@@ -177,7 +189,7 @@ public static void GetBytes_ZeroLength()`
`177`	`189`	`[Fact]`
`178`	`190`	`public static void GetBytes_NegativeLength()`
`179`	`191`	`{`
`180`		`- Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt);`
	`192`	`+ Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1);`
`181`	`193`	`Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(-1));`
`182`	`194`	`Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(int.MinValue));`
`183`	`195`	`Assert.Throws<ArgumentOutOfRangeException>(() => deriveBytes.GetBytes(int.MinValue / 2));`
`@@ -189,7 +201,7 @@ public static void GetBytes_NotIdempotent()`
`189`	`201`	`byte[] first;`
`190`	`202`	`byte[] second;`
`191`	`203`
`192`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
	`204`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))`
`193`	`205`	`{`
`194`	`206`	`first = deriveBytes.GetBytes(32);`
`195`	`207`	`second = deriveBytes.GetBytes(32);`
`@@ -212,15 +224,15 @@ public static void GetBytes_StreamLike(int size)`
`212`	`224`	`{`
`213`	`225`	`byte[] first;`
`214`	`226`
`215`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
	`227`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))`
`216`	`228`	`{`
`217`	`229`	`first = deriveBytes.GetBytes(size);`
`218`	`230`	`}`
`219`	`231`
`220`	`232`	`byte[] second = new byte[first.Length];`
`221`	`233`
`222`	`234`	`// Reset`
`223`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
	`235`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, DefaultIterationCount, HashAlgorithmName.SHA1))`
`224`	`236`	`{`
`225`	`237`	`byte[] secondFirstHalf = deriveBytes.GetBytes(first.Length / 2);`
`226`	`238`	`byte[] secondSecondHalf = deriveBytes.GetBytes(first.Length - secondFirstHalf.Length);`
`@@ -246,15 +258,15 @@ public static void GetBytes_StreamLike_OneAtATime(int size)`
`246`	`258`	`{`
`247`	`259`	`byte[] first;`
`248`	`260`
`249`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB))`
	`261`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))`
`250`	`262`	`{`
`251`	`263`	`first = deriveBytes.GetBytes(size);`
`252`	`264`	`}`
`253`	`265`
`254`	`266`	`byte[] second = new byte[first.Length];`
`255`	`267`
`256`	`268`	`// Reset`
`257`		`- using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB))`
	`269`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPasswordB, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))`
`258`	`270`	`{`
`259`	`271`	`for (int i = 0; i < second.Length; i++)`
`260`	`272`	`{`
`@@ -367,11 +379,13 @@ public static void CheckHashAlgorithmValue(string hashAlgorithmName)`
`367`	`379`	`[Fact]`
`368`	`380`	`public static void CryptDeriveKey_NotSupported()`
`369`	`381`	`{`
	`382`	`+#pragma warning disable SYSLIB0041 // Rfc2898DeriveBytes insecure constructor defaults`
	`383`	`+#pragma warning disable SYSLIB0033 // Rfc2898DeriveBytes.CryptDeriveKey is obsolete`
`370`	`384`	`using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
`371`	`385`	`{`
`372`		`-#pragma warning disable SYSLIB0033 // Rfc2898DeriveBytes.CryptDeriveKey is obsolete`
`373`	`386`	`Assert.Throws<PlatformNotSupportedException>(() => deriveBytes.CryptDeriveKey("RC2", "SHA1", 128, new byte[8]));`
`374`	`387`	`#pragma warning restore SYSLIB0033`
	`388`	`+#pragma warning restore SYSLIB0041`
`375`	`389`	`}`
`376`	`390`	`}`
`377`	`391`
`@@ -381,7 +395,7 @@ public static void GetBytes_ExceedCounterLimit()`
`381`	`395`	`FieldInfo blockField = typeof(Rfc2898DeriveBytes).GetField("_block", BindingFlags.NonPublic \| BindingFlags.Instance);`
`382`	`396`	`Assert.NotNull(blockField);`
`383`	`397`
`384`		`- using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt))`
	`398`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(TestPassword, s_testSalt, 1, HashAlgorithmName.SHA1))`
`385`	`399`	`{`
`386`	`400`	`// Set the internal block counter to be on the last possible block. This should succeed.`
`387`	`401`	`blockField.SetValue(deriveBytes, uint.MaxValue - 1);`
`@@ -398,12 +412,12 @@ public static void Ctor_PasswordMutatedAfterCreate()`
`398`	`412`	`byte[] passwordBytes = Encoding.UTF8.GetBytes(TestPassword);`
`399`	`413`	`byte[] derived;`
`400`	`414`
`401`		`- using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount))`
	`415`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))`
`402`	`416`	`{`
`403`	`417`	`derived = deriveBytes.GetBytes(64);`
`404`	`418`	`}`
`405`	`419`
`406`		`- using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount))`
	`420`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))`
`407`	`421`	`{`
`408`	`422`	`passwordBytes[0] ^= 0xFF; // Flipping a byte after the object is constructed should not be observed.`
`409`	`423`
`@@ -418,7 +432,7 @@ public static void Ctor_PasswordBytes_NotCleared()`
`418`	`432`	`byte[] passwordBytes = Encoding.UTF8.GetBytes(TestPassword);`
`419`	`433`	`byte[] passwordBytesOriginal = passwordBytes.AsSpan().ToArray();`
`420`	`434`
`421`		`- using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount))`
	`435`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(passwordBytes, s_testSaltB, DefaultIterationCount, HashAlgorithmName.SHA1))`
`422`	`436`	`{`
`423`	`437`	`Assert.Equal(passwordBytesOriginal, passwordBytes);`
`424`	`438`	`}`
`@@ -428,7 +442,7 @@ private static void TestKnownValue(string password, byte[] salt, int iterationCo`
`428`	`442`	`{`
`429`	`443`	`byte[] output;`
`430`	`444`
`431`		`- using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, iterationCount))`
	`445`	`+ using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, iterationCount, HashAlgorithmName.SHA1))`
`432`	`446`	`{`
`433`	`447`	`output = deriveBytes.GetBytes(expected.Length);`
`434`	`448`	`}`