Added tests for EdDsa as AsymmetricAlgorithm

src/ScottBrady.IdentityModel/Crypto/ExtendedSecurityAlgorithms.cs

@@ -13,12 +13,18 @@ public static class ExtendedSecurityAlgorithms
  // https://tools.ietf.org/html/rfc8037#section-5
  public const string EdDsa = "EdDSA";
 
- public class Curves
+ public static class Curves
  {
  // https://tools.ietf.org/html/rfc8037#section-5
  public const string Ed25519 = "Ed25519";
  public const string Ed448 = "Ed448";
  public const string X25519 = "X25519";
  public const string X448 = "X448";
  }
+
+ public static class KeyTypes
+ {
+ // https://datatracker.ietf.org/doc/html/draft-ietf-jose-cfrg-curves-06#section-2
+ public const string Ecdh = "OKP";
+ }
 }

src/ScottBrady.IdentityModel/Extensions/ExtendedJsonWebKeyConverter.cs

@@ -14,7 +14,7 @@ public static JsonWebKey ConvertFromEdDsaSecurityKey(EdDsaSecurityKey securityKe
  Crv = parameters.Curve,
  X = parameters.X != null ? Base64UrlEncoder.Encode(parameters.X) : null,
  D = parameters.D != null ? Base64UrlEncoder.Encode(parameters.D) : null,
- Kty = ExtendedJsonWebAlgorithmsKeyTypes.ECDH,
+ Kty = ExtendedSecurityAlgorithms.KeyTypes.Ecdh,
  Alg = ExtendedSecurityAlgorithms.EdDsa,
  CryptoProviderFactory = securityKey.CryptoProviderFactory,
  };

src/ScottBrady.IdentityModel/ScottBrady.IdentityModel.csproj

@@ -11,7 +11,7 @@
  <PackageTags>IdentityModel Base16 Base62 EdDSA</PackageTags>
  <IncludeSymbols>true</IncludeSymbols>
  <GenerateDocumentationFile>true</GenerateDocumentationFile>
- <Version>3.1.0</Version>
+ <Version>4.0.0</Version>
  <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
  <NoWarn>1591</NoWarn>
  </PropertyGroup>

src/ScottBrady.IdentityModel/Tokens/EdDsa.cs

@@ -10,46 +10,59 @@
 
 namespace ScottBrady.IdentityModel.Tokens;
 
-public class EdDsa: AsymmetricAlgorithm
+public class EdDsa : AsymmetricAlgorithm
 {
  internal EdDsaParameters Parameters { get; private init; }
+ internal AsymmetricKeyParameter PrivateKeyParameter { get; private init; }
+ internal AsymmetricKeyParameter PublicKeyParameter { get; private init; }
 
  private EdDsa() { }
 
  public static EdDsa Create(EdDsaParameters parameters)
  {
  if (parameters == null) throw new ArgumentNullException(nameof(parameters));
-
+ 
  parameters.Validate();
- return new EdDsa {Parameters = parameters};
+ return new EdDsa
+ {
+ Parameters = parameters,
+ PrivateKeyParameter = CreatePrivateKeyParameter(parameters),
+ PublicKeyParameter = CreatePublicKeyParameter(parameters)
+ };
  }
 
  /// <summary>
  /// Create new key for EdDSA.
  /// </summary>
  /// <param name="curve">Create key for curve Ed25519 or Ed448.</param>
- public static EdDsa Create(string curve)
+ public new static EdDsa Create(string curve)
  {
  if (string.IsNullOrWhiteSpace(curve)) throw new ArgumentNullException(nameof(curve));
 
+ IAsymmetricCipherKeyPairGenerator generator;
  if (curve == ExtendedSecurityAlgorithms.Curves.Ed25519)
  {
- var generator = new Ed25519KeyPairGenerator();
+ generator = new Ed25519KeyPairGenerator();
  generator.Init(new Ed25519KeyGenerationParameters(new SecureRandom()));
- var keyPair = generator.GenerateKeyPair();
- return new EdDsa {Parameters = new EdDsaParameters(keyPair, curve)};
+
  }
-
- if (curve == ExtendedSecurityAlgorithms.Curves.Ed448)
+ else if (curve == ExtendedSecurityAlgorithms.Curves.Ed448)
  {
- var generator = new Ed448KeyPairGenerator();
+ generator = new Ed448KeyPairGenerator();
  generator.Init(new Ed448KeyGenerationParameters(new SecureRandom()));
- var keyPair = generator.GenerateKeyPair();
-
- return new EdDsa {Parameters = new EdDsaParameters(keyPair, curve)};
  }
-
- throw new NotSupportedException("Unsupported EdDSA curve");
+ else
+ {
+ throw new NotSupportedException("Unsupported EdDSA curve"); 
+ }
+
+ var keyPair = generator.GenerateKeyPair();
+ return new EdDsa
+ {
+ Parameters = new EdDsaParameters(keyPair, curve),
+ PrivateKeyParameter = keyPair.Private,
+ PublicKeyParameter = keyPair.Public
+ };
  }
 
  /// <summary>
@@ -61,12 +74,23 @@ public static EdDsa CreateFromJwk(string jwk)
  throw new NotImplementedException();
  }
 
