public void TestU2fAttCertNotP256()
{
using (var ecdsaAtt = ECDsa.Create(ECCurve.NamedCurves.nistP384))
{
var attRequest = new CertificateRequest("CN=U2FTesting, OU=Authenticator Attestation, O=FIDO2-NET-LIB, C=US", ecdsaAtt, HashAlgorithmName.SHA256);
attRequest.CertificateExtensions.Add(
new X509BasicConstraintsExtension(false, false, 0, false));
using (var attestnCert = attRequest.CreateSelfSigned(DateTimeOffset.UtcNow, DateTimeOffset.UtcNow.AddDays(2)))
{
var attnStmt = (CborMap)_attestationObject["attStmt"];
attnStmt.Set("x5c", new CborArray {
attestnCert.RawData
});
}
}
var ex = Assert.ThrowsAsync <Fido2VerificationException>(() => MakeAttestationResponse());
Assert.Equal("Attestation certificate public key is not an Elliptic Curve (EC) public key over the P-256 curve", ex.Result.Message);
}
public virtual void HandleMcpeServerToClientHandshake(McpeServerToClientHandshake message)
{
string token = message.token;
Log.Debug($"JWT:\n{token}");
IDictionary <string, dynamic> headers = JWT.Headers(token);
string x5u = headers["x5u"];
Log.Debug($"JWT payload:\n{JWT.Payload(token)}");
ECPublicKeyParameters remotePublicKey = (ECPublicKeyParameters)PublicKeyFactory.CreateKey(x5u.DecodeBase64());
var signParam = new ECParameters
{
Curve = ECCurve.NamedCurves.nistP384,
Q =
{
X = remotePublicKey.Q.AffineXCoord.GetEncoded(),
Y = remotePublicKey.Q.AffineYCoord.GetEncoded()
},
};
signParam.Validate();
var signKey = ECDsa.Create(signParam);
try
{
var data = JWT.Decode <HandshakeData>(token, signKey);
Client.InitiateEncryption(Base64Url.Decode(x5u), Base64Url.Decode(data.salt));
}
catch (Exception e)
{
Log.Error(token, e);
throw;
}
}
public static void ECDSA_Signing_RSAPublicKey()
{
using (RSA rsa = RSA.Create())
using (ECDsa ecdsa = ECDsa.Create())
{
var request = new CertificateRequest(
new X500DistinguishedName("CN=Test"),
ecdsa,
HashAlgorithmName.SHA256);
request.CertificateExtensions.Add(
new X509BasicConstraintsExtension(true, false, 0, true));
DateTimeOffset now = DateTimeOffset.UtcNow;
using (X509Certificate2 cert = request.CreateSelfSigned(now, now.AddDays(1)))
{
X509SignatureGenerator rsaGenerator =
X509SignatureGenerator.CreateForRSA(rsa, RSASignaturePadding.Pkcs1);
request = new CertificateRequest(
new X500DistinguishedName("CN=Leaf"),
rsaGenerator.PublicKey,
HashAlgorithmName.SHA256);
byte[] serialNumber = { 1, 1, 2, 3, 5, 8, 13 };
AssertExtensions.Throws <ArgumentException>("issuerCertificate", () => request.Create(cert, now, now.AddHours(3), serialNumber));
X509SignatureGenerator ecdsaGenerator =
X509SignatureGenerator.CreateForECDsa(ecdsa);
// Passes with the generator
using (request.Create(cert.SubjectName, ecdsaGenerator, now, now.AddHours(3), serialNumber))
{
}
}
}
}
public static byte[] Sign(byte[] message, byte[] prikey, byte[] pubkey)
{
var signer = SignerUtilities.GetSigner("SHA256withECDSA");
var curve = NistNamedCurves.GetByName("P-256");
var dom = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
ECKeyParameters privateKeyParameters = new ECPrivateKeyParameters(new BigInteger(1, prikey), dom);
signer.Init(true, privateKeyParameters);
signer.BlockUpdate(message, 0, message.Length);
var sig = signer.GenerateSignature();
return(TranscodeSignatureToConcat(sig, 64));
#if OLD_VERSION
#if NET461
const int ECDSA_PRIVATE_P256_MAGIC = 0x32534345;
prikey = BitConverter.GetBytes(ECDSA_PRIVATE_P256_MAGIC).Concat(BitConverter.GetBytes(32)).Concat(pubkey).Concat(prikey).ToArray();
using (CngKey key = CngKey.Import(prikey, CngKeyBlobFormat.EccPrivateBlob))
using (ECDsaCng ecdsa = new ECDsaCng(key))
{
return(ecdsa.SignData(message, HashAlgorithmName.SHA256));
}
#else
using (var ecdsa = ECDsa.Create(new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
D = prikey,
Q = new ECPoint
{
X = pubkey.Take(32).ToArray(),
Y = pubkey.Skip(32).ToArray()
}
}))
{
return(ecdsa.SignData(message, HashAlgorithmName.SHA256));
}
#endif
#endif
}
public static X509Certificate2 GetSelfSigned13ServerCertificate()
{
if (s_selfSigned13ServerCertificate == null)
{
X509Certificate2 cert;
using (ECDsa dsa = ECDsa.Create())
{
var certReq = new CertificateRequest("CN=testservereku.contoso.com", dsa, HashAlgorithmName.SHA256);
certReq.CertificateExtensions.Add(new X509BasicConstraintsExtension(false, false, 0, false));
certReq.CertificateExtensions.Add(new X509EnhancedKeyUsageExtension(new OidCollection {
new Oid("1.3.6.1.5.5.7.3.1")
}, false));
certReq.CertificateExtensions.Add(new X509KeyUsageExtension(X509KeyUsageFlags.DigitalSignature, false));
X509Certificate2 innerCert = certReq.CreateSelfSigned(DateTimeOffset.UtcNow.AddMonths(-1), DateTimeOffset.UtcNow.AddMonths(1));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
using (innerCert)
{
cert = new X509Certificate2(innerCert.Export(X509ContentType.Pfx));
}
}
else
{
cert = innerCert;
}
}
if (Interlocked.CompareExchange(ref s_selfSigned13ServerCertificate, cert, null) != null)
{
// Lost a race to create.
cert.Dispose();
}
}
return(new X509Certificate2(s_selfSigned13ServerCertificate));
}
public void ExportPkcs8PrivateKey(AsnFormat format)
{
using ECDsa ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);
byte[] exported = ecdsa.ExportPkcs8PrivateKey(format);
if (format == AsnFormat.Der)
{
var info = PrivateKeyFactory.CreateKey(exported);
Assert.IsNotNull(info);
}
if (format == AsnFormat.Pem)
{
using MemoryStream ms = new MemoryStream(exported);
using TextReader tr = new StreamReader(ms, Encoding.ASCII);
PemReader pemReader = new PemReader(tr);
object obj = pemReader.ReadObject();
Assert.IsNotNull(obj);
}
this.CheckFormat(format, exported);
}
public static string Sign(string apiKey, string data)
{
var digest = SHA256.Create().ComputeHash(Encoding.ASCII.GetBytes(data));
var keyInfo = ASN1.ParseASN1String(apiKey);
if (!ASN1.NIST_P_256_CURVE.Equals(keyInfo.CurveNameHex, StringComparison.InvariantCultureIgnoreCase))
{
throw new NotSupportedException("Curves other than NIST P256 are not supported");
}
var q = new ECPoint {
X = keyInfo.Qx, Y = keyInfo.Qy
};
var d = keyInfo.PrivateKey;
var ecParams = new ECParameters {
D = d, Curve = ECCurve.NamedCurves.nistP256, Q = q
};
using (var dsa = ECDsa.Create(ecParams))
{
return(Utils.ByteArrayToHexString(dsa.SignHash(digest)));
}
}
/// <inheritdoc/>
public override X509Certificate2 CreateForECDsa(X509SignatureGenerator generator)
{
if (IssuerCAKeyCert == null)
{
throw new NotSupportedException("X509 Signature generator requires an issuer certificate.");
}
if (m_ecdsaPublicKey == null && m_curve == null)
{
throw new NotSupportedException("Need a public key or a ECCurve to create the certificate.");
}
CreateDefaults();
ECDsa key = null;
ECDsa publicKey = m_ecdsaPublicKey;
if (publicKey == null)
{
key = ECDsa.Create((ECCurve)m_curve);
publicKey = key;
}
var request = new CertificateRequest(SubjectName, publicKey, HashAlgorithmName);
CreateX509Extensions(request, true);
X509Certificate2 signedCert = request.Create(
IssuerCAKeyCert.SubjectName,
generator,
NotBefore,
NotAfter,
m_serialNumber.Reverse().ToArray()
);
// return a X509Certificate2
return((key == null) ? signedCert : signedCert.CopyWithPrivateKey(key));
}
public static void SignatureAlgorithm_Encoding(string hashAlgorithmName)
{
string expectedAlgOid;
switch (hashAlgorithmName)
{
case "SHA1":
expectedAlgOid = "06072A8648CE3D0401";
break;
case "SHA256":
expectedAlgOid = "06082A8648CE3D040302";
break;
case "SHA384":
expectedAlgOid = "06082A8648CE3D040303";
break;
case "SHA512":
expectedAlgOid = "06082A8648CE3D040304";
break;
default:
throw new ArgumentOutOfRangeException(nameof(hashAlgorithmName));
}
EccTestData testData = EccTestData.Secp521r1Data;
string expectedHex = $"30{(expectedAlgOid.Length / 2):X2}{expectedAlgOid}";
using (ECDsa ecdsa = ECDsa.Create(testData.KeyParameters))
{
var generator = X509SignatureGenerator.CreateForECDsa(ecdsa);
byte[] sigAlg = generator.GetSignatureAlgorithmIdentifier(new HashAlgorithmName(hashAlgorithmName));
Assert.Equal(expectedHex, sigAlg.ByteArrayToHex());
}
}
public static void ECDSA_Signing_UnknownPublicKeyAlgorithm()
{
using ECDsa ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);
PublicKey gostRPublicKey = PublicKey.CreateFromSubjectPublicKeyInfo(
TestData.GostR3410SubjectPublicKeyInfo,
out _);
CertificateRequest issuerRequest = new CertificateRequest(
new X500DistinguishedName("CN=root"),
ecdsa,
HashAlgorithmName.SHA256);
issuerRequest.CertificateExtensions.Add(
new X509BasicConstraintsExtension(true, false, 0, true));
CertificateRequest request = new CertificateRequest(
new X500DistinguishedName("CN=test"),
gostRPublicKey,
HashAlgorithmName.SHA256);
request.CertificateExtensions.Add(
new X509BasicConstraintsExtension(false, false, 0, true));
DateTimeOffset notBefore = DateTimeOffset.UtcNow;
DateTimeOffset notAfter = notBefore.AddDays(30);
byte[] serial = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
using X509Certificate2 issuer = issuerRequest.CreateSelfSigned(notBefore, notAfter);
X509SignatureGenerator ecdsaGenerator = X509SignatureGenerator.CreateForECDsa(ecdsa);
using X509Certificate2 cert = request.Create(issuer.SubjectName, ecdsaGenerator, notBefore, notAfter, serial);
Assert.Null(cert.GetECDsaPublicKey());
Assert.Null(cert.GetECDiffieHellmanPublicKey());
Assert.Equal("1.2.643.2.2.19", cert.PublicKey.Oid.Value);
}
static void CreateCertificate(string path, string password = null)
{
var ecdsa = ECDsa.Create();
var request = new CertificateRequest("CN=testcert, O=GIBZ, L=Zug, S=Zug, C=CH", ecdsa, HashAlgorithmName.SHA512);
var cert = request.CreateSelfSigned(DateTimeOffset.Now, DateTimeOffset.Now.AddYears(1));
byte[] exportedCert = null;
if (password == null)
{
exportedCert = cert.Export(X509ContentType.Pfx);
}
else
{
exportedCert = cert.Export(X509ContentType.Pfx, password);
}
if (!Directory.Exists(Path.GetDirectoryName(path)))
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
}
File.WriteAllBytes(path, exportedCert);
}
public static X509Certificate2 Create(string cn, X509KeyUsageFlags?usageFlags = null, string extraKeyUsageOids = null)
{
using ECDsa elipticKey = ECDsa.Create(ECCurve.NamedCurves.nistP256);
CertificateRequest request = new CertificateRequest($"CN={cn}; C=SK", elipticKey, HashAlgorithmName.SHA256);
if (usageFlags.HasValue)
{
request.CertificateExtensions.Add(new X509KeyUsageExtension(usageFlags.Value, false));
}
if (!string.IsNullOrEmpty(extraKeyUsageOids))
{
OidCollection oidCollection = new OidCollection();
foreach (string oid in extraKeyUsageOids.Split(new char[] { ';', ',' }))
{
oidCollection.Add(new Oid(oid.Trim()));
}
request.CertificateExtensions.Add(new X509EnhancedKeyUsageExtension(oidCollection, false));
}
return(request.CreateSelfSigned(DateTime.Now.AddDays(-1.0), DateTime.Now.AddDays(1.0)));
}
private void CreateSelfSignedCert(string certName)
{
ECDsa ecdsaKey = ECDsa.Create();
CertificateRequest certificateRequest = new CertificateRequest(certName, ecdsaKey, HashAlgorithmName.SHA256);
// We have to export cert to dummy cert since `CreateSelfSigned` creates a cert without a private key.
X509Certificate2 cert = certificateRequest.CreateSelfSigned(DateTimeOffset.Now, DateTimeOffset.Now.AddYears(5));
X509Certificate2 dummyCert = null;
if (PowerShell.Authentication.Helpers.OperatingSystem.IsMacOS())
{
dummyCert = new X509Certificate2(cert.Export(X509ContentType.Pfx, "P@55w0rd"), "P@55w0rd", X509KeyStorageFlags.Exportable);
}
else
{
dummyCert = new X509Certificate2(cert.Export(X509ContentType.Pfx, "P@55w0rd"), "P@55w0rd", X509KeyStorageFlags.PersistKeySet);
}
using (X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser))
{
store.Open(OpenFlags.ReadWrite);
store.Add(dummyCert);
}
}
/// <summary>
/// Create a Self signed certificate with all options which can also be used as a root certificate
/// </summary>
/// <param name="distinguishedName">Distinguished Name used for the subject and the issuer properties</param>
/// <param name="validityPeriod">Valid from, Valid to certificate properties</param>
/// <param name="subjectAlternativeName">SAN but only DnsNames can be added as a list + Email property</param>
/// <param name="enhancedKeyUsages">Defines how the certificate key can be used.
/// OidLookup.ServerAuthentication,
/// OidLookup.ClientAuthentication,
/// OidLookup.CodeSigning,
/// OidLookup.SecureEmail,
/// OidLookup.TimeStamping
/// </param>
/// <param name="x509KeyUsageFlags">Defines how the certificate key can be used.
/// None No key usage parameters.
/// EncipherOnly The key can be used for encryption only.
/// CrlSign The key can be used to sign a certificate revocation list (CRL).
/// KeyCertSign The key can be used to sign certificates.
/// KeyAgreement The key can be used to determine key agreement, such as a key created using the Diffie-Hellman key agreement algorithm.
/// DataEncipherment The key can be used for data encryption.
/// KeyEncipherment The key can be used for key encryption.
/// NonRepudiation The key can be used for authentication.
/// DecipherOnly The key can be used for decryption only.
/// </param>
/// <returns>Self signed certificate</returns>
public X509Certificate2 NewECDsaSelfSignedCertificate(
DistinguishedName distinguishedName,
BasicConstraints basicConstraints,
ValidityPeriod validityPeriod,
SubjectAlternativeName subjectAlternativeName,
OidCollection enhancedKeyUsages,
X509KeyUsageFlags x509KeyUsageFlags,
ECDsaConfiguration eCDsaConfiguration)
{
using var ecdsa = ECDsa.Create("ECDsa");
ecdsa.KeySize = eCDsaConfiguration.KeySize;
var request = new CertificateRequest(
_certificateUtility.CreateIssuerOrSubject(distinguishedName),
ecdsa,
eCDsaConfiguration.HashAlgorithmName);
return(NewECDsaSelfSignedCertificate(basicConstraints,
validityPeriod,
subjectAlternativeName,
enhancedKeyUsages,
x509KeyUsageFlags,
request));
}
private ECDsa ConvertToSingKeyFormat(AsymmetricCipherKeyPair key)
{
ECPublicKeyParameters pubAsyKey = (ECPublicKeyParameters)key.Public;
ECPrivateKeyParameters privAsyKey = (ECPrivateKeyParameters)key.Private;
var signParam = new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
Q =
{
X = pubAsyKey.Q.AffineXCoord.GetEncoded(),
Y = pubAsyKey.Q.AffineYCoord.GetEncoded()
}
};
signParam.D = CryptoUtils.FixDSize(privAsyKey.D.ToByteArrayUnsigned(), signParam.Q.X.Length);
signParam.Validate();
X = pubAsyKey.Q.AffineXCoord.GetEncoded();
Y = pubAsyKey.Q.AffineYCoord.GetEncoded();
return(ECDsa.Create(signParam));
}
public static bool Verify(ReadOnlyMemory <byte> publicKey, ReadOnlyMemory <byte> signature, ReadOnlySequence <byte> sequence)
{
ECParameters ecParameters;
{
var plist = SerializeHelper.Decode(publicKey).ToArray();
ecParameters = new ECParameters()
{
Q = new ECPoint()
{
X = plist[0].ToArray(),
Y = plist[1].ToArray(),
},
};
}
using (var ecdsa = ECDsa.Create())
{
ecdsa.ImportParameters(ecParameters);
return(ecdsa.VerifyHash(Sha2_256.ComputeHash(sequence).AsSpan(), signature.Span));
}
}
public _signatureProvider(SecurityKey key, string algorithm) : base(key, algorithm)
{
_key = key as JsonWebKey;
if (_key.Kty == JsonWebAlgorithmsKeyTypes.EllipticCurve)
{
var ecpa = new ECParameters
{
Curve = _curves[_key.Crv],
D = _key.D != null?Base64UrlEncoder.DecodeBytes(_key.D) : null,
Q = new ECPoint
{
X = Base64UrlEncoder.DecodeBytes(_key.X),
Y = Base64UrlEncoder.DecodeBytes(_key.Y)
}
};
_ecdsa = ECDsa.Create(ecpa);
}
else
{
throw new InvalidOperationException("Algorithm not yet supported");
}
}
public static void DecryptUsingWrongPrivateKeyType()
{
byte[] content = new byte[] { 1, 2, 3, 4 };
ContentInfo contentInfo = new ContentInfo(content);
AlgorithmIdentifier alg = new AlgorithmIdentifier(new Oid(Oids.Aes192));
EnvelopedCms ecms = new EnvelopedCms(contentInfo, alg);
using (X509Certificate2 cert = Certificates.RSAKeyTransfer1.GetCertificate())
{
CmsRecipient cmsRecipient = new CmsRecipient(SubjectIdentifierType.IssuerAndSerialNumber, cert);
ecms.Encrypt(cmsRecipient);
}
byte[] encoded = ecms.Encode();
ecms = new EnvelopedCms();
ecms.Decode(encoded);
using (ECDsa ecdsa = ECDsa.Create())
{
Assert.Throws <CryptographicException>(() => ecms.Decrypt(ecms.RecipientInfos[0], ecdsa));
}
}
/// <summary>
/// 根据传入的公私钥，对可签名的对象进行签名
/// </summary>
/// <param name="signable">要签名的数据</param>
/// <param name="prikey">私钥</param>
/// <param name="pubkey">公钥</param>
/// <returns>返回签名后的结果</returns>
internal static byte[] Sign(this ISignable signable, byte[] prikey, byte[] pubkey)
{
#if NET461
const int ECDSA_PRIVATE_P256_MAGIC = 0x32534345;
prikey = BitConverter.GetBytes(ECDSA_PRIVATE_P256_MAGIC).Concat(BitConverter.GetBytes(32)).Concat(pubkey).Concat(prikey).ToArray();
using (CngKey key = CngKey.Import(prikey, CngKeyBlobFormat.EccPrivateBlob))
using (ECDsaCng ecdsa = new ECDsaCng(key))
#else
using (var ecdsa = ECDsa.Create(new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
D = prikey,
Q = new ECPoint
{
X = pubkey.Take(32).ToArray(),
Y = pubkey.Skip(32).ToArray()
}
}))
#endif
{
return(ecdsa.SignHash(signable.GetHashForSigning()));
}
}
/// <summary>
/// 根据传入的公钥与签名，对可签名对象的签名进行验证
/// </summary>
/// <param name="signable">要验证的数据</param>
/// <param name="pubkey">公钥</param>
/// <param name="signature">签名</param>
/// <returns>返回验证结果</returns>
public static bool VerifySignature(this ISignable signable, Cryptography.ECC.ECPoint pubkey, byte[] signature)
{
byte[] pubk = pubkey.EncodePoint(false).Skip(1).ToArray();
#if NET461
const int ECDSA_PUBLIC_P256_MAGIC = 0x31534345;
pubk = BitConverter.GetBytes(ECDSA_PUBLIC_P256_MAGIC).Concat(BitConverter.GetBytes(32)).Concat(pubk).ToArray();
using (CngKey key = CngKey.Import(pubk, CngKeyBlobFormat.EccPublicBlob))
using (ECDsaCng ecdsa = new ECDsaCng(key))
#else
using (var ecdsa = ECDsa.Create(new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
Q = new ECPoint
{
X = pubk.Take(32).ToArray(),
Y = pubk.Skip(32).ToArray()
}
}))
#endif
{
return(ecdsa.VerifyHash(signable.GetHashForSigning(), signature));
}
}
/// <summary>
/// Gets a signing key based on settings
/// </summary>
/// <param name="settings">The identity settings</param>
/// <returns></returns>
private static ECDsaSecurityKey GetSigningKey(IdentitySettings settings)
{
// source directory
var sourceDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty;
// build full path to key
var fullKeyPath = Path.GetFullPath(settings.SigningKeyPath, sourceDirectory);
// read signing key path to load key
var eccPem = File.ReadAllText(fullKeyPath);
// build key and import
var edc = ECDsa.Create();
// import pem content into key
edc?.ImportFromPem(eccPem);
// create a security key based on ECD
return(new ECDsaSecurityKey(edc)
{
KeyId = "default"
});
}
public byte[] Sign(byte[] message, byte[] prikey, byte[] pubkey)
{
#if NET461
const int ECDSA_PRIVATE_P256_MAGIC = 0x32534345;
prikey = BitConverter.GetBytes(ECDSA_PRIVATE_P256_MAGIC).Concat(BitConverter.GetBytes(32)).Concat(pubkey).Concat(prikey).ToArray();
using (CngKey key = CngKey.Import(prikey, CngKeyBlobFormat.EccPrivateBlob))
using (ECDsaCng ecdsa = new ECDsaCng(key))
#else
using (var ecdsa = ECDsa.Create(new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
D = prikey,
Q = new ECPoint
{
X = pubkey.Take(32).ToArray(),
Y = pubkey.Skip(32).ToArray()
}
}))
#endif
{
return(ecdsa.SignData(message, HashAlgorithmName.SHA256));
}
}
public static void ECDSA_Signing_ECDSA_NoKeyUsageValidForECDSAAndECDH()
{
using ECDsa ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);
using ECDsa ecdsaLeaf = ECDsa.Create(ECCurve.NamedCurves.nistP256);
CertificateRequest issuerRequest = new CertificateRequest(
new X500DistinguishedName("CN=root"),
ecdsa,
HashAlgorithmName.SHA256);
issuerRequest.CertificateExtensions.Add(
new X509BasicConstraintsExtension(true, false, 0, true));
CertificateRequest request = new CertificateRequest(
new X500DistinguishedName("CN=test"),
ecdsaLeaf,
HashAlgorithmName.SHA256);
request.CertificateExtensions.Add(
new X509BasicConstraintsExtension(false, false, 0, true));
DateTimeOffset notBefore = DateTimeOffset.UtcNow;
DateTimeOffset notAfter = notBefore.AddDays(30);
byte[] serial = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
using X509Certificate2 issuer = issuerRequest.CreateSelfSigned(notBefore, notAfter);
using X509Certificate2 cert = request.Create(issuer, notBefore, notAfter, serial);
using ECDiffieHellman publicCertEcDhKey = cert.GetECDiffieHellmanPublicKey();
using ECDsa publicCertEcDsaKey = cert.GetECDsaPublicKey();
byte[] expectedSubjectPublicKeyInfo = ecdsaLeaf.ExportSubjectPublicKeyInfo();
Assert.NotNull(publicCertEcDhKey);
Assert.NotNull(publicCertEcDsaKey);
Assert.Equal(expectedSubjectPublicKeyInfo, publicCertEcDhKey.ExportSubjectPublicKeyInfo());
Assert.Equal(expectedSubjectPublicKeyInfo, publicCertEcDsaKey.ExportSubjectPublicKeyInfo());
}
public void FromECDsaP384()
{
#if (NET45 || NETCOREAPP1_1)
Assert.Inconclusive("ECDsa is not available.");
#else
// From https://tools.ietf.org/html/rfc6605#section-6.2
var privateKey = Convert.FromBase64String("WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR");
var dnsPublicKey = Convert.FromBase64String("xKYaNhWdGOfJ+nPrL8/arkwf2EY3MDJ+SErKivBVSum1w/egsXvSADtNJhyem5RCOpgQ6K8X1DRSEkrbYQ+OB+v8/uX45NBwY8rp65F6Glur8I/mlVNgF6W/qTI37m40");
var qx = new byte[48];
var qy = new byte[48];
Array.Copy(dnsPublicKey, 0, qx, 0, 48);
Array.Copy(dnsPublicKey, 48, qy, 0, 48);
// Create the public key
var parameters = new ECParameters
{
Curve = ECCurve.NamedCurves.nistP384,
Q = new ECPoint
{
X = qx,
Y = qy,
}
};
ECDsa publicKey = ECDsa.Create(parameters);
var dnskey = new DNSKEYRecord(publicKey)
{
Flags = DNSKEYFlags.ZoneKey | DNSKEYFlags.SecureEntryPoint
};
Assert.AreEqual(DNSKEYFlags.ZoneKey | DNSKEYFlags.SecureEntryPoint, dnskey.Flags);
Assert.AreEqual(3, dnskey.Protocol);
Assert.AreEqual(SecurityAlgorithm.ECDSAP384SHA384, dnskey.Algorithm);
CollectionAssert.AreEqual(dnsPublicKey, dnskey.PublicKey);
Assert.AreEqual(10771, dnskey.KeyTag());
#endif
}
public void FromECDsaP256()
{
#if (NET45 || NETCOREAPP1_1)
Assert.Inconclusive("ECDsa is not available.");
#else
// From https://tools.ietf.org/html/rfc6605#section-6.1
var privateKey = Convert.FromBase64String("GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=");
var dnsPublicKey = Convert.FromBase64String("GojIhhXUN/u4v54ZQqGSnyhWJwaubCvTmeexv7bR6edbkrSqQpF64cYbcB7wNcP+e+MAnLr+Wi9xMWyQLc8NAA==");
var qx = new byte[32];
var qy = new byte[32];
Array.Copy(dnsPublicKey, 0, qx, 0, 32);
Array.Copy(dnsPublicKey, 32, qy, 0, 32);
// Create the public key
var parameters = new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
Q = new ECPoint
{
X = qx,
Y = qy,
}
};
ECDsa publicKey = ECDsa.Create(parameters);
var dnskey = new DNSKEYRecord(publicKey)
{
Flags = DNSKEYFlags.ZoneKey | DNSKEYFlags.SecureEntryPoint
};
Assert.AreEqual(DNSKEYFlags.ZoneKey | DNSKEYFlags.SecureEntryPoint, dnskey.Flags);
Assert.AreEqual(3, dnskey.Protocol);
Assert.AreEqual(SecurityAlgorithm.ECDSAP256SHA256, dnskey.Algorithm);
CollectionAssert.AreEqual(dnsPublicKey, dnskey.PublicKey);
Assert.AreEqual(55648, dnskey.KeyTag());
#endif
}
/// <summary>
/// 验证签名
/// </summary>
/// <param name="message">已签名的数据</param>
/// <param name="signature">要验证的签名数据</param>
/// <param name="pubkey">公钥地址，是由02和03组成的</param>
/// <returns></returns>
public bool VerifySignature(byte[] message, byte[] signature, byte[] pubkey)
{
if (pubkey.Length == 33 && (pubkey[0] == 0x02 || pubkey[0] == 0x03))
{
try
{
pubkey = Cryptography.ECC.ECPoint.DecodePoint(pubkey, Cryptography.ECC.ECCurve.Secp256r1).EncodePoint(false).Skip(1).ToArray();
}
catch
{
return(false);
}
}
else if (pubkey.Length == 65 && pubkey[0] == 0x04)
{
pubkey = pubkey.Skip(1).ToArray();
}
else if (pubkey.Length != 64)
{
throw new ArgumentException();
}
using (var ecdsa = ECDsa.Create(new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256, //表示与公钥 (Q) 和可选私钥 (D) 相关联的曲线
Q = new ECPoint //表示椭圆曲线加密 (ECC) 算法的公钥 Q。表示椭圆曲线加密 (ECC) 结构的 (X,Y) 坐标对
{
X = pubkey.Take(32).ToArray(), //表示 X 坐标,公钥前32个字节
Y = pubkey.Skip(32).ToArray() // 表示 Y 坐标,公钥32个字节之后的数据
}
}))
{
//通过使用指定的哈希算法计算指定数据的哈希值，并将其与提供的签名进行比较，
//验证数字签名是否有效
return(ecdsa.VerifyData(message, signature, HashAlgorithmName.SHA256));
}
}
public static void SelfSign_ECC_DiminishedPoint_UseCertKeys()
{
X509Certificate2 cert;
ECParameters pubParams;
ECDsa priv2;
using (ECDsa ecdsa = ECDsa.Create(EccTestData.Secp521r1_DiminishedPublic_Data.KeyParameters))
{
pubParams = ecdsa.ExportParameters(false);
CertificateRequest request = new CertificateRequest(
"CN=localhost, OU=.NET Framework (CoreFX), O=Microsoft Corporation, L=Redmond, S=Washington, C=US",
ecdsa,
HashAlgorithmName.SHA512);
DateTimeOffset now = DateTimeOffset.UtcNow;
cert = request.CreateSelfSigned(now, now.AddDays(90));
priv2 = cert.GetECDsaPrivateKey();
}
using (cert)
using (priv2)
using (ECDsa pub = ECDsa.Create(pubParams))
{
Assert.True(cert.HasPrivateKey, "cert.HasPrivateKey");
Assert.NotNull(priv2);
byte[] sig = priv2.SignData(pubParams.Q.X, HashAlgorithmName.SHA384);
Assert.True(
pub.VerifyData(pubParams.Q.X, sig, HashAlgorithmName.SHA384),
"Cert signature validates with public key");
}
}
public void GenerateAndSign()
{
var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);
// generate a key ring
string passPhrase = "test";
var keyRingGen = new PgpKeyRingGenerator(ecdsa, "*****@*****.**", passPhrase);
PgpPublicKeyRing pubRing = keyRingGen.GeneratePublicKeyRing();
PgpSecretKeyRing secRing = keyRingGen.GenerateSecretKeyRing();
KeyTestHelper.SignAndVerifyTestMessage(secRing.GetSecretKey().ExtractPrivateKey(passPhrase), pubRing.GetPublicKey());
PgpPublicKeyRing pubRingEnc = new PgpPublicKeyRing(pubRing.GetEncoded());
Assert.AreEqual(pubRing.GetEncoded(), pubRingEnc.GetEncoded(), "public key ring encoding failed");
PgpSecretKeyRing secRingEnc = new PgpSecretKeyRing(secRing.GetEncoded());
Assert.AreEqual(secRing.GetEncoded(), secRingEnc.GetEncoded(), "secret key ring encoding failed");
// try a signature using encoded key
KeyTestHelper.SignAndVerifyTestMessage(secRing.GetSecretKey().ExtractPrivateKey(passPhrase), secRing.GetSecretKey());
}
public ISignatureAlgorithm ToSignatureAlgorithm(ClientDataRecord dataRecord, SharedSecretEncryptionKey encryptionKey)
{
if (dataRecord == null)
{
throw new ArgumentNullException(nameof(dataRecord));
}
switch (dataRecord.SigType)
{
case string str when str.Equals("rsa", StringComparison.OrdinalIgnoreCase):
using (var rsaForVerification = new RSACryptoServiceProvider())
{
rsaForVerification.FromXml(dataRecord.SigParameter);
var paramsForVerification = rsaForVerification.ExportParameters(false);
return(SignatureAlgorithm.CreateForVerification(paramsForVerification, new HashAlgorithmName(dataRecord.SigHashAlgorithm)));
}
case string str when str.Equals("ecdsa", StringComparison.OrdinalIgnoreCase):
using (var ecdsaForVerification = ECDsa.Create())
{
ecdsaForVerification.FromXml(dataRecord.SigParameter);
var paramsForVerification = ecdsaForVerification.ExportParameters(false);
return(SignatureAlgorithm.CreateForVerification(paramsForVerification, new HashAlgorithmName(dataRecord.SigHashAlgorithm)));
}
case string str when str.Equals("hmac", StringComparison.OrdinalIgnoreCase):
var unencryptedKey = GetUnencryptedParameter(dataRecord, encryptionKey);
return(SignatureAlgorithm.CreateForVerification(unencryptedKey, new HashAlgorithmName(dataRecord.SigHashAlgorithm)));
default:
throw new NotSupportedException($"The specified signature algorithm type ({dataRecord.SigHashAlgorithm ?? "[null]"}) cannot be deserialized.");
}
}
/// <inheritdoc/>
public override AsymmetricSecurityKey ToSecurityKey()
{
var curve = Algorithm switch
{
"ES256" => "P-256",
"ES384" => "P-384",
"ES512" => "P-521",
_ => throw new Exception("Invalid SigningAlgorithm")
};
var parameters = new ECParameters {
Curve = CryptoHelper.GetCurveFromCrvValue(curve),
D = D,
Q = Q,
};
var key = new ECDsaSecurityKey(ECDsa.Create(parameters))
{
KeyId = Id
};
return(key);
}
}
