Skip to content

Commit f246e16

Browse files
MrMatthewLaytonMrMatthewLayton
authored
Refactored and added cryptographic import and export methods. This now includes support for binary, PKCS8, and PEM formatted imports and exports. (#88)
1 parent 03568e1 commit f246e16

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

47 files changed

+2148
-370
lines changed

‎Directory.Build.props

+3-3
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,8 @@
88
<NeutralLanguage>en</NeutralLanguage>
99
<Copyright>Copyright © ONIXLabs 2020</Copyright>
1010
<RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
11-
<Version>10.1.0</Version>
12-
<PackageVersion>10.1.0</PackageVersion>
13-
<AssemblyVersion>10.1.0</AssemblyVersion>
11+
<Version>11.0.0</Version>
12+
<PackageVersion>11.0.0</PackageVersion>
13+
<AssemblyVersion>11.0.0</AssemblyVersion>
1414
</PropertyGroup>
1515
</Project>

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

+118-4
Original file line numberDiff line numberDiff line change
@@ -40,11 +40,11 @@ public void EcdhPkcs8RoundTripDeriveSharedSecretShouldProduceIdenticalSecrets()
4040
// Given
4141
using HashAlgorithm algorithm = SHA256.Create();
4242
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
43-
byte[] aliceExportedBytes = EcdhPrivateKey.Create().ExportPkcs8PrivateKey("AlicePassword", parameters);
44-
byte[] bobExportedBytes = EcdhPrivateKey.Create().ExportPkcs8PrivateKey("BobPassword", parameters);
43+
byte[] aliceExportedBytes = EcdhPrivateKey.Create().ExportPkcs8("AlicePassword", parameters);
44+
byte[] bobExportedBytes = EcdhPrivateKey.Create().ExportPkcs8("BobPassword", parameters);
4545

46-
IEcdhPrivateKey alice = EcdhPrivateKey.ImportPkcs8PrivateKey(aliceExportedBytes, "AlicePassword");
47-
IEcdhPrivateKey bob = EcdhPrivateKey.ImportPkcs8PrivateKey(bobExportedBytes, "BobPassword");
46+
IEcdhPrivateKey alice = EcdhPrivateKey.ImportPkcs8(aliceExportedBytes, "AlicePassword");
47+
IEcdhPrivateKey bob = EcdhPrivateKey.ImportPkcs8(bobExportedBytes, "BobPassword");
4848

4949
// When
5050
Secret aliceSecret = alice.DeriveSharedSecret(bob.GetPublicKey());
@@ -53,4 +53,118 @@ public void EcdhPkcs8RoundTripDeriveSharedSecretShouldProduceIdenticalSecrets()
5353
// Then
5454
Assert.Equal(aliceSecret, bobSecret);
5555
}
56+
57+
[Fact(DisplayName = "EcdhPrivateKey should be exportable and importable")]
58+
public void EcdhPrivateKeyShouldBeExportableAndImportable()
59+
{
60+
// Given
61+
EcdhPrivateKey expected = EcdhPrivateKey.Create();
62+
63+
// When
64+
byte[] privateKeyData = expected.Export();
65+
EcdhPrivateKey actual = EcdhPrivateKey.Import(privateKeyData);
66+
67+
// Then
68+
Assert.Equal(expected, actual);
69+
}
70+
71+
[Fact(DisplayName = "EcdhPrivateKey should be exportable and importable as PEM")]
72+
public void EcdhPrivateKeyShouldBeExportableAndImportableAsPem()
73+
{
74+
// Given
75+
EcdhPrivateKey expected = EcdhPrivateKey.Create();
76+
77+
// When
78+
string privateKeyData = expected.ExportPem();
79+
EcdhPrivateKey actual = EcdhPrivateKey.ImportPem(privateKeyData);
80+
81+
// Then
82+
Assert.Equal(expected, actual);
83+
}
84+
85+
[Fact(DisplayName = "EcdhPrivateKey should be exportable and importable as PKCS8")]
86+
public void EcdhPrivateKeyShouldBeExportableAndImportableAsPkcs8()
87+
{
88+
// Given
89+
EcdhPrivateKey expected = EcdhPrivateKey.Create();
90+
91+
// When
92+
byte[] privateKeyData = expected.ExportPkcs8();
93+
EcdhPrivateKey actual = EcdhPrivateKey.ImportPkcs8(privateKeyData);
94+
95+
// Then
96+
Assert.Equal(expected, actual);
97+
}
98+
99+
[Fact(DisplayName = "EcdhPrivateKey should be exportable and importable as PKCS8 PEM")]
100+
public void EcdhPrivateKeyShouldBeExportableAndImportableAsPkcs8Pem()
101+
{
102+
// Given
103+
EcdhPrivateKey expected = EcdhPrivateKey.Create();
104+
105+
// When
106+
string privateKeyData = expected.ExportPkcs8Pem();
107+
EcdhPrivateKey actual = EcdhPrivateKey.ImportPem(privateKeyData);
108+
109+
// Then
110+
Assert.Equal(expected, actual);
111+
}
112+
113+
[Fact(DisplayName = "EcdhPrivateKey should be exportable and importable as encrypted PKCS8")]
114+
public void EcdhPrivateKeyShouldBeExportableAndImportableAsEncryptedPkcs8()
115+
{
116+
// Given
117+
EcdhPrivateKey expected = EcdhPrivateKey.Create();
118+
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
119+
120+
// When
121+
byte[] privateKeyData = expected.ExportPkcs8("Password", parameters);
122+
EcdhPrivateKey actual = EcdhPrivateKey.ImportPkcs8(privateKeyData, "Password");
123+
124+
// Then
125+
Assert.Equal(expected, actual);
126+
}
127+
128+
[Fact(DisplayName = "EcdhPrivateKey should be exportable and importable as encrypted PKCS8 PEM")]
129+
public void EcdhPrivateKeyShouldBeExportableAndImportableAsEncryptedPkcs8Pem()
130+
{
131+
// Given
132+
EcdhPrivateKey expected = EcdhPrivateKey.Create();
133+
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
134+
135+
// When
136+
string privateKeyData = expected.ExportPkcs8Pem("Password", parameters);
137+
EcdhPrivateKey actual = EcdhPrivateKey.ImportPem(privateKeyData, "Password");
138+
139+
// Then
140+
Assert.Equal(expected, actual);
141+
}
142+
143+
[Fact(DisplayName = "EcdhPublicKey should be exportable and importable")]
144+
public void EcdhPublicKeyShouldBeExportableAndImportable()
145+
{
146+
// Given
147+
EcdhPublicKey expected = EcdhPrivateKey.Create().GetPublicKey();
148+
149+
// When
150+
byte[] privateKeyData = expected.Export();
151+
EcdhPublicKey actual = EcdhPublicKey.Import(privateKeyData);
152+
153+
// Then
154+
Assert.Equal(expected, actual);
155+
}
156+
157+
[Fact(DisplayName = "EcdhPublicKey should be exportable and importable as PEM")]
158+
public void EcdhPublicKeyShouldBeExportableAndImportableAsPem()
159+
{
160+
// Given
161+
EcdhPublicKey expected = EcdhPrivateKey.Create().GetPublicKey();
162+
163+
// When
164+
string privateKeyData = expected.ExportPem();
165+
EcdhPublicKey actual = EcdhPublicKey.ImportPem(privateKeyData);
166+
167+
// Then
168+
Assert.Equal(expected, actual);
169+
}
56170
}

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