+ public override string KeyExchangeAlgorithm => null;
+ public override string SignatureAlgorithm => ExtendedSecurityAlgorithms.EdDsa;
+ public override int KeySize => Parameters.D?.Length ?? Parameters.X?.Length ?? throw new InvalidOperationException("Missing EdDsa key");
+
+ public override KeySizes[] LegalKeySizes => Parameters.Curve switch
+ {
+ ExtendedSecurityAlgorithms.Curves.Ed25519 => new[] { new KeySizes(32, 32, 0) },
+ ExtendedSecurityAlgorithms.Curves.Ed448 => new[] { new KeySizes(57, 57, 0) },
+ _ => throw new NotSupportedException()
+ };
+
  public byte[] Sign(byte[] input)
  {
  if (input == null) throw new ArgumentNullException(nameof(input));
 
  var signer = CreateSigner();
- signer.Init(true, CreatePrivateKeyParameter());
+ signer.Init(true, PrivateKeyParameter);
  signer.BlockUpdate(input, 0, input.Length);
 
  return signer.GenerateSignature();
@@ -89,28 +113,32 @@ public bool Verify(byte[] input, byte[] signature)
  if (signature == null) throw new ArgumentNullException(nameof(signature));
 
  var validator = CreateSigner();
- validator.Init(false, CreatePublicKeyParameter());
+ validator.Init(false, PublicKeyParameter);
  validator.BlockUpdate(input, 0, input.Length);
 
  return validator.VerifySignature(signature);
  }
 
- private AsymmetricKeyParameter CreatePrivateKeyParameter()
+ private static AsymmetricKeyParameter CreatePrivateKeyParameter(EdDsaParameters parameters)
  {
- return Parameters.Curve switch
+ if (parameters.D == null) return null;
+
+ return parameters.Curve switch
  {
- ExtendedSecurityAlgorithms.Curves.Ed25519 => new Ed25519PrivateKeyParameters(Parameters.D, 0),
- ExtendedSecurityAlgorithms.Curves.Ed448 => new Ed448PrivateKeyParameters(Parameters.D, 0),
+ ExtendedSecurityAlgorithms.Curves.Ed25519 => new Ed25519PrivateKeyParameters(parameters.D),
+ ExtendedSecurityAlgorithms.Curves.Ed448 => new Ed448PrivateKeyParameters(parameters.D),
  _ => throw new NotSupportedException()
  };
  }
 
- private AsymmetricKeyParameter CreatePublicKeyParameter()
+ private static AsymmetricKeyParameter CreatePublicKeyParameter(EdDsaParameters parameters)
  {
- return Parameters.Curve switch
+ if (parameters.X == null) return null;
+
+ return parameters.Curve switch
  {
- ExtendedSecurityAlgorithms.Curves.Ed25519 => new Ed25519PublicKeyParameters(Parameters.X, 0),
- ExtendedSecurityAlgorithms.Curves.Ed448 => new Ed448PublicKeyParameters(Parameters.X, 0),
+ ExtendedSecurityAlgorithms.Curves.Ed25519 => new Ed25519PublicKeyParameters(parameters.X),
+ ExtendedSecurityAlgorithms.Curves.Ed448 => new Ed448PublicKeyParameters(parameters.X),
  _ => throw new NotSupportedException()
  };
  }
@@ -124,4 +152,8 @@ private ISigner CreateSigner()
  _ => throw new NotSupportedException()
  };
  }
+
+ public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<char> password) => throw new NotImplementedException();
+ public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<byte> passwordBytes) => throw new NotImplementedException();
+ public override void ImportFromPem(ReadOnlySpan<char> input) => throw new NotImplementedException();
 }

src/ScottBrady.IdentityModel/Tokens/EdDsaSecurityKey.cs

@@ -17,9 +17,9 @@ private EdDsaSecurityKey()
  CryptoProviderFactory.CustomCryptoProvider = new ExtendedCryptoProvider();
  }
 
- public EdDsaSecurityKey(EdDsa edDsa) : this()
+ public EdDsaSecurityKey(EdDsa edDsaCreation) : this()
  {
- EdDsa = edDsa ?? throw new ArgumentNullException(nameof(edDsa));
+ EdDsa = edDsaCreation ?? throw new ArgumentNullException(nameof(edDsaCreation));
  }
 
  [Obsolete("Deprecated in favor of EdDsa constructor")]

test/ScottBrady.IdentityModel.Tests/ScottBrady.IdentityModel.Tests.csproj

@@ -5,6 +5,7 @@
  </PropertyGroup>
 
  <ItemGroup>
+ <PackageReference Include="AutoFixture" Version="4.18.1" />
  <PackageReference Include="FluentAssertions" Version="6.12.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
  <PackageReference Include="Moq" Version="4.20.70" />

test/ScottBrady.IdentityModel.Tests/Tokens/EdDSA/AsymmetricAlgorithm/EdDsaBaseClassTests.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Security.Cryptography;
+using AutoFixture;
+using FluentAssertions;
+using ScottBrady.IdentityModel.Crypto;
+using ScottBrady.IdentityModel.Tokens;
+using Xunit;
+
+namespace ScottBrady.IdentityModel.Tests.Tokens.EdDSA.AsymmetricAlgorithm;
+
+public class EdDsaBaseClassTests : EdDsaTestBase
+{
+ public static TheoryData<EdDsa, int> Keys
+ => new TheoryData<EdDsa, int> { { _ed25519Key, 32 }, { _ed448Key, 57 } };
+
+ private static readonly Fixture _fixture = new();
+ private static readonly EdDsa _ed25519Key = EdDsa.Create(ExtendedSecurityAlgorithms.Curves.Ed25519);
+ private static readonly EdDsa _ed448Key = EdDsa.Create(ExtendedSecurityAlgorithms.Curves.Ed448);
+
+ [Theory, MemberData(nameof(Keys))]
+ public void KeySize_Expect32(EdDsa key, int expectedKeySize)
+ => key.KeySize.Should().Be(expectedKeySize);
+
+#pragma warning disable SYSLIB0045
+ [Fact]
+ public void Create_WhenEdDsaCurve_ExpectNull() 
+ => System.Security.Cryptography.AsymmetricAlgorithm.Create(ExtendedSecurityAlgorithms.EdDsa).Should().BeNull();
+#pragma warning restore SYSLIB0045
+
+#pragma warning disable SYSLIB0007
+ [Fact]
+ public void Create_ExpectPlatformNotSupportedException()
+ => Assert.Throws<PlatformNotSupportedException>(EdDsa.Create);
+#pragma warning restore SYSLIB0007
+
+ [Theory, MemberData(nameof(Keys))]
+ public void LegalKeySizes_ExpectCorrectValues(EdDsa key, int keySize)
+ => key.LegalKeySizes.Should().BeEquivalentTo(new[] { new KeySizes(keySize, keySize, 0) });
+
+ [Theory, MemberData(nameof(Keys))]
+ public void SignatureAlgorithm_ExpectEdDSA(EdDsa key, int _)
+ => key.SignatureAlgorithm.Should().Be(ExtendedSecurityAlgorithms.EdDsa);
+
+ [Theory, MemberData(nameof(Keys))]
+ public void KeyExchangeAlgorithm_ExpectNull(EdDsa key, int _)
+ => key.KeyExchangeAlgorithm.Should().BeNull();
+
+ [Theory, MemberData(nameof(Keys))]
+ public void FromXmlString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.FromXmlString(""));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ToXmlString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ToXmlString(true));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportEncryptedPkcs8PrivateKey_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportEncryptedPkcs8PrivateKey(Array.Empty<byte>(), Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportEncryptedPkcs8PrivateKey_WithPasswordString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportEncryptedPkcs8PrivateKey(Array.Empty<char>(), Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportPkcs8PrivateKey_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportPkcs8PrivateKey(Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportSubjectPublicKeyInfo_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportSubjectPublicKeyInfo(Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportEncryptedPkcs8PrivateKey_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ExportEncryptedPkcs8PrivateKey(Array.Empty<byte>(), _fixture.Create<PbeParameters>()));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportEncryptedPkcs8PrivateKey_WithPasswordString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ExportEncryptedPkcs8PrivateKey(Array.Empty<char>(), _fixture.Create<PbeParameters>()));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportPkcs8PrivateKey_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(key.ExportPkcs8PrivateKey);
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportSubjectPublicKeyInfo_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(key.ExportSubjectPublicKeyInfo);
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportEncryptedPkcs8PrivateKey_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportEncryptedPkcs8PrivateKey(Array.Empty<byte>(), _fixture.Create<PbeParameters>(), Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportEncryptedPkcs8PrivateKey_WithPasswordString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportEncryptedPkcs8PrivateKey(Array.Empty<char>(), _fixture.Create<PbeParameters>(), Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportPkcs8PrivateKey_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportPkcs8PrivateKey(Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportSubjectPublicKeyInfo_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportSubjectPublicKeyInfo(Array.Empty<byte>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportFromEncryptedPem_WithPasswordString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportFromEncryptedPem(Array.Empty<char>(), Array.Empty<char>()));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportFromEncryptedPem_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportFromEncryptedPem(Array.Empty<char>(), Array.Empty<byte>()));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ImportFromPem_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ImportFromPem(Array.Empty<char>()));
+
+#if NET8
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportPkcs8PrivateKeyPem_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ExportPkcs8PrivateKeyPem());
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportEncryptedPkcs8PrivateKeyPem_WithPasswordString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ExportEncryptedPkcs8PrivateKeyPem(Array.Empty<char>(), _fixture.Create<PbeParameters>()));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportEncryptedPkcs8PrivateKeyPem_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ExportEncryptedPkcs8PrivateKeyPem(Array.Empty<byte>(), _fixture.Create<PbeParameters>()));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void ExportSubjectPublicKeyInfoPem_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.ExportSubjectPublicKeyInfoPem();
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportSubjectPublicKeyInfoPem_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportSubjectPublicKeyInfoPem(Array.Empty<char>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportPkcs8PrivateKeyPem_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportPkcs8PrivateKeyPem(Array.Empty<char>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportEncryptedPkcs8PrivateKeyPem_WithPasswordString_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportEncryptedPkcs8PrivateKeyPem(Array.Empty<char>(), _fixture.Create<PbeParameters>()), Array.Empty<char>(), out var _));
+
+ [Theory, MemberData(nameof(Keys))]
+ public void TryExportEncryptedPkcs8PrivateKeyPem_WithPasswordBytes_ExpectNotImplementedException(EdDsa key, int _)
+ => Assert.Throws<NotImplementedException>(() => key.TryExportEncryptedPkcs8PrivateKeyPem(Array.Empty<byte>(), _fixture.Create<PbeParameters>()), Array.Empty<char>(), out var _));
+#endif
+
+ [Theory, MemberData(nameof(Keys))]
+ public void Clear_WhenDisposed_ExpectNoException(EdDsa key, int _)
+ => key.Clear();
+
+ [Theory, MemberData(nameof(Keys))]
+ public void Dispose_WhenDisposed_ExpectNoException(EdDsa key, int _)
+ => key.Dispose();
+
+
+}