Implemented ECDSA public/private keys and tests.

Author: MrMatthewLayton

OnixLabs.Security.Cryptography.UnitTests/EcdsaKeyTests.cs

@@ -0,0 +1,43 @@
+// Copyright 2020 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Security.Cryptography;
+using Xunit;
+
+namespace OnixLabs.Security.Cryptography.UnitTests;
+
+public sealed class EcdsaKeyTests
+{
+    [Fact(DisplayName = "ECDSA sign and verify with two identical keys should succeed")]
+    public void EcdsaSignAndVerifyWithTwoIdenticalKeysShouldSucceed()
+    {
+        // Given
+        byte[] data = Salt.CreateNonZero(2048).ToByteArray();
+        HashAlgorithm algorithm = SHA256.Create();
+        IEcdsaPrivateKey privateKey1 = EcdsaPrivateKey.Create();
+        IEcdsaPrivateKey privateKey2 = new EcdsaPrivateKey(privateKey1.ToByteArray());
+        IEcdsaPublicKey publicKey1 = privateKey1.GetPublicKey();
+        IEcdsaPublicKey publicKey2 = privateKey2.GetPublicKey();
+
+        // When
+        DigitalSignature signature1 = new(privateKey1.SignData(data, algorithm));
+        DigitalSignature signature2 = new(privateKey2.SignData(data, algorithm));
+
+        // Then
+        Assert.True(publicKey1.IsDataValid(signature1, data, algorithm));
+        Assert.True(publicKey1.IsDataValid(signature2, data, algorithm));
+        Assert.True(publicKey2.IsDataValid(signature1, data, algorithm));
+        Assert.True(publicKey2.IsDataValid(signature2, data, algorithm));
+    }
+}

OnixLabs.Security.Cryptography/EcdsaPrivateKey.Create.cs

@@ -0,0 +1,55 @@
+// Copyright 2020 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Security.Cryptography;
+
+namespace OnixLabs.Security.Cryptography;
+
+public sealed partial class EcdsaPrivateKey
+{
+    /// <summary>
+    /// Creates a new ECDSA cryptographic private key.
+    /// </summary>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance.</returns>
+    public static EcdsaPrivateKey Create()
+    {
+        using ECDsa key = ECDsa.Create();
+        byte[] keyData = key.ExportECPrivateKey();
+        return new EcdsaPrivateKey(keyData);
+    }
+
+    /// <summary>
+    /// Creates a new ECDSA cryptographic private key.
+    /// </summary>
+    /// <param name="curve">The elliptic curve from which to create a new ECDSA cryptographic private key.</param>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance.</returns>
+    public static EcdsaPrivateKey Create(ECCurve curve)
+    {
+        using ECDsa key = ECDsa.Create(curve);
+        byte[] keyData = key.ExportECPrivateKey();
+        return new EcdsaPrivateKey(keyData);
+    }
+
+    /// <summary>
+    /// Creates a new ECDSA cryptographic private key.
+    /// </summary>
+    /// <param name="parameters">The elliptic curve parameters from which to create a new ECDSA cryptographic private key.</param>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance.</returns>
+    public static EcdsaPrivateKey Create(ECParameters parameters)
+    {
+        using ECDsa key = ECDsa.Create(parameters);
+        byte[] keyData = key.ExportECPrivateKey();
+        return new EcdsaPrivateKey(keyData);
+    }
+}

OnixLabs.Security.Cryptography/EcdsaPrivateKey.Export.cs

@@ -0,0 +1,43 @@
+// Copyright 2020 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Security.Cryptography;
+
+namespace OnixLabs.Security.Cryptography;
+
+public sealed partial class EcdsaPrivateKey
+{
+    /// <summary>
+    /// Exports the ECDSA cryptographic private key data in PKCS #8 format.
+    /// </summary>
+    /// <returns>Returns a new <see cref="T:Byte[]"/> instance containing the ECDSA cryptographic private key data in PKCS #8 format.</returns>
+    public override byte[] ExportPkcs8PrivateKey()
+    {
+        using ECDsa key = ImportKeyData();
+        return key.ExportPkcs8PrivateKey();
+    }
+
+    /// <summary>
+    /// Exports the ECDSA cryptographic private key data in encrypted PKCS #8 format.
+    /// </summary>
+    /// <param name="password">The password to use for encryption.</param>
+    /// <param name="parameters">The parameters required for password based encryption.</param>
+    /// <returns>Returns a new <see cref="T:Byte[]"/> instance containing the ECDSA cryptographic private key data in PKCS #8 format.</returns>
+    public override byte[] ExportPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters parameters)
+    {
+        using ECDsa key = ImportKeyData();
+        return key.ExportEncryptedPkcs8PrivateKey(password, parameters);
+    }
+}