+116-2
Original file line numberDiff line numberDiff line change
@@ -49,8 +49,8 @@ public void EcdsaPkcs8RoundTripSignAndVerifyShouldSucceed()
4949
ReadOnlySpan<byte> data = Salt.CreateNonZero(2048).AsReadOnlySpan();
5050
using HashAlgorithm algorithm = SHA256.Create();
5151
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
52-
byte[] exportedPrivateKey = EcdsaPrivateKey.Create().ExportPkcs8PrivateKey("Password", parameters);
53-
IEcdsaPrivateKey privateKey = EcdsaPrivateKey.ImportPkcs8PrivateKey(exportedPrivateKey, "Password");
52+
byte[] exportedPrivateKey = EcdsaPrivateKey.Create().ExportPkcs8("Password", parameters);
53+
IEcdsaPrivateKey privateKey = EcdsaPrivateKey.ImportPkcs8(exportedPrivateKey, "Password");
5454
IEcdsaPublicKey publicKey = privateKey.GetPublicKey();
5555

5656
// When
@@ -59,4 +59,118 @@ public void EcdsaPkcs8RoundTripSignAndVerifyShouldSucceed()
5959
// Then
6060
Assert.True(publicKey.IsDataValid(signature, data, algorithm));
6161
}
62+
63+
[Fact(DisplayName = "EcdsaPrivateKey should be exportable and importable")]
64+
public void EcdsaPrivateKeyShouldBeExportableAndImportable()
65+
{
66+
// Given
67+
EcdsaPrivateKey expected = EcdsaPrivateKey.Create();
68+
69+
// When
70+
byte[] privateKeyData = expected.Export();
71+
EcdsaPrivateKey actual = EcdsaPrivateKey.Import(privateKeyData);
72+
73+
// Then
74+
Assert.Equal(expected, actual);
75+
}
76+
77+
[Fact(DisplayName = "EcdsaPrivateKey should be exportable and importable as PEM")]
78+
public void EcdsaPrivateKeyShouldBeExportableAndImportableAsPem()
79+
{
80+
// Given
81+
EcdsaPrivateKey expected = EcdsaPrivateKey.Create();
82+
83+
// When
84+
string privateKeyData = expected.ExportPem();
85+
EcdsaPrivateKey actual = EcdsaPrivateKey.ImportPem(privateKeyData);
86+
87+
// Then
88+
Assert.Equal(expected, actual);
89+
}
90+
91+
[Fact(DisplayName = "EcdsaPrivateKey should be exportable and importable as PKCS8")]
92+
public void EcdsaPrivateKeyShouldBeExportableAndImportableAsPkcs8()
93+
{
94+
// Given
95+
EcdsaPrivateKey expected = EcdsaPrivateKey.Create();
96+
97+
// When
98+
byte[] privateKeyData = expected.ExportPkcs8();
99+
EcdsaPrivateKey actual = EcdsaPrivateKey.ImportPkcs8(privateKeyData);
100+
101+
// Then
102+
Assert.Equal(expected, actual);
103+
}
104+
105+
[Fact(DisplayName = "EcdsaPrivateKey should be exportable and importable as PKCS8 PEM")]
106+
public void EcdsaPrivateKeyShouldBeExportableAndImportableAsPkcs8Pem()
107+
{
108+
// Given
109+
EcdsaPrivateKey expected = EcdsaPrivateKey.Create();
110+
111+
// When
112+
string privateKeyData = expected.ExportPkcs8Pem();
113+
EcdsaPrivateKey actual = EcdsaPrivateKey.ImportPem(privateKeyData);
114+
115+
// Then
116+
Assert.Equal(expected, actual);
117+
}
118+
119+
[Fact(DisplayName = "EcdsaPrivateKey should be exportable and importable as encrypted PKCS8")]
120+
public void EcdsaPrivateKeyShouldBeExportableAndImportableAsEncryptedPkcs8()
121+
{
122+
// Given
123+
EcdsaPrivateKey expected = EcdsaPrivateKey.Create();
124+
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
125+
126+
// When
127+
byte[] privateKeyData = expected.ExportPkcs8("Password", parameters);
128+
EcdsaPrivateKey actual = EcdsaPrivateKey.ImportPkcs8(privateKeyData, "Password");
129+
130+
// Then
131+
Assert.Equal(expected, actual);
132+
}
133+
134+
[Fact(DisplayName = "EcdsaPrivateKey should be exportable and importable as encrypted PKCS8 PEM")]
135+
public void EcdsaPrivateKeyShouldBeExportableAndImportableAsEncryptedPkcs8Pem()
136+
{
137+
// Given
138+
EcdsaPrivateKey expected = EcdsaPrivateKey.Create();
139+
PbeParameters parameters = new(PbeEncryptionAlgorithm.Aes256Cbc, HashAlgorithmName.SHA256, 10);
140+
141+
// When
142+
string privateKeyData = expected.ExportPkcs8Pem("Password", parameters);
143+
EcdsaPrivateKey actual = EcdsaPrivateKey.ImportPem(privateKeyData, "Password");
144+
145+
// Then
146+
Assert.Equal(expected, actual);
147+
}
148+
149+
[Fact(DisplayName = "EcdsaPublicKey should be exportable and importable")]
150+
public void EcdsaPublicKeyShouldBeExportableAndImportable()
151+
{
152+
// Given
153+
EcdsaPublicKey expected = EcdsaPrivateKey.Create().GetPublicKey();
154+
155+
// When
156+
byte[] privateKeyData = expected.Export();
157+
EcdsaPublicKey actual = EcdsaPublicKey.Import(privateKeyData);
158+
159+
// Then
160+
Assert.Equal(expected, actual);
161+
}
162+
163+
[Fact(DisplayName = "EcdsaPublicKey should be exportable and importable as PEM")]
164+
public void EcdsaPublicKeyShouldBeExportableAndImportableAsPem()
165+
{
166+
// Given
167+
EcdsaPublicKey expected = EcdsaPrivateKey.Create().GetPublicKey();
168+
169+
// When
170+
string privateKeyData = expected.ExportPem();
171+
EcdsaPublicKey actual = EcdsaPublicKey.ImportPem(privateKeyData);
172+
173+
// Then
174+
Assert.Equal(expected, actual);
175+
}
62176
}

0 commit comments

Comments
 (0)