public void LookupCurveByOidWindowsFriendlyName(string friendlyName)
{
ECDsaOpenSsl ec = new ECDsaOpenSsl(ECCurve.CreateFromFriendlyName(friendlyName));
ECParameters param = ec.ExportParameters(false);
param.Validate();
}
public MessageClientIdentity(string systemName, string clientName, ECDiffieHellmanCurve curve)
{
ECDiffieHellman dh;
var dhCurve = curve switch
{
ECDiffieHellmanCurve.P256 => ECCurve.NamedCurves.nistP256,
ECDiffieHellmanCurve.P384 => ECCurve.NamedCurves.nistP384,
ECDiffieHellmanCurve.P521 => ECCurve.NamedCurves.nistP521,
_ => throw new ArgumentOutOfRangeException(nameof(curve))
};
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
dh = new ECDiffieHellmanCng(dhCurve);
ECDsa = new ECDsaCng();
}
else
{
#if (!NET48)
dh = new ECDiffieHellmanOpenSsl();
#else
throw new NotSupportedException("ECDiffieHellmanOpenSsl is not supported in .NET 4.8");
#endif
ECDsa = new ECDsaOpenSsl();
}
SystemName = systemName;
Name = clientName;
ECDiffieHellman = dh;
ECDsa.ImportParameters(dh.ExportExplicitParameters(true));
}
public static void VerifyDuplicateKey_ECDsaHandle()
{
using (ECDsaOpenSsl ecdsa = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle pkey = ecdsa.DuplicateKeyHandle())
{
Assert.ThrowsAny <CryptographicException>(() => new DSAOpenSsl(pkey));
}
}
public static void DefaultCtor()
{
using (ECDsaOpenSsl e = new ECDsaOpenSsl())
{
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public static void VerifyDuplicateKey_DistinctHandles()
{
using (ECDsaOpenSsl first = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle firstHandle = first.DuplicateKeyHandle())
using (SafeEvpPKeyHandle firstHandle2 = first.DuplicateKeyHandle())
{
Assert.NotSame(firstHandle, firstHandle2);
}
}
public static void DefaultCtor()
{
using (ECDsaOpenSsl e = new ECDsaOpenSsl())
{
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public static void Ctor384()
{
int expectedKeySize = 384;
using (ECDsaOpenSsl e = new ECDsaOpenSsl(expectedKeySize))
{
int keySize = e.KeySize;
Assert.Equal(expectedKeySize, keySize);
e.Exercise();
}
}
public static void Ctor521()
{
int expectedKeySize = 521;
using (ECDsaOpenSsl e = new ECDsaOpenSsl(expectedKeySize))
{
int keySize = e.KeySize;
Assert.Equal(expectedKeySize, keySize);
e.Exercise();
}
}
public void LookupCurveByOidValue()
{
ECDsaOpenSsl ec = null;
ec = new ECDsaOpenSsl(ECCurve.CreateFromValue(ECDSA_P256_OID_VALUE)); // Same as nistP256
ECParameters param = ec.ExportParameters(false);
param.Validate();
Assert.Equal(256, ec.KeySize);
Assert.True(param.Curve.IsNamed);
Assert.Equal("ECDSA_P256", param.Curve.Oid.FriendlyName);
Assert.Equal(ECDSA_P256_OID_VALUE, param.Curve.Oid.Value);
}
[ConditionalFact("ECDsa224Available")] // Issue #4337
public static void KeySizeProp()
{
using (ECDsaOpenSsl e = new ECDsaOpenSsl())
{
e.KeySize = 384;
Assert.Equal(384, e.KeySize);
e.Exercise();
e.KeySize = 224;
Assert.Equal(224, e.KeySize);
e.Exercise();
}
}
public static void VerifyDuplicateKey_InvalidHandle()
{
using (ECDsaOpenSsl ecdsa = new ECDsaOpenSsl())
{
SafeEvpPKeyHandle pkey = ecdsa.DuplicateKeyHandle();
using (pkey)
{
}
Assert.Throws <ArgumentException>(() => new ECDsaOpenSsl(pkey));
}
}
public void NoncompliantGenerateKey()
{
var ec1 = new ECDiffieHellmanCng();
ec1.GenerateKey(ECCurve.NamedCurves.brainpoolP160r1); // Noncompliant {{Use a key length of at least 224 bits for EC cipher algorithm.}}
var ec2 = new ECDsaCng();
ec2.GenerateKey(ECCurve.NamedCurves.brainpoolP160t1); // Noncompliant {{Use a key length of at least 224 bits for EC cipher algorithm.}}
var ec3 = new ECDsaOpenSsl();
ec3.GenerateKey(ECCurve.NamedCurves.brainpoolP192t1); // Noncompliant {{Use a key length of at least 224 bits for EC cipher algorithm.}}
}
public static void VerifyDuplicateKey_ValidHandle()
{
byte[] data = ByteUtils.RepeatByte(0x71, 11);
using (ECDsaOpenSsl first = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle firstHandle = first.DuplicateKeyHandle())
{
using (ECDsa second = new ECDsaOpenSsl(firstHandle))
{
byte[] signed = second.SignData(data, HashAlgorithmName.SHA512);
Assert.True(first.VerifyData(data, signed, HashAlgorithmName.SHA512));
}
}
}
/// <summary>
/// Creates an instance of the platform specific implementation of the cref="ECDsa" algorithm.
/// </summary>
/// <param name="parameters">
/// The <see cref="ECParameters"/> representing the elliptic curve parameters.
/// </param>
public static partial ECDsa Create(ECParameters parameters)
{
ECDsa ec = new ECDsaOpenSsl();
try
{
ec.ImportParameters(parameters);
return(new ECDsaWrapper(ec));
}
catch
{
ec.Dispose();
throw;
}
}
private static void Exercise(this ECDsaOpenSsl e)
{
// Make a few calls on this to ensure we aren't broken due to bad/prematurely released handles.
int keySize = e.KeySize;
byte[] data = new byte[0x10];
byte[] sig = e.SignData(data, 0, data.Length, HashAlgorithmName.SHA1);
bool verified = e.VerifyData(data, sig, HashAlgorithmName.SHA1);
Assert.True(verified);
sig[sig.Length - 1]++;
verified = e.VerifyData(data, sig, HashAlgorithmName.SHA1);
Assert.False(verified);
}
/// <summary>Constructor</summary>
/// <param name="eaa">EnumDigitalSignAlgorithm</param>
/// <param name="hashAlgorithm">HashAlgorithm</param>
public DigitalSignECDsaOpenSsl(EnumDigitalSignAlgorithm eaa, HashAlgorithm hashAlgorithm)
{
AsymmetricAlgorithm aa = null;
HashAlgorithm ha = null;
AsymmetricAlgorithmCmnFunc.CreateDigitalSignSP(eaa, out aa, out ha);
ECDsaOpenSsl ecdsa = (ECDsaOpenSsl)aa;
this._privateKey = ecdsa.ExportParameters(true);
this._publicKey = ecdsa.ExportParameters(false);
this.AsymmetricAlgorithm = aa;
this.HashAlgorithm = hashAlgorithm;
}
public void CompliantConstructors()
{
var ec1 = new ECDiffieHellmanCng(); // Compliant - default EC key size is 521
var ec2 = new ECDsaCng(); // Compliant - default EC key size is 521
var ec3 = new ECDsaOpenSsl(); // Compliant - default EC key size is 521
// Valid key sizes are 256, 384, and 521 bits.
var ec4 = new ECDiffieHellmanCng(256);
var ec5 = new ECDsaCng(384);
var ec6 = new ECDsaOpenSsl(521);
var ec7 = new ECDsaOpenSsl((IntPtr)128);
var ec8 = new ECDiffieHellmanCng(ECCurve.NamedCurves.brainpoolP384r1);
var ec9 = new ECDsaCng(ECCurve.NamedCurves.brainpoolP384t1);
var ec10 = new ECDsaOpenSsl(ECCurve.NamedCurves.brainpoolP512r1);
}
public void CtorHandle224()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByOid(ECDSA_P224_OID_VALUE);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
int keySize = e.KeySize;
Assert.Equal(224, keySize);
e.Exercise();
}
Interop.Crypto.EcKeyDestroy(ecKey);
}
public static void CtorHandle384()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByCurveName(NID_secp384r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
int keySize = e.KeySize;
Assert.Equal(384, keySize);
e.Exercise();
}
Interop.Crypto.EcKeyDestroy(ecKey);
}
public static void CtorHandle384()
{
IntPtr ecKey = EC_KEY_new_by_curve_name(NID_secp384r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = EC_KEY_generate_key(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
int keySize = e.KeySize;
Assert.Equal(384, keySize);
e.Exercise();
}
EC_KEY_free(ecKey);
}
/// <summary>Constructor</summary>
/// <param name="eCParameters">ECParameters（任意）</param>
/// <param name="hashAlgorithm">HashAlgorithm</param>
public DigitalSignECDsaOpenSsl(ECParameters eCParameters, HashAlgorithm hashAlgorithm)
{
ECDsaOpenSsl ecdsa = new ECDsaOpenSsl(eCParameters.Curve);
ecdsa.ImportParameters(eCParameters);
if (eCParameters.D != null)
{
this._privateKey = ecdsa.ExportParameters(true);
}
this._publicKey = ecdsa.ExportParameters(false);
this.AsymmetricAlgorithm = ecdsa;
this.AsymmetricAlgorithm = ecdsa;
this.HashAlgorithm = hashAlgorithm;
}
public void CompliantGenerateKey()
{
var ec1 = new ECDiffieHellmanCng();
ec1.GenerateKey(ECCurve.NamedCurves.brainpoolP224r1);
ec1.GenerateKey(ECCurve.NamedCurves.nistP256);
var ec2 = new ECDsaCng();
ec2.GenerateKey(ECCurve.NamedCurves.brainpoolP256r1);
ec2.GenerateKey(ECCurve.NamedCurves.nistP384);
var ec3 = new ECDsaOpenSsl();
ec3.GenerateKey(ECCurve.NamedCurves.brainpoolP384t1);
ec3.GenerateKey(ECCurve.NamedCurves.nistP521);
}
internal MessageClientIdentity(string systemName, string clientName, ECDiffieHellman dh, bool isPrivateIdentity)
{
SystemName = systemName;
Name = clientName;
ECDiffieHellman = dh;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
ECDsa = new ECDsaCng();
}
else
{
ECDsa = new ECDsaOpenSsl();
}
ECDsa.ImportParameters(dh.ExportExplicitParameters(isPrivateIdentity));
}
public void CompliantKeySizeSet()
{
var ec1 = new ECDiffieHellmanCng();
ec1.KeySize = 512;
ec1.KeySize = 128; // OK - because this is not a valid key size for this object
var ec2 = new ECDsaCng();
ec2.KeySize = 512;
ec2.KeySize = 64; // OK - because this is not a valid key size for this object
var ec3 = new ECDsaOpenSsl();
ec3.KeySize = 512;
ec3.KeySize = 12; // OK - because this is not a valid key size for this object
}
public SafeFreeCredentials(X509Certificate certificate, SslProtocols protocols, EncryptionPolicy policy)
: base(IntPtr.Zero, true)
{
Debug.Assert(
certificate == null || certificate is X509Certificate2,
"Only X509Certificate2 certificates are supported at this time");
X509Certificate2 cert = (X509Certificate2)certificate;
if (cert != null)
{
Debug.Assert(cert.HasPrivateKey, "cert.HasPrivateKey");
using (RSAOpenSsl rsa = (RSAOpenSsl)cert.GetRSAPrivateKey())
{
if (rsa != null)
{
_certKeyHandle = rsa.DuplicateKeyHandle();
Interop.Crypto.CheckValidOpenSslHandle(_certKeyHandle);
}
}
if (_certKeyHandle == null)
{
using (ECDsaOpenSsl ecdsa = (ECDsaOpenSsl)cert.GetECDsaPrivateKey())
{
if (ecdsa != null)
{
_certKeyHandle = ecdsa.DuplicateKeyHandle();
Interop.Crypto.CheckValidOpenSslHandle(_certKeyHandle);
}
}
}
if (_certKeyHandle == null)
{
throw new NotSupportedException(SR.net_ssl_io_no_server_cert);
}
_certHandle = Interop.Crypto.X509Duplicate(cert.Handle);
Interop.Crypto.CheckValidOpenSslHandle(_certHandle);
}
_protocols = protocols;
_policy = policy;
}
public static void CtorHandle384()
{
IntPtr ecKey = EC_KEY_new_by_curve_name(NID_secp384r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = EC_KEY_generate_key(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
int keySize = e.KeySize;
Assert.Equal(384, keySize);
e.Exercise();
}
EC_KEY_free(ecKey);
}
public void CtorHandle384()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByOid(ECDSA_P384_OID_VALUE);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
int keySize = e.KeySize;
Assert.Equal(384, keySize);
e.Exercise();
}
Interop.Crypto.EcKeyDestroy(ecKey);
}
[ConditionalFact("ECDsa224Available")] // Issue #4337
public static void CtorHandle224()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByCurveName(NID_secp224r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
int keySize = e.KeySize;
Assert.Equal(224, keySize);
e.Exercise();
}
Interop.Crypto.EcKeyDestroy(ecKey);
}
public static void VerifyDuplicateKey_RefCounts()
{
byte[] data = ByteUtils.RepeatByte(0x74, 11);
byte[] signature;
ECDsa second;
using (ECDsaOpenSsl first = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle firstHandle = first.DuplicateKeyHandle())
{
signature = first.SignData(data, HashAlgorithmName.SHA384);
second = new ECDsaOpenSsl(firstHandle);
}
// Now show that second still works, despite first and firstHandle being Disposed.
using (second)
{
Assert.True(second.VerifyData(data, signature, HashAlgorithmName.SHA384));
}
}
public ICertificatePal CopyWithPrivateKey(ECDsa privateKey)
{
ECDsaOpenSsl typedKey = privateKey as ECDsaOpenSsl;
if (typedKey != null)
{
return(CopyWithPrivateKey((SafeEvpPKeyHandle)typedKey.DuplicateKeyHandle()));
}
ECParameters ecParameters = privateKey.ExportParameters(true);
using (PinAndClear.Track(ecParameters.D))
using (typedKey = new ECDsaOpenSsl())
{
typedKey.ImportParameters(ecParameters);
return(CopyWithPrivateKey((SafeEvpPKeyHandle)typedKey.DuplicateKeyHandle()));
}
}
public void CtorHandleDuplicate()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByOid(ECDSA_P521_OID_VALUE);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
// Make sure ECDsaOpenSsl did its own ref-count bump.
Interop.Crypto.EcKeyDestroy(ecKey);
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public static void CtorHandleDuplicate()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByCurveName(NID_secp521r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
// Make sure ECDsaOpenSsl did his own ref-count bump.
Interop.Crypto.EcKeyDestroy(ecKey);
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public static void CtorHandleDuplicate()
{
IntPtr ecKey = EC_KEY_new_by_curve_name(NID_secp521r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = EC_KEY_generate_key(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
// Make sure ECDsaOpenSsl did his own ref-count bump.
EC_KEY_free(ecKey);
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public void KeySizePropWithExercise()
{
using (ECDsaOpenSsl e = new ECDsaOpenSsl())
{
e.KeySize = 384;
Assert.Equal(384, e.KeySize);
e.Exercise();
ECParameters p384 = e.ExportParameters(false);
Assert.Equal(ECCurve.ECCurveType.Named, p384.Curve.CurveType);
e.KeySize = 521;
Assert.Equal(521, e.KeySize);
e.Exercise();
ECParameters p521 = e.ExportParameters(false);
Assert.Equal(ECCurve.ECCurveType.Named, p521.Curve.CurveType);
// ensure the key was regenerated
Assert.NotEqual(p384.Curve.Oid.Value, p521.Curve.Oid.Value);
}
}
protected override byte[] ExportPkcs8(
ICertificatePalCore certificatePal,
ReadOnlySpan <char> password)
{
AsymmetricAlgorithm alg = null;
SafeEvpPKeyHandle privateKey = ((OpenSslX509CertificateReader)certificatePal).PrivateKeyHandle;
try
{
alg = new RSAOpenSsl(privateKey);
}
catch (CryptographicException)
{
}
if (alg == null)
{
try
{
alg = new ECDsaOpenSsl(privateKey);
}
catch (CryptographicException)
{
}
}
if (alg == null)
{
try
{
alg = new DSAOpenSsl(privateKey);
}
catch (CryptographicException)
{
}
}
Debug.Assert(alg != null);
return(alg.ExportEncryptedPkcs8PrivateKey(password, s_windowsPbe));
}
public static void VerifyDuplicateKey_ECDsaHandle()
{
using (ECDsaOpenSsl ecdsa = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle pkey = ecdsa.DuplicateKeyHandle())
{
Assert.ThrowsAny<CryptographicException>(() => new DSAOpenSsl(pkey));
}
}
public static void CtorHandleDuplicate()
{
IntPtr ecKey = EC_KEY_new_by_curve_name(NID_secp521r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = EC_KEY_generate_key(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
// Make sure ECDsaOpenSsl did his own ref-count bump.
EC_KEY_free(ecKey);
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public void KeySizePropWithExercise()
{
using (ECDsaOpenSsl e = new ECDsaOpenSsl())
{
e.KeySize = 384;
Assert.Equal(384, e.KeySize);
e.Exercise();
ECParameters p384 = e.ExportParameters(false);
Assert.Equal(ECCurve.ECCurveType.Named, p384.Curve.CurveType);
e.KeySize = 521;
Assert.Equal(521, e.KeySize);
e.Exercise();
ECParameters p521 = e.ExportParameters(false);
Assert.Equal(ECCurve.ECCurveType.Named, p521.Curve.CurveType);
// ensure the key was regenerated
Assert.NotEqual(p384.Curve.Oid.Value, p521.Curve.Oid.Value);
}
}
public void LookupCurveByOidValue()
{
ECDsaOpenSsl ec = null;
ec = new ECDsaOpenSsl(ECCurve.CreateFromValue(ECDSA_P256_OID_VALUE)); // Same as nistP256
ECParameters param = ec.ExportParameters(false);
param.Validate();
Assert.Equal(256, ec.KeySize);
Assert.True(param.Curve.IsNamed);
Assert.Equal("ECDSA_P256", param.Curve.Oid.FriendlyName);
Assert.Equal(ECDSA_P256_OID_VALUE, param.Curve.Oid.Value);
}
public static void VerifyDuplicateKey_InvalidHandle()
{
using (ECDsaOpenSsl ecdsa = new ECDsaOpenSsl())
{
SafeEvpPKeyHandle pkey = ecdsa.DuplicateKeyHandle();
using (pkey)
{
}
Assert.Throws<ArgumentException>(() => new ECDsaOpenSsl(pkey));
}
}
public static void VerifyDuplicateKey_RefCounts()
{
byte[] data = ByteUtils.RepeatByte(0x74, 11);
byte[] signature;
ECDsa second;
using (ECDsaOpenSsl first = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle firstHandle = first.DuplicateKeyHandle())
{
signature = first.SignData(data, HashAlgorithmName.SHA384);
second = new ECDsaOpenSsl(firstHandle);
}
// Now show that second still works, despite first and firstHandle being Disposed.
using (second)
{
Assert.True(second.VerifyData(data, signature, HashAlgorithmName.SHA384));
}
}
public static void VerifyDuplicateKey_DistinctHandles()
{
using (ECDsaOpenSsl first = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle firstHandle = first.DuplicateKeyHandle())
using (SafeEvpPKeyHandle firstHandle2 = first.DuplicateKeyHandle())
{
Assert.NotSame(firstHandle, firstHandle2);
}
}
public static void VerifyDuplicateKey_ValidHandle()
{
byte[] data = ByteUtils.RepeatByte(0x71, 11);
using (ECDsaOpenSsl first = new ECDsaOpenSsl())
using (SafeEvpPKeyHandle firstHandle = first.DuplicateKeyHandle())
{
using (ECDsa second = new ECDsaOpenSsl(firstHandle))
{
byte[] signed = second.SignData(data, HashAlgorithmName.SHA512);
Assert.True(first.VerifyData(data, signed, HashAlgorithmName.SHA512));
}
}
}
public static void KeySizeProp()
{
using (ECDsaOpenSsl e = new ECDsaOpenSsl())
{
e.KeySize = 384;
Assert.Equal(384, e.KeySize);
e.Exercise();
e.KeySize = 224;
Assert.Equal(224, e.KeySize);
e.Exercise();
}
}
public static void CtorHandleDuplicate()
{
IntPtr ecKey = Interop.Crypto.EcKeyCreateByCurveName(NID_secp521r1);
Assert.NotEqual(IntPtr.Zero, ecKey);
int success = Interop.Crypto.EcKeyGenerateKey(ecKey);
Assert.NotEqual(0, success);
using (ECDsaOpenSsl e = new ECDsaOpenSsl(ecKey))
{
// Make sure ECDsaOpenSsl did his own ref-count bump.
Interop.Crypto.EcKeyDestroy(ecKey);
int keySize = e.KeySize;
Assert.Equal(521, keySize);
e.Exercise();
}
}
public void LookupCurveByOidFriendlyName()
{
ECDsaOpenSsl ec = null;
// prime256v1 is alias for nistP256 for OpenSsl
ec = new ECDsaOpenSsl(ECCurve.CreateFromFriendlyName("prime256v1"));
ECParameters param = ec.ExportParameters(false);
param.Validate();
Assert.Equal(256, ec.KeySize);
Assert.True(param.Curve.IsNamed);
Assert.Equal("ECDSA_P256", param.Curve.Oid.FriendlyName); // OpenSsl maps prime256v1 to ECDSA_P256
Assert.Equal(ECDSA_P256_OID_VALUE, param.Curve.Oid.Value);
// secp521r1 is same as nistP521; note Windows uses secP521r1 (uppercase P)
ec = new ECDsaOpenSsl(ECCurve.CreateFromFriendlyName("secp521r1"));
param = ec.ExportParameters(false);
param.Validate();
Assert.Equal(521, ec.KeySize);
Assert.True(param.Curve.IsNamed);
Assert.Equal("ECDSA_P521", param.Curve.Oid.FriendlyName); // OpenSsl maps secp521r1 to ECDSA_P521
Assert.Equal(ECDSA_P521_OID_VALUE, param.Curve.Oid.Value);
}