OnixLabs.Security.Cryptography/EcdsaPrivateKey.Get.cs

@@ -0,0 +1,31 @@
+// Copyright 2020 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Security.Cryptography;
+
+namespace OnixLabs.Security.Cryptography;
+
+public sealed partial class EcdsaPrivateKey
+{
+    /// <summary>
+    /// Gets the ECDSA cryptographic public key component from the current ECDSA cryptographic private key.
+    /// </summary>
+    /// <returns>Returns a new <see cref="EcdsaPublicKey"/> instance containing the ECDSA cryptographic public key component from the current ECDSA cryptographic private key.</returns>
+    public override EcdsaPublicKey GetPublicKey()
+    {
+        using ECDsa key = ImportKeyData();
+        byte[] keyData = key.ExportSubjectPublicKeyInfo();
+        return new EcdsaPublicKey(keyData);
+    }
+}

OnixLabs.Security.Cryptography/EcdsaPrivateKey.Import.cs

@@ -0,0 +1,82 @@
+// Copyright 2020 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Security.Cryptography;
+
+namespace OnixLabs.Security.Cryptography;
+
+public sealed partial class EcdsaPrivateKey
+{
+    /// <summary>
+    /// Imports the ECDSA cryptographic private key data in PKCS #8 format.
+    /// </summary>
+    /// <param name="data">The cryptographic private key data to import.</param>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance from the imported cryptographic private key data.</returns>
+    public static EcdsaPrivateKey ImportPkcs8PrivateKey(ReadOnlySpan<byte> data)
+    {
+        return ImportPkcs8PrivateKey(data, out int _);
+    }
+
+    /// <summary>
+    /// Imports the ECDSA cryptographic private key data in PKCS #8 format.
+    /// </summary>
+    /// <param name="data">The cryptographic private key data to import.</param>
+    /// <param name="bytesRead">The number of bytes read from the input data.</param>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance from the imported cryptographic private key data.</returns>
+    public static EcdsaPrivateKey ImportPkcs8PrivateKey(ReadOnlySpan<byte> data, out int bytesRead)
+    {
+        using ECDsa key = ECDsa.Create();
+        key.ImportPkcs8PrivateKey(data, out bytesRead);
+        byte[] keyData = key.ExportECPrivateKey();
+        return new EcdsaPrivateKey(keyData);
+    }
+
+    /// <summary>
+    /// Imports the ECDSA cryptographic private key data in encrypted PKCS #8 format.
+    /// </summary>
+    /// <param name="data">The cryptographic private key data to import.</param>
+    /// <param name="password">The password required for password based decryption.</param>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance from the imported cryptographic private key data.</returns>
+    public static EcdsaPrivateKey ImportPkcs8PrivateKey(ReadOnlySpan<byte> data, ReadOnlySpan<char> password)
+    {
+        return ImportPkcs8PrivateKey(data, password, out int _);
+    }
+
+    /// <summary>
+    /// Imports the ECDSA cryptographic private key data in encrypted PKCS #8 format.
+    /// </summary>
+    /// <param name="data">The cryptographic private key data to import.</param>
+    /// <param name="password">The password required for password based decryption.</param>
+    /// <param name="bytesRead">The number of bytes read from the input data.</param>
+    /// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance from the imported cryptographic private key data.</returns>
+    public static EcdsaPrivateKey ImportPkcs8PrivateKey(ReadOnlySpan<byte> data, ReadOnlySpan<char> password, out int bytesRead)
+    {
+        using ECDsa key = ECDsa.Create();
+        key.ImportEncryptedPkcs8PrivateKey(password, data, out bytesRead);
+        byte[] keyData = key.ExportECPrivateKey();
+        return new EcdsaPrivateKey(keyData);
+    }
+
+    /// <summary>
+    /// Imports the key data into a new <see cref="ECDsa"/> instance.
+    /// </summary>
+    /// <returns>Returns a new <see cref="ECDsa"/> instance containing the imported key data.</returns>
+    private ECDsa ImportKeyData()
+    {
+        ECDsa algorithm = ECDsa.Create();
+        algorithm.ImportECPrivateKey(KeyData, out int _);
+        return algorithm;
+    }
+}