Skip to content

Commit 2950a0c

Browse files
MrMatthewLaytonMrMatthewLayton
authored
Added EC Diffie-Hellman public and private keys. (#45)
1 parent a5d96b9 commit 2950a0c

14 files changed

+633
-0
lines changed

‎OnixLabs.Security.Cryptography.UnitTests/EcdhKeyTests.cs

+56
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System.Security.Cryptography;
16+
using Xunit;
17+
18+
namespace OnixLabs.Security.Cryptography.UnitTests;
19+
20+
public sealed class EcdhKeyTests
21+
{
22+
[Fact(DisplayName = "EC Diffie-Hellman DeriveSharedSecret should produce identical secrets")]
23+
public void EcdhDeriveSharedSecretShouldProduceIdenticalSecrets()
24+
{
25+
// Given
26+
IEcdhPrivateKey alice = EcdhPrivateKey.Create();
27+
IEcdhPrivateKey bob = EcdhPrivateKey.Create();
28+
29+
// When
30+
Secret aliceSecret = alice.DeriveSharedSecret(bob.GetPublicKey());
31+
Secret bobSecret = bob.DeriveSharedSecret(alice.GetPublicKey());
32+
33+
// Then
34+
Assert.Equal(aliceSecret, bobSecret);
35+
}
36+
37+
[Fact(DisplayName = "EC Diffie-Hellman PKCS #8 round-trip DeriveSharedSecret should produce identical secrets")]
38+
public void EcdhPkcs8RoundTripDeriveSharedSecretShouldProduceIdenticalSecrets()
39+
{
40+
// Given
41+
using HashAlgorithm algorithm = SHA256.Create();
42+
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
43+
byte[] aliceExportedBytes = EcdhPrivateKey.Create().ExportPkcs8PrivateKey("AlicePassword", parameters);
44+
byte[] bobExportedBytes = EcdhPrivateKey.Create().ExportPkcs8PrivateKey("BobPassword", parameters);
45+
46+
IEcdhPrivateKey alice = EcdhPrivateKey.ImportPkcs8PrivateKey(aliceExportedBytes, "AlicePassword");
47+
IEcdhPrivateKey bob = EcdhPrivateKey.ImportPkcs8PrivateKey(bobExportedBytes, "BobPassword");
48+
49+
// When
50+
Secret aliceSecret = alice.DeriveSharedSecret(bob.GetPublicKey());
51+
Secret bobSecret = bob.DeriveSharedSecret(alice.GetPublicKey());
52+
53+
// Then
54+
Assert.Equal(aliceSecret, bobSecret);
55+
}
56+
}

‎OnixLabs.Security.Cryptography.UnitTests/SecretTests.cs

+123
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using Xunit;
16+
17+
namespace OnixLabs.Security.Cryptography.UnitTests;
18+
19+
public sealed class SecretTests
20+
{
21+
[Fact(DisplayName = "Secret should be constructable from bytes")]
22+
public void SecretShouldBeConstructableFromBytes()
23+
{
24+
// Given
25+
byte[] value = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
26+
const string expected = "000102030405060708090a0b0c0d0e0f";
27+
28+
// When
29+
Secret candidate = new(value);
30+
string actual = candidate.ToString();
31+
32+
// Then
33+
Assert.Equal(expected, actual);
34+
}
35+
36+
[Fact(DisplayName = "Secret value should not be modified when altering the original byte array")]
37+
public void SecretValueShouldNotBeModifiedWhenAlteringTheOriginalByteArray()
38+
{
39+
// Given
40+
byte[] value = [1, 2, 3, 4];
41+
Secret candidate = new(value);
42+
const string expected = "01020304";
43+
44+
// When
45+
value[0] = 0;
46+
string actual = candidate.ToString();
47+
48+
// Then
49+
Assert.Equal(expected, actual);
50+
}
51+
52+
[Fact(DisplayName = "Secret value should not be modified when altering the obtained byte array")]
53+
public void SecretValueShouldNotBeModifiedWhenAlteringTheObtainedByteArray()
54+
{
55+
// Given
56+
Secret candidate = new([1, 2, 3, 4]);
57+
const string expected = "01020304";
58+
59+
// When
60+
byte[] value = candidate.ToByteArray();
61+
value[0] = 0;
62+
string actual = candidate.ToString();
63+
64+
// Then
65+
Assert.Equal(expected, actual);
66+
}
67+
68+
[Fact(DisplayName = "Identical secret values should be considered equal")]
69+
public void IdenticalSecretValuesShouldBeConsideredEqual()
70+
{
71+
// Given
72+
Secret left = new([1, 2, 3, 4]);
73+
Secret right = new([1, 2, 3, 4]);
74+
75+
// Then
76+
Assert.Equal(left, right);
77+
Assert.True(left.Equals(right));
78+
Assert.True(left == right);
79+
}
80+
81+
[Fact(DisplayName = "Different secret values should not be considered equal")]
82+
public void DifferentSecretValuesShouldNotBeConsideredEqual()
83+
{
84+
// Given
85+
Secret left = new([1, 2, 3, 4]);
86+
Secret right = new([5, 6, 7, 8]);
87+
88+
// Then
89+
Assert.NotEqual(left, right);
90+
Assert.False(left.Equals(right));
91+
Assert.True(left != right);
92+
}
93+
94+
[Fact(DisplayName = "Identical secret values should produce identical hash codes")]
95+
public void IdenticalSecretValuesShouldProduceIdenticalSecretCodes()
96+
{
97+
// Given
98+
Secret left = new([1, 2, 3, 4]);
99+
Secret right = new([1, 2, 3, 4]);
100+
101+
// When
102+
int leftHashCode = left.GetHashCode();
103+
int rightHashCode = right.GetHashCode();
104+
105+
// Then
106+
Assert.Equal(leftHashCode, rightHashCode);
107+
}
108+
109+
[Fact(DisplayName = "Different secret values should produce different hash codes")]
110+
public void DifferentSecretValuesShouldProduceDifferentSecretCodes()
111+
{
112+
// Given
113+
Secret left = new([1, 2, 3, 4]);
114+
Secret right = new([5, 6, 7, 8]);
115+
116+
// When
117+
int leftHashCode = left.GetHashCode();
118+
int rightHashCode = right.GetHashCode();
119+
120+
// Then
121+
Assert.NotEqual(leftHashCode, rightHashCode);
122+
}
123+
}

‎OnixLabs.Security.Cryptography/EcdhPrivateKey.Create.cs

+56
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System;
16+
using System.Security.Cryptography;
17+
18+
namespace OnixLabs.Security.Cryptography;
19+
20+
public sealed partial class EcdhPrivateKey
21+
{
22+
/// <summary>
23+
/// Creates a new EC Diffie-Hellman cryptographic private key.
24+
/// </summary>
25+
/// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance.</returns>
26+
public static EcdhPrivateKey Create()
27+
{
28+
using ECDiffieHellman key = ECDiffieHellman.Create();
29+
byte[] keyData = key.ExportECPrivateKey();
30+
return new EcdhPrivateKey(keyData);
31+
}
32+
33+
/// <summary>
34+
/// Creates a new EC Diffie-Hellman cryptographic private key.
35+
/// </summary>
36+
/// <param name="curve">The elliptic curve from which to create a new EC Diffie-Hellman cryptographic private key.</param>
37+
/// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance.</returns>
38+
public static EcdhPrivateKey Create(ECCurve curve)
39+
{
40+
using ECDiffieHellman key = ECDiffieHellman.Create(curve);
41+
byte[] keyData = key.ExportECPrivateKey();
42+
return new EcdhPrivateKey(keyData);
43+
}
44+
45+
/// <summary>
46+
/// Creates a new EC Diffie-Hellman cryptographic private key.
47+
/// </summary>
48+
/// <param name="parameters">The elliptic curve parameters from which to create a new EC Diffie-Hellman cryptographic private key.</param>
49+
/// <returns>Returns a new <see cref="EcdsaPrivateKey"/> instance.</returns>
50+
public static EcdhPrivateKey Create(ECParameters parameters)
51+
{
52+
using ECDiffieHellman key = ECDiffieHellman.Create(parameters);
53+
byte[] keyData = key.ExportECPrivateKey();
54+
return new EcdhPrivateKey(keyData);
55+
}
56+
}

‎OnixLabs.Security.Cryptography/EcdhPrivateKey.Derive.cs

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System.Security.Cryptography;
16+
17+
namespace OnixLabs.Security.Cryptography;
18+
19+
public sealed partial class EcdhPrivateKey
20+
{
21+
/// <summary>
22+
/// Derives a cryptographic shared secret from the current EC Diffie-Hellman cryptographic private key, and the specified cryptographic public key.
23+
/// </summary>
24+
/// <param name="publicKey">The EC Diffie-Hellman cryptographic public key from which to derive cryptographic shared secret.</param>
25+
/// <returns>Returns a cryptographic shared secret, derived from the current EC Diffie-Hellman cryptographic private key, and the specified cryptographic public key.</returns>
26+
public Secret DeriveSharedSecret(IEcdhPublicKey publicKey)
27+
{
28+
using ECDiffieHellman ourKey = ImportKeyData();
29+
using ECDiffieHellman theirKey = ECDiffieHellman.Create();
30+
theirKey.ImportSubjectPublicKeyInfo(publicKey.ToByteArray(), out int _);
31+
byte[] secretData = ourKey.DeriveKeyMaterial(theirKey.PublicKey);
32+
return new Secret(secretData);
33+
}
34+
}

‎OnixLabs.Security.Cryptography/EcdhPrivateKey.Export.cs

+43
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System;
16+
using System.Security.Cryptography;
17+
18+
namespace OnixLabs.Security.Cryptography;
19+
20+
public sealed partial class EcdhPrivateKey
21+
{
22+
/// <summary>
23+
/// Exports the current EC Diffie-Hellman cryptographic private key data in PKCS #8 format.
24+
/// </summary>
25+
/// <returns>Returns a new <see cref="T:Byte[]"/> instance containing the EC Diffie-Hellman cryptographic private key data in PKCS #8 format.</returns>
26+
public byte[] ExportPkcs8PrivateKey()
27+
{
28+
using ECDiffieHellman key = ImportKeyData();
29+
return key.ExportPkcs8PrivateKey();
30+
}
31+
32+
/// <summary>
33+
/// Exports the EC Diffie-Hellman cryptographic private key data in encrypted PKCS #8 format.
34+
/// </summary>
35+
/// <param name="password">The password to use for encryption.</param>
36+
/// <param name="parameters">The parameters required for password based encryption.</param>
37+
/// <returns>Returns a new <see cref="T:Byte[]"/> instance containing the EC Diffie-Hellman cryptographic private key data in PKCS #8 format.</returns>
38+
public byte[] ExportPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters parameters)
39+
{
40+
using ECDiffieHellman key = ImportKeyData();
41+
return key.ExportEncryptedPkcs8PrivateKey(password, parameters);
42+
}
43+
}

‎OnixLabs.Security.Cryptography/EcdhPrivateKey.Get.cs

+31
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System.Security.Cryptography;
16+
17+
namespace OnixLabs.Security.Cryptography;
18+
19+
public sealed partial class EcdhPrivateKey
20+
{
21+
/// <summary>
22+
/// Gets the EC Diffie-Hellman cryptographic public key component from the current cryptographic private key.
23+
/// </summary>
24+
/// <returns>Returns the EC Diffie-Hellman cryptographic public key component from the current cryptographic private key.</returns>
25+
public EcdhPublicKey GetPublicKey()
26+
{
27+
using ECDiffieHellman key = ImportKeyData();
28+
byte[] keyData = key.ExportSubjectPublicKeyInfo();
29+
return new EcdhPublicKey(keyData);
30+
}
31+
}

0 commit comments

Comments
 (0)