Adjust project descriptions (#12)

* Adjust package description

.github/workflows/cd.yaml

@@ -21,6 +21,7 @@ jobs:
       Test_Project_Path: SystemExtensions.Tests\SystemExtensions.NetStandard.Tests.csproj
       DI_Test_Project_Path: SystemExtensions.DependencyInjection.Tests\SystemExtensions.NetStandard.DependencyInjection.Tests.csproj
       Source_Project_Path: SystemExtensions.NetStandard\SystemExtensions.NetStandard.csproj
+      Core_Project_Path: SystemExtensions.NetCore\SystemExtensions.NetCore.csproj
       Actions_Allow_Unsecure_Commands: true
 
     steps:
@@ -32,7 +33,7 @@ jobs:
     - name: Install .NET Core
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: '5.0.202'
+        dotnet-version: '6.0.x'
 
     - name: Setup MSBuild.exe
       uses: microsoft/setup-msbuild@v1.0.1
@@ -45,6 +46,9 @@ jobs:
     - name: Build SystemExtensions.NetStandard project
       run: dotnet build SystemExtensions.NetStandard -c $env:Configuration
 
+    - name: Build SystemExtensions.NetCore project
+      run: dotnet build SystemExtensions.NetCore -c $env:Configuration
+
     - name: Build SystemExtensions.NetStandard.DependencyInjection project
       run: dotnet build SystemExtensions.NetStandard.DependencyInjection -c $env:Configuration
 
@@ -57,6 +61,12 @@ jobs:
          PROJECT_FILE_PATH: SystemExtensions.NetStandard\SystemExtensions.NetStandard.csproj
          NUGET_KEY: ${{secrets.NUGET_API_KEY}}
 
+    - name: Push SystemExtensions.NetCore nuget package
+      uses: brandedoutcast/publish-nuget@v2.5.5
+      with:
+         PROJECT_FILE_PATH: SystemExtensions.NetCore\SystemExtensions.NetCore.csproj
+         NUGET_KEY: ${{secrets.NUGET_API_KEY}}
+
     - name: Push SystemExtensions.NetStandard.DependencyInjection nuget package
       uses: brandedoutcast/publish-nuget@v2.5.5
       with:

.github/workflows/ci.yaml

@@ -35,7 +35,7 @@ jobs:
     - name: Install .NET Core
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: '5.0.202'
+        dotnet-version: '6.0.x'
 
     - name: Setup MSBuild.exe
       uses: microsoft/setup-msbuild@v1.0.1

SystemExtensions.DependencyInjection.Tests/SystemExtensions.NetStandard.DependencyInjection.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>

SystemExtensions.NetCore/Extensions/ObjectExtensions.cs

@@ -0,0 +1,22 @@
+using System.Runtime.CompilerServices;
+
+namespace System.Core.Extensions;
+
+public static class ObjectExtensions
+{
+    public static T ThrowIfNull<T>([ValidatedNotNull] this T obj, [CallerArgumentExpression("obj")] string? paramName = null)
+        where T : class
+    {
+        if (obj is null)
+        {
+            throw new ArgumentNullException(paramName);
+        }
+
+        return obj;
+    }
+
+    [AttributeUsage(AttributeTargets.Parameter)]
+    sealed class ValidatedNotNullAttribute : Attribute
+    {
+    }
+}

SystemExtensions.NetCore/SystemExtensions.NetCore.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+	<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <Nullable>enable</Nullable>
+    <RootNamespace>System</RootNamespace>
+	<PackageLicenseFile>LICENSE</PackageLicenseFile>
+	<PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+	<Version>1.0.1</Version>
+	<Authors>Alexandru Macocian</Authors>
+	<RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
+	<Description>Extensions for the System namespace</Description>
+  </PropertyGroup>
+
+  <ItemGroup>
+	<None Include="../LICENSE">
+		<Pack>True</Pack>
+		<PackagePath></PackagePath>
+	</None>
+  </ItemGroup>
+
+</Project>

SystemExtensions.NetStandard.DependencyInjection/SystemExtensions.NetStandard.DependencyInjection.csproj

@@ -6,9 +6,10 @@
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <LangVersion>latest</LangVersion>
-    <Version>1.1.5</Version>
+    <Version>1.1.7</Version>
     <Authors>Alexandru Macocian</Authors>
     <RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
+    <Description>Extensions for the Slim Dependency Injection engine</Description>
   </PropertyGroup>
 
   <ItemGroup>
@@ -20,8 +21,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CorrelationVector" Version="1.0.42" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
-    <PackageReference Include="Slim" Version="1.5.4" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
+    <PackageReference Include="Slim" Version="1.6.0" />
     <PackageReference Include="SystemExtensions.NetStandard" Version="1.3.1" />
   </ItemGroup>
 

SystemExtensions.NetStandard.Security.Tests/AesEncrypterTests.cs

@@ -3,9 +3,9 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.IO;
 using System.Security.Cryptography;
+using System.Security.Encryption;
 using System.Text;
 using System.Threading.Tasks;
-using SystemExtensions.NetStandard.Security.Encryption;
 
 namespace SystemExtensions.NetStandard.Security.Tests
 {

SystemExtensions.NetStandard.Security.Tests/CryptoRngProviderTests.cs

@@ -1,7 +1,7 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Linq;
-using System.Rng;
+using System.Security.Rng;
 
 namespace SystemExtensions.NetStandard.Security.Tests
 {

SystemExtensions.NetStandard.Security.Tests/Rfc2898DeriveBytesPasswordHashingServiceTests.cs

@@ -0,0 +1,261 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Security.Hashing;
+using System.Threading.Tasks;
+
+namespace SystemExtensions.NetStandard.Security.Tests
+{
+    [TestClass]
+    public sealed class Rfc2898DeriveBytesPasswordHashingServiceTests
+    {
+        private const int TooShortHashLength = 31;
+        private const int DesiredHashLength = 32;
+        private const int Iterations = 10000;
+        private const int TooLittleIterations = 1000;
+
+        private readonly Rfc2898DeriveBytesPasswordHashingService rfc2898DeriveBytesPasswordHashingService = new();
+
+        private byte[] tooShortSaltBytes;
+        private string tooShortSaltString;
+        private byte[] incorrectSaltBytes;
+        private string incorrectSaltString;
+        private byte[] saltBytes;
+        private string saltString;
+        private byte[] passwordBytes;
+        private string passwordString;
+        private byte[] incorrectPasswordBytes;
+        private string incorrectPasswordString;
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            this.tooShortSaltBytes = new byte[16];
+            this.tooShortSaltString = Convert.ToBase64String(this.tooShortSaltBytes);
+            this.saltBytes = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
+            this.incorrectSaltBytes = new byte[32];
+            this.incorrectSaltString = Convert.ToBase64String(this.incorrectSaltBytes);
+            this.saltString = Convert.ToBase64String(this.saltBytes);
+            this.passwordBytes = new byte[] { 5, 1, 2, 34, 35, 123, 4, 23, 1, 235, 32, 234 };
+            this.passwordString = Convert.ToBase64String(this.passwordBytes);
+            this.incorrectPasswordBytes = new byte[] { 14, 123, 23, 4, 2, 1, 23, 25 };
+            this.incorrectPasswordString = Convert.ToBase64String(this.incorrectPasswordBytes);
+        }
+
+        [TestMethod]
+        public void PasswordNull_HashBytes_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<byte[]>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(null, this.saltBytes, DesiredHashLength, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void PasswordNull_HashString_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<string>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(null, this.saltString, DesiredHashLength, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void SaltNull_HashBytes_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<byte[]>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, null, DesiredHashLength, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void SaltNull_HashString_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<string>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, null, DesiredHashLength, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void HashLengthTooSmall_HashBytes_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<byte[]>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, TooShortHashLength, Iterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void HashLengthTooSmall_HashString_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<string>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, TooShortHashLength, Iterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void TooLittleIterations_HashBytes_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<byte[]>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, DesiredHashLength, TooLittleIterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void TooLittleIterations_HashString_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<string>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, DesiredHashLength, TooLittleIterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void TooShortSalt_HashBytes_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<byte[]>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.tooShortSaltBytes, DesiredHashLength, TooLittleIterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void TooShortSalt_HashString_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<string>>(() => this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.tooShortSaltString, DesiredHashLength, TooLittleIterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void PasswordNull_VerifyBytes_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(null, this.incorrectPasswordBytes, this.saltBytes, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void PasswordNull_VerifyString_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(null, this.incorrectPasswordString, this.saltString, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void HashNull_VerifyBytes_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(this.passwordBytes, null, this.saltBytes, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void HashNull_VerifyString_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(this.passwordString, null, this.saltString, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void SaltNull_VerifyBytes_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(this.passwordBytes, this.incorrectPasswordBytes, null, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void SaltNull_VerifyString_Throws_ArgumentNullException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(this.passwordString, this.incorrectPasswordString, null, Iterations));
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+        [TestMethod]
+        public void TooLittleIterations_VerifyBytes_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(this.passwordBytes, this.incorrectPasswordBytes, this.saltBytes, TooLittleIterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public void TooLittleIterations_VerifyString_Throws_InvalidOperationException()
+        {
+            var action = new Func<Task<bool>>(() => this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(this.passwordString, this.incorrectPasswordString, this.saltString, TooLittleIterations));
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+        [TestMethod]
+        public async Task HashBytes_ReturnsHashedBytes()
+        {
+            var hashedBytes = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, DesiredHashLength, Iterations);
+
+            hashedBytes.Should().NotBeNull();
+            hashedBytes.Should().HaveCount(DesiredHashLength);
+        }
+        [TestMethod]
+        public async Task HashString_ReturnsHashedString()
+        {
+            var hashedString = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, DesiredHashLength, Iterations);
+
+            hashedString.Should().NotBeNull();
+            var hashedBytes = Convert.FromBase64String(hashedString);
+            hashedBytes.Should().HaveCount(DesiredHashLength);
+        }
+        [TestMethod]
+        public async Task VerifyBytes_CorrectPassword_ReturnsTrue()
+        {
+            var hashedBytes = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedBytes, this.passwordBytes, this.saltBytes, Iterations);
+
+            result.Should().BeTrue();
+        }
+        [TestMethod]
+        public async Task VerifyString_CorrectPassword_ReturnsTrue()
+        {
+            var hashedString = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedString, this.passwordString, this.saltString, Iterations);
+
+            result.Should().BeTrue();
+        }
+        [TestMethod]
+        public async Task VerifyBytes_IncorrectPassword_ReturnsFalse()
+        {
+            var hashedBytes = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedBytes, this.incorrectPasswordBytes, this.saltBytes, Iterations);
+
+            result.Should().BeFalse();
+        }
+        [TestMethod]
+        public async Task VerifyString_IncorrectPassword_ReturnsFalse()
+        {
+            var hashedString = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedString, this.incorrectPasswordString, this.saltString, Iterations);
+
+            result.Should().BeFalse();
+        }
+        [TestMethod]
+        public async Task VerifyBytes_IncorrectSalt_ReturnsFalse()
+        {
+            var hashedBytes = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedBytes, this.passwordBytes, this.incorrectSaltBytes, Iterations);
+
+            result.Should().BeFalse();
+        }
+        [TestMethod]
+        public async Task VerifyString_IncorrectSalt_ReturnsFalse()
+        {
+            var hashedString = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedString, this.passwordString, this.incorrectSaltString, Iterations);
+
+            result.Should().BeFalse();
+        }
+        [TestMethod]
+        public async Task VerifyBytes_IncorrectIterations_ReturnsFalse()
+        {
+            var hashedBytes = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordBytes, this.saltBytes, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedBytes, this.passwordBytes, this.saltBytes, Iterations + 1);
+
+            result.Should().BeFalse();
+        }
+        [TestMethod]
+        public async Task VerifyString_IncorrectIterations_ReturnsFalse()
+        {
+            var hashedString = await this.rfc2898DeriveBytesPasswordHashingService.Hash(this.passwordString, this.saltString, DesiredHashLength, Iterations);
+
+            var result = await this.rfc2898DeriveBytesPasswordHashingService.VerifyPassword(hashedString, this.passwordString, this.saltString, Iterations + 1);
+
+            result.Should().BeFalse();
+        }
+    }
+}

SystemExtensions.NetStandard.Security.Tests/SecureStringTests.cs

@@ -1,7 +1,6 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Encryption;
+using System.Security.Encryption;
 
 namespace SystemExtensions.NetStandard.Security.Tests
 {

SystemExtensions.NetStandard.Security.Tests/Sha256HashingServiceTests.cs

@@ -2,9 +2,9 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.IO;
+using System.Security.Hashing;
 using System.Text;
 using System.Threading.Tasks;
-using SystemExtensions.NetStandard.Security.Hashing;
 
 namespace SystemExtensions.NetStandard.Security.Tests
 {

SystemExtensions.NetStandard.Security.Tests/SystemExtensions.NetStandard.Security.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>

SystemExtensions.NetStandard.Security/Encryption/AesEncrypter.cs

@@ -1,11 +1,10 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
 using System.Threading.Tasks;
-using SystemExtensions.NetStandard.Security.Utilities;
+using System.Security.Utilities;
 
-namespace SystemExtensions.NetStandard.Security.Encryption
+namespace System.Security.Encryption
 {
     public sealed class AesEncrypter : ISymmetricEncrypter
     {

SystemExtensions.NetStandard.Security/Encryption/ISymmetricEncrypter.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using System.Threading.Tasks;
 
-namespace SystemExtensions.NetStandard.Security.Encryption
+namespace System.Security.Encryption
 {
     public interface ISymmetricEncrypter
     {

SystemExtensions.NetStandard.Security/Encryption/SecureString.cs

@@ -1,7 +1,7 @@
 using System.Security.Cryptography;
 using System.Text;
 
-namespace System.Encryption
+namespace System.Security.Encryption
 {
     public sealed class SecureString
     {

SystemExtensions.NetStandard.Security/Hashing/IHashingService.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using System.Threading.Tasks;
 
-namespace SystemExtensions.NetStandard.Security.Hashing
+namespace System.Security.Hashing
 {
     public interface IHashingService
     {

SystemExtensions.NetStandard.Security/Hashing/IPasswordHashingService.cs

@@ -0,0 +1,47 @@
+using System.Threading.Tasks;
+
+namespace System.Security.Hashing
+{
+    public interface IPasswordHashingService
+    {
+        /// <summary>
+        /// Hash provided raw password and return the hashed value.
+        /// </summary>
+        /// <param name="raw">Base64 encoded password.</param>
+        /// <param name="salt">Base64 encoded salt to be used for hashing.</param>
+        /// <param name="length">Length of the resulting hash.</param>
+        /// <param name="iterations">Number of hashing iterations to be performed.</param>
+        /// <remarks>
+        /// The length of the hash will vary due to the base64 encoding of the resulting hash.
+        /// </remarks>
+        /// <returns>Base64 encoded hashed password.</returns>
+        Task<string> Hash(string raw, string salt, int length, int iterations);
+        /// <summary>
+        /// Hash provided raw password and return the hashed value.
+        /// </summary>
+        /// <param name="raw">Password to be hashed.</param>
+        /// <param name="salt">Salt to be used for hashing.</param>
+        /// <param name="length">Length of the resulting hash.</param>
+        /// <param name="iterations">Number of hashing iterations to be performed.</param>
+        /// <returns>Hashed password.</returns>
+        Task<byte[]> Hash(byte[] raw, byte[] salt, int length, int iterations);
+        /// <summary>
+        /// Verify provided password against a hashed password.
+        /// </summary>
+        /// <param name="hash">Base64 encoding of the previously hashed password.</param>
+        /// <param name="password">Base64 encoding of the password to be verified.</param>
+        /// <param name="salt">Salt used to hash the previous password.</param>
+        /// <param name="iterations">Number of iterations used to hash the previous password.</param>
+        /// <returns>Returns true if password matches the previously hashed password. Otherwise returns false.</returns>
+        Task<bool> VerifyPassword(string hash, string password, string salt, int iterations);
+        /// <summary>
+        /// Verify provided password against a hashed password.
+        /// </summary>
+        /// <param name="hash">Previously hashed password.</param>
+        /// <param name="password">Password to be verified.</param>
+        /// <param name="salt">Salt used to hash the previous password.</param>
+        /// <param name="iterations">Number of iterations used to hash the previous password.</param>
+        /// <returns>Returns true if password matches the previously hashed password. Otherwise returns false.</returns>
+        Task<bool> VerifyPassword(byte[] hash, byte[] password, byte[] salt, int iterations);
+    }
+}

SystemExtensions.NetStandard.Security/Hashing/Rfc2898DeriveBytesPasswordHashingService.cs

@@ -0,0 +1,101 @@
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+
+namespace System.Security.Hashing
+{
+    public sealed class Rfc2898DeriveBytesPasswordHashingService : IPasswordHashingService
+    {
+        private const int MinimumIterations = 10000;
+        private const int MinimumHashLength = 32;
+
+        public Rfc2898DeriveBytesPasswordHashingService()
+        {
+        }
+
+        public async Task<string> Hash(string raw, string salt, int length, int iterations)
+        {
+            this.ValidateHashArguments(raw, salt, length, iterations);
+
+            var rawBytes = Convert.FromBase64String(raw);
+            var saltBytes = Convert.FromBase64String(salt);
+            var hashBytes = await this.HashInternal(rawBytes, saltBytes, length, iterations);
+            return Convert.ToBase64String(hashBytes);
+        }
+        public Task<byte[]> Hash(byte[] raw, byte[] salt, int length, int iterations)
+        {
+            this.ValidateHashArguments(raw, salt, length, iterations);
+
+            return this.HashInternal(raw, salt, length, iterations);
+        }
+        public Task<bool> VerifyPassword(string hash, string password, string salt, int iterations)
+        {
+            this.ValidateVerifyArguments(hash, password, salt, iterations);
+            var hashBytes = Convert.FromBase64String(hash);
+            var saltBytes = Convert.FromBase64String(salt);
+            var passwordBytes = Convert.FromBase64String(password);
+            return this.VerifyPasswordInternal(hashBytes, passwordBytes, saltBytes, iterations);
+        }
+        public Task<bool> VerifyPassword(byte[] hash, byte[] password, byte[] salt, int iterations)
+        {
+            this.ValidateVerifyArguments(hash, password, salt, iterations);
+            return this.VerifyPasswordInternal(hash, password, salt, iterations);
+        }
+
+        private void ValidateHashArguments(object raw, object salt, int length, int iterations)
+        {
+            _ = raw ?? throw new ArgumentNullException(nameof(raw));
+            _ = salt ?? throw new ArgumentNullException(nameof(salt));
+
+            if (iterations < MinimumIterations)
+            {
+                throw new InvalidOperationException($"Unable to perform secure hash. Iteration count must be over {MinimumIterations}");
+            }
+
+            if (length < MinimumHashLength)
+            {
+                throw new InvalidOperationException($"Unable to perform secure hash. Hash length must be over {MinimumHashLength}");
+            }
+        }
+        private void ValidateVerifyArguments(object hash, object password, object salt, int iterations)
+        {
+            _ = hash ?? throw new ArgumentNullException(nameof(hash));
+            _ = salt ?? throw new ArgumentNullException(nameof(salt));
+            _ = password ?? throw new ArgumentNullException(nameof(password));
+
+            if (iterations < MinimumIterations)
+            {
+                throw new InvalidOperationException($"Unable to verify hash. Iteration count must be over {MinimumIterations}");
+            }
+        }
+        private Task<byte[]> HashInternal(byte[] raw, byte[] salt, int length, int iterations)
+        {
+            using var pbkdf2 = new Rfc2898DeriveBytes(raw, salt, iterations);
+            var hash = pbkdf2.GetBytes(length);
+            return Task.FromResult(hash);
+        }
+        private Task<bool> VerifyPasswordInternal(byte[] hash, byte[] password, byte[] salt, int iterations)
+        {
+            using var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations);
+            var hashToVerify = pbkdf2.GetBytes(hash.Length);
+            var lengthToVerify = Math.Max(hash.Length, hashToVerify.Length);
+            var match = true;
+            if (lengthToVerify <= 0)
+            {
+                return Task.FromResult(false);
+            }
+
+            for(var i = 0; i < lengthToVerify; i++)
+            {
+                if (i < hash.Length && i < hashToVerify.Length)
+                {
+                    if (hashToVerify[i].Equals(hash[i]) is false)
+                    {
+                        match = false;
+                    }
+                }
+            }
+
+            return Task.FromResult(match && hash.Length.Equals(hashToVerify.Length));
+        }
+    }
+}

SystemExtensions.NetStandard.Security/Hashing/Sha256HashingService.cs

@@ -1,9 +1,8 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Security.Cryptography;
 using System.Threading.Tasks;
 
-namespace SystemExtensions.NetStandard.Security.Hashing
+namespace System.Security.Hashing
 {
     public sealed class Sha256HashingService : IHashingService
     {

SystemExtensions.NetStandard.Security/Rng/CryptoRngProvider.cs

@@ -1,6 +1,6 @@
 using System.Security.Cryptography;
 
-namespace System.Rng
+namespace System.Security.Rng
 {
     public sealed class CryptoRngProvider : ICryptoRngProvider, IDisposable
     {

SystemExtensions.NetStandard.Security/Rng/ICryptoRngProvider.cs

@@ -1,10 +1,28 @@
-namespace System.Rng
+namespace System.Security.Rng
 {
     public interface ICryptoRngProvider
     {
+        /// <summary>
+        /// Populate provided array of bytes with cryptographically secure random bytes.
+        /// </summary>
+        /// <param name="data">Array of bytes to be populated.</param>
         public void GetBytes(byte[] data);
+        /// <summary>
+        /// Return an array of cryptographically secure random bytes.
+        /// </summary>
+        /// <param name="byteCount">Length of the returned array.</param>
+        /// <returns>Array containing cryptographically secure random values.</returns>
         public byte[] GetBytes(int byteCount);
+        /// <summary>
+        /// Populate provided array of bytes with cryptographically secure random non-zero bytes.
+        /// </summary>
+        /// <param name="data">Array of bytes to be populated.</param>
         public void GetNonZeroBytes(byte[] data);
+        /// <summary>
+        /// Return an array of cryptographically secure random non-zero bytes.
+        /// </summary>
+        /// <param name="byteCount">Length of the returned array.</param>
+        /// <returns>Array containing cryptographically secure random non-zero values.</returns>
         public byte[] GetNonZeroBytes(int byteCount);
     }
 }

SystemExtensions.NetStandard.Security/SystemExtensions.NetStandard.Security.csproj

@@ -7,9 +7,10 @@
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <RootNamespace>System</RootNamespace>
-    <Version>1.1.1</Version>
+    <Version>1.2.3</Version>
     <Authors>Alexandru Macocian</Authors>
     <RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
+    <Description>Security extensions for the System namespace</Description>
   </PropertyGroup>
 
   <ItemGroup>

SystemExtensions.NetStandard.Security/Utilities/NotClosingCryptoStream.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using System.Security.Cryptography;
 
-namespace SystemExtensions.NetStandard.Security.Utilities
+namespace System.Security.Utilities
 {
     internal sealed class NotClosingCryptoStream : CryptoStream
     {

SystemExtensions.NetStandard/SystemExtensions.NetStandard.csproj

@@ -2,13 +2,15 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
+	<LangVersion>latest</LangVersion>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <RootNamespace>System</RootNamespace>
-    <Version>1.3.1</Version>
+    <Version>1.3.2</Version>
     <Authors>Alexandru Macocian</Authors>
     <RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
+    <Description>Extensions for the System namespace</Description>
   </PropertyGroup>
 
   <ItemGroup>

SystemExtensions.Tests/Extensions/ObjectExtensionsTests.cs

@@ -0,0 +1,42 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Extensions.Tests;
+
+[TestClass]
+public class ObjectExtensionsTests
+{
+    [TestMethod]
+    public void ThrowIfNull_NetCore_ThrowsWithCorrectName()
+    {
+        object obj = null;
+        try
+        {
+            System.Core.Extensions.ObjectExtensions.ThrowIfNull(obj);
+        }
+        catch (ArgumentNullException ex)
+        {
+            ex.ParamName.Should().Be("obj");
+            return;
+        }
+
+        Assert.Fail("Null object should throw");
+    }
+
+    [TestMethod]
+    public void ThrowIfNull_NetStandard_ThrowsWithCorrectName()
+    {
+        object obj = null;
+        try
+        {
+            ObjectExtensions.ThrowIfNull(obj, nameof(obj));
+        }
+        catch (ArgumentNullException ex)
+        {
+            ex.ParamName.Should().Be("obj");
+            return;
+        }
+
+        Assert.Fail("Null object should throw");
+    }
+}

SystemExtensions.Tests/Http/HttpClientTests.cs

@@ -1,7 +1,5 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Http;
 using System.IO;
 using System.Net;
 using System.Net.Http;
@@ -9,7 +7,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using SystemExtensionsTests.Utils;
 
-namespace SystemExtensionsTests.Http
+namespace System.Http.Tests
 {
     [TestClass]
     public class HttpClientTests

SystemExtensions.Tests/SystemExtensions.NetStandard.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
@@ -18,6 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\SystemExtensions.NetCore\SystemExtensions.NetCore.csproj" />
     <ProjectReference Include="..\SystemExtensions.NetStandard\SystemExtensions.NetStandard.csproj" />
   </ItemGroup>
 

SystemExtensions.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.31005.135
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31815.197
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SystemExtensions.NetStandard", "SystemExtensions.NetStandard\SystemExtensions.NetStandard.csproj", "{4CE9E55C-6016-4631-B8D4-4D763DD05F23}"
 EndProject
@@ -14,9 +14,19 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SystemExtensions.NetStandar
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SystemExtensions.NetStandard.DependencyInjection.Tests", "SystemExtensions.DependencyInjection.Tests\SystemExtensions.NetStandard.DependencyInjection.Tests.csproj", "{1AFA1EEF-CEBA-4046-8466-C9B52979B7DA}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemExtensions.NetStandard.Security", "SystemExtensions.NetStandard.Security\SystemExtensions.NetStandard.Security.csproj", "{BFC5BEE7-2569-45EA-9713-CDB32EED57AA}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SystemExtensions.NetStandard.Security", "SystemExtensions.NetStandard.Security\SystemExtensions.NetStandard.Security.csproj", "{BFC5BEE7-2569-45EA-9713-CDB32EED57AA}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemExtensions.NetStandard.Security.Tests", "SystemExtensions.NetStandard.Security.Tests\SystemExtensions.NetStandard.Security.Tests.csproj", "{341ECE0F-A8DD-49A0-AE3D-B28D72E85130}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SystemExtensions.NetStandard.Security.Tests", "SystemExtensions.NetStandard.Security.Tests\SystemExtensions.NetStandard.Security.Tests.csproj", "{341ECE0F-A8DD-49A0-AE3D-B28D72E85130}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemExtensions.NetCore", "SystemExtensions.NetCore\SystemExtensions.NetCore.csproj", "{9E6EBBF0-671B-4941-A72B-2CA60C882038}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{BBA334F6-779A-4A45-8BF3-EA321D0D12CF}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{52962B0C-BB5F-4211-A70C-801D0A73CACC}"
+	ProjectSection(SolutionItems) = preProject
+		.github\workflows\cd.yaml = .github\workflows\cd.yaml
+		.github\workflows\ci.yaml = .github\workflows\ci.yaml
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -48,10 +58,17 @@ Global
 		{341ECE0F-A8DD-49A0-AE3D-B28D72E85130}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{341ECE0F-A8DD-49A0-AE3D-B28D72E85130}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{341ECE0F-A8DD-49A0-AE3D-B28D72E85130}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9E6EBBF0-671B-4941-A72B-2CA60C882038}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9E6EBBF0-671B-4941-A72B-2CA60C882038}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9E6EBBF0-671B-4941-A72B-2CA60C882038}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9E6EBBF0-671B-4941-A72B-2CA60C882038}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{52962B0C-BB5F-4211-A70C-801D0A73CACC} = {BBA334F6-779A-4A45-8BF3-EA321D0D12CF}
+	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {BFA90E90-BD97-40AD-B19E-C723E504369A}
 	EndGlobalSection