ECDiffieHellmanCng Classe

Référence

Définition

Espace de noms:: System.Security.Cryptography

Assembly:: System.Security.Cryptography.Cng.dll

Assembly:: System.Security.Cryptography.dll

Assembly:: System.Core.dll

Paquet:: System.Security.Cryptography.Cng v5.0.0

Source:: Cng.NotSupported.cs

Source:: Cng.NotSupported.cs

Source:: Cng.NotSupported.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit une implémentation CNG (Cryptography Next Generation) de l'algorithme ECDH (Elliptic Curve Diffie-Hellman). Cette classe est utilisée pour exécuter des opérations de chiffrement.

public ref class ECDiffieHellmanCng sealed : System::Security::Cryptography::ECDiffieHellman

public sealed class ECDiffieHellmanCng : System.Security.Cryptography.ECDiffieHellman

type ECDiffieHellmanCng = class
    inherit ECDiffieHellman

Public NotInheritable Class ECDiffieHellmanCng
Inherits ECDiffieHellman

Héritage: Object

AsymmetricAlgorithm

ECDiffieHellman
ECDiffieHellmanCng

Héritage: Object

AsymmetricAlgorithm

ECAlgorithm

ECDiffieHellman
ECDiffieHellmanCng

Exemples

L’exemple suivant montre comment utiliser la ECDiffieHellmanCng classe pour établir un échange de clés et comment utiliser cette clé pour chiffrer un message qui peut être envoyé via un canal public et déchiffré par le récepteur.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class Alice
{
    public static byte[] alicePublicKey;

    public static void Main(string[] args)
    {
        using (ECDiffieHellmanCng alice = new ECDiffieHellmanCng())
        {

            alice.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
            alice.HashAlgorithm = CngAlgorithm.Sha256;
            alicePublicKey = alice.PublicKey.ToByteArray();
            Bob bob = new Bob();
            CngKey bobKey = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob);
            byte[] aliceKey = alice.DeriveKeyMaterial(bobKey);
            byte[] encryptedMessage = null;
            byte[] iv = null;
            Send(aliceKey, "Secret message", out encryptedMessage, out iv);
            bob.Receive(encryptedMessage, iv);
        }
    }

    private static void Send(byte[] key, string secretMessage, out byte[] encryptedMessage, out byte[] iv)
    {
        using (Aes aes = new AesCryptoServiceProvider())
        {
            aes.Key = key;
            iv = aes.IV;

            // Encrypt the message
            using (MemoryStream ciphertext = new MemoryStream())
            using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write))
            {
                byte[] plaintextMessage = Encoding.UTF8.GetBytes(secretMessage);
                cs.Write(plaintextMessage, 0, plaintextMessage.Length);
                cs.Close();
                encryptedMessage = ciphertext.ToArray();
            }
        }
    }
}
public class Bob
{
    public byte[] bobPublicKey;
    private byte[] bobKey;
    public Bob()
    {
        using (ECDiffieHellmanCng bob = new ECDiffieHellmanCng())
        {

            bob.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
            bob.HashAlgorithm = CngAlgorithm.Sha256;
            bobPublicKey = bob.PublicKey.ToByteArray();
            bobKey = bob.DeriveKeyMaterial(CngKey.Import(Alice.alicePublicKey, CngKeyBlobFormat.EccPublicBlob));
        }
    }

    public void Receive(byte[] encryptedMessage, byte[] iv)
    {

        using (Aes aes = new AesCryptoServiceProvider())
        {
            aes.Key = bobKey;
            aes.IV = iv;
            // Decrypt the message
            using (MemoryStream plaintext = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(encryptedMessage, 0, encryptedMessage.Length);
                    cs.Close();
                    string message = Encoding.UTF8.GetString(plaintext.ToArray());
                    Console.WriteLine(message);
                }
            }
        }
    }
}

Imports System.IO
Imports System.Security.Cryptography
Imports System.Text




Class Alice
    Public Shared alicePublicKey() As Byte


    Public Shared Sub Main(ByVal args() As String)
        Using alice As New ECDiffieHellmanCng()
            alice.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash
            alice.HashAlgorithm = CngAlgorithm.Sha256
            alicePublicKey = alice.PublicKey.ToByteArray()
            Dim bob As New Bob()
            Dim k As CngKey = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob)
            Dim aliceKey As Byte() = alice.DeriveKeyMaterial(CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob))
            Dim encryptedMessage As Byte() = Nothing
            Dim iv As Byte() = Nothing
            Send(aliceKey, "Secret message", encryptedMessage, iv)
            bob.Receive(encryptedMessage, iv)
        End Using
    End Sub


    Private Shared Sub Send(ByVal key() As Byte, ByVal secretMessage As String, ByRef encryptedMessage() As Byte, ByRef iv() As Byte)
        Using aes As New AesCryptoServiceProvider()
            aes.Key = key
            iv = aes.IV

            ' Encrypt the message
            Using ciphertext As New MemoryStream()
                Using cs As New CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write)
                    Dim plaintextMessage As Byte() = Encoding.UTF8.GetBytes(secretMessage)
                    cs.Write(plaintextMessage, 0, plaintextMessage.Length)
                    cs.Close()
                    encryptedMessage = ciphertext.ToArray()
                End Using
            End Using
        End Using

    End Sub
End Class

Public Class Bob
    Public bobPublicKey() As Byte
    Private bobKey() As Byte

    Public Sub New()
        Using bob As New ECDiffieHellmanCng()

            bob.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash
            bob.HashAlgorithm = CngAlgorithm.Sha256
            bobPublicKey = bob.PublicKey.ToByteArray()
            bobKey = bob.DeriveKeyMaterial(CngKey.Import(Alice.alicePublicKey, CngKeyBlobFormat.EccPublicBlob))
        End Using

    End Sub


    Public Sub Receive(ByVal encryptedMessage() As Byte, ByVal iv() As Byte)

        Using aes As New AesCryptoServiceProvider()
                aes.Key = bobKey
                aes.IV = iv
                ' Decrypt the message
            Using plaintext As New MemoryStream()
                Using cs As New CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write)
                    cs.Write(encryptedMessage, 0, encryptedMessage.Length)
                    cs.Close()
                    Dim message As String = Encoding.UTF8.GetString(plaintext.ToArray())
                    Console.WriteLine(message)
                End Using
            End Using
        End Using
    End Sub
End Class

Remarques

La ECDiffieHellmanCng classe permet à deux parties d’échanger du matériel de clé privée même si elles communiquent via un canal public. Les deux parties peuvent calculer la même valeur de secret, qui est appelée contrat secret dans les classes Diffie-Hellman managées. L’accord secret peut ensuite être utilisé à diverses fins, notamment en tant que clé symétrique. Toutefois, au lieu d’exposer directement le contrat secret, la ECDiffieHellmanCng classe effectue un post-traitement sur le contrat avant de fournir la valeur. Ce post-traitement est appelé fonction de dérivation de clé (KDF) ; vous pouvez sélectionner le KDF que vous souhaitez utiliser et définir ses paramètres via un ensemble de propriétés sur l’instance de l’objet Diffie-Hellman.

Fonction de dérivation de clé	Propriétés
Hash	HashAlgorithm - Algorithme de hachage utilisé pour traiter l’accord secret. SecretPrepend - Tableau d’octets facultatif à ajouter au contrat secret avant de le hacher. SecretAppend - Tableau d’octets facultatif à ajouter au contrat secret avant de le hacher.
Hmac	HashAlgorithm - Algorithme de hachage utilisé pour traiter l’accord secret. SecretPrepend- Tableau d’octets facultatif à ajouter au contrat secret avant de le hacher. SecretAppend - Tableau d’octets facultatif à ajouter au contrat secret avant de le hacher.
Tls	Label - Étiquette pour la dérivation de clé. Seed - Seed pour la dérivation de clé.

Le résultat de la transmission de l’accord secret via la fonction de dérivation de clé est un tableau d’octets qui peut être utilisé comme matériau clé pour votre application. Le nombre d’octets de matériel de clé généré dépend de la fonction de dérivation de clé ; par exemple, SHA-256 génère 256 bits de matériel clé, tandis que SHA-512 génère 512 bits de matériel clé. Le flux de base d’un échange de clés ECDH est le suivant :

Alice et Bob créent une paire de clés à utiliser pour l’opération d’échange de clés Diffie-Hellman
Alice et Bob configurent le KDF à l’aide des paramètres de l’accord.
Alice envoie sa clé publique à Bob.
Bob envoie sa clé publique à Alice.
Alice et Bob utilisent les clés publiques de l’autre pour générer l’accord secret et appliquent le KDF à l’accord secret pour générer du matériel clé.

Constructeurs

ECDiffieHellmanCng()	Initialise une nouvelle instance de la classe ECDiffieHellmanCng avec une paire de clés aléatoire.
ECDiffieHellmanCng(CngKey)	Initialise une nouvelle instance de la classe ECDiffieHellmanCng à l'aide de l'objet CngKey spécifié.
ECDiffieHellmanCng(ECCurve)	Crée une nouvelle instance de la classe ECDiffieHellmanCng dont la paire de clés publique/privée est générée sur la courbe spécifiée.
ECDiffieHellmanCng(Int32)	Initialise une nouvelle instance de la classe ECDiffieHellmanCng avec une paire de clés aléatoire, à l’aide de la taille de clé spécifiée.

Champs

KeySizeValue	Représente la taille, en bits, du modulo de la clé utilisé par l'algorithme asymétrique. (Hérité de AsymmetricAlgorithm)
LegalKeySizesValue	Spécifie les tailles de clé prises en charge par l'algorithme asymétrique. (Hérité de AsymmetricAlgorithm)

Propriétés

HashAlgorithm	Obtient ou définit l'algorithme de hachage à utiliser lors de la génération du matériel de clé.
HmacKey	Obtient ou définit la clé HMAC (Hash-based Message Authentication Code) à utiliser lorsque le matériel de clé est dérivé.
Key	Spécifie le CngKey utilisé par l'objet actuel pour les opérations de chiffrement.
KeyDerivationFunction	Obtient ou définit la fonction de dérivation de clés pour la classe ECDiffieHellmanCng.
KeyExchangeAlgorithm	Obtient le nom de l'algorithme d'échange de clés. (Hérité de ECDiffieHellman)
KeySize	Obtient ou définit la taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.
KeySize	Obtient ou définit la taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique. (Hérité de AsymmetricAlgorithm)
Label	Obtient ou définit la valeur d'étiquette utilisée pour la dérivation de clés.
LegalKeySizes	Obtient les tailles de clé prises en charge par l'algorithme asymétrique.
LegalKeySizes	Obtient les tailles de clé prises en charge par l'algorithme asymétrique. (Hérité de AsymmetricAlgorithm)
PublicKey	Obtient la clé publique qui peut être utilisée par un autre objet ECDiffieHellmanCng pour générer un accord secret partagé.
SecretAppend	Obtient ou définit une valeur qui sera ajoutée à l'accord secret lors de la génération du matériel de clé.
SecretPrepend	Obtient ou définit une valeur qui sera ajoutée au début de l'accord secret lors de la dérivation du matériel de clé.
Seed	Obtient ou définit la valeur initiale qui sera utilisée lors de la dérivation du matériel de clé.
SignatureAlgorithm	Obtient le nom de l'algorithme de signature. (Hérité de ECDiffieHellman)
UseSecretAgreementAsHmacKey	Obtient une valeur qui indique si l'accord secret est utilisé comme une clé HMAC (Hash-based Message Authentication Code) pour dériver le matériel de clé.

Méthodes

Clear()	Libère toutes les ressources utilisées par la classe AsymmetricAlgorithm. (Hérité de AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)	Effectue une dérivation de clés à l’aide d’un algorithme de hachage spécifié. (Hérité de ECDiffieHellman)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])	Effectue une dérivation de clés à l’aide d’un algorithme de hachage spécifié avec des données facultatives ajoutées au début ou à la fin.
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])	En cas d’implémentation dans une classe dérivée, effectue une dérivation de clés à l’aide d’un algorithme de hachage spécifié avec des données facultatives ajoutées au début ou à la fin. (Hérité de ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])	Effectue une dérivation de clés à l’aide d’un algorithme HMAC (Hash-based Message Authentication Code) spécifié. (Hérité de ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])	Effectue une dérivation de clés à l’aide d’un algorithme HMAC (Hash-based Message Authentication Code) spécifié avec des données facultatives ajoutées au début ou à la fin.
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])	En cas d’implémentation dans une classe dérivée, effectue une dérivation de clés à l’aide d’un algorithme HMAC (Hash-based Message Authentication Code) spécifié avec des données facultatives ajoutées au début ou à la fin. (Hérité de ECDiffieHellman)
DeriveKeyMaterial(CngKey)	Dérive le matériel de clé généré par l'accord secret entre deux correspondants, étant donné un objet CngKey qui contient la clé publique du deuxième correspondant.
DeriveKeyMaterial(ECDiffieHellmanPublicKey)	Dérive le matériel de clé généré par l'accord secret entre deux correspondants, étant donné un objet ECDiffieHellmanPublicKey qui contient la clé publique du deuxième correspondant.
DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])	Effectue une dérivation de clés à l’aide de la fonction pseudo-aléatoire (PRF) du protocole TLS (Transport Layer Security) 1.1.
DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])	En cas d’implémentation dans une classe dérivée, effectue une dérivation de clés à l’aide de la fonction pseudo-aléatoire (PRF) du protocole TLS (Transport Layer Security) 1.1. (Hérité de ECDiffieHellman)
DeriveRawSecretAgreement(ECDiffieHellmanPublicKey)	Dérivez la matière de clé brute. (Hérité de ECDiffieHellman)
DeriveSecretAgreementHandle(CngKey)	Obtient un handle pour l'accord secret généré entre deux correspondants, étant donné un objet CngKey qui contient la clé publique du deuxième correspondant.
DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey)	Obtient un handle pour l'accord secret généré entre deux correspondants, étant donné un objet ECDiffieHellmanPublicKey qui contient la clé publique du deuxième correspondant.
Dispose()	Libère toutes les ressources utilisées par l'instance actuelle de la classe AsymmetricAlgorithm. (Hérité de AsymmetricAlgorithm)
Dispose(Boolean)	Libère les ressources non managées utilisées par la classe AsymmetricAlgorithm et libère éventuellement les ressources managées. (Hérité de AsymmetricAlgorithm)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
ExportECPrivateKey()	Exporte la clé actuelle au format ECPrivateKey. (Hérité de ECDiffieHellman)
ExportECPrivateKeyPem()	Exporte la clé actuelle au format ECPrivateKey, encodé pem. (Hérité de ECAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur l’octet.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur l’octet. (Hérité de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char. (Hérité de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur des octets, encodé en PEM. (Hérité de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char, encodé pem. (Hérité de AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)	Exporte les paramètres de clé et de courbe explicite utilisés par l’objet ECCurve dans un objet ECParameters.
ExportExplicitParameters(Boolean)	En cas de substitution dans une classe dérivée, exporte les informations de clé publique ou des clés publique et privée d’une clé ECDiffieHellman valide à l’aide du formulaire de courbe explicite vers une structure ECParameters pour qu’elle puisse être passée à la méthode ImportParameters(ECParameters). (Hérité de ECDiffieHellman)
ExportParameters(Boolean)	Exporte la clé utilisée par l'objet ECCurve dans un objet ECParameters.
ExportParameters(Boolean)	En cas de substitution dans une classe dérivée, exporte les informations de clé publique ou des clés publique et privée d’une clé ECDiffieHellman valide vers une structure ECParameters pour qu’elle puisse être passée à la méthode ImportParameters(ECParameters). (Hérité de ECDiffieHellman)
ExportPkcs8PrivateKey()	Exporte la clé actuelle au format PKCS#8 PrivateKeyInfo. (Hérité de AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Exporte la clé actuelle au format PKCS#8 PrivateKeyInfo, encodé en PEM. (Hérité de AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()	Exporte la partie clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo. (Hérité de AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Exporte la partie clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo, encodé en PEM. (Hérité de AsymmetricAlgorithm)
FromXmlString(String)	Cette méthode n’est pas implémentée.
FromXmlString(String)	Cette méthode lève une exception dans tous les cas. (Hérité de ECDiffieHellman)
FromXmlString(String, ECKeyXmlFormat)	Obsolète. Désérialise les informations de clés d'une chaîne XML en utilisant le format spécifié.
GenerateKey(ECCurve)	Génère une nouvelle paire de clés publique/privée éphémère pour la courbe spécifiée.
GenerateKey(ECCurve)	En cas de substitution dans une classe dérivée, génère une nouvelle paire de clés publique/privée éphémère pour la courbe spécifiée. (Hérité de ECDiffieHellman)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure ECPrivateKey, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur l’octet, en remplaçant les clés de cet objet.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur l’octet, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur char, en remplaçant les clés de cet objet.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur char, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)	Importe une clé privée chiffrée encodée en PEM RFC 7468, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Importe une clé privée chiffrée encodée en PEM RFC 7468, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportFromPem(ReadOnlySpan<Char>)	Importe une clé encodée EN PEM RFC 7468, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportParameters(ECParameters)	Importe les paramètres spécifiés pour un objet ECCurve comme clé dans l’instance actuelle.
ImportParameters(ECParameters)	En cas de substitution dans une classe dérivée, importe les paramètres spécifiés pour une ECCurve en tant que clé éphémère dans l’objet ECDiffieHellman actuel. (Hérité de ECDiffieHellman)
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure PKCS#8 PrivateKeyInfo après le déchiffrement, en remplaçant les clés de cet objet.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	Importe la paire de clés publique/privée à partir d’une structure PKCS#8 PrivateKeyInfo après le déchiffrement, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)	Importe la clé publique à partir d’une structure X.509 SubjectPublicKeyInfo après le déchiffrement, en remplaçant les clés de cet objet. (Hérité de ECDiffieHellman)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
ToXmlString(Boolean)	Cette méthode n’est pas implémentée.
ToXmlString(Boolean)	Cette méthode lève une exception dans tous les cas. (Hérité de ECDiffieHellman)
ToXmlString(ECKeyXmlFormat)	Obsolète. Sérialise les informations de clés en une chaîne XML en utilisant le format spécifié.
TryExportECPrivateKey(Span<Byte>, Int32)	Tente d’exporter la clé actuelle dans le format `ECPrivateKey` dans une mémoire tampon fournie. (Hérité de ECDiffieHellman)
TryExportECPrivateKeyPem(Span<Char>, Int32)	Tente d’exporter la clé actuelle au format ECPrivateKey encodé en PEM dans une mémoire tampon fournie. (Hérité de ECAlgorithm)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo dans une mémoire tampon fournie, à l’aide d’un mot de passe basé sur l’octet.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo dans une mémoire tampon fournie, à l’aide d’un mot de passe basé sur l’octet. (Hérité de ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo dans une mémoire tampon fournie, à l’aide d’un mot de passe basé sur char.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo dans une mémoire tampon fournie, à l’aide d’un mot de passe basé sur char. (Hérité de ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur des octets, encodé pem. (Hérité de AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char, encodé pem. (Hérité de AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo dans une mémoire tampon fournie.
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo dans une mémoire tampon fournie. (Hérité de ECDiffieHellman)
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo encodé en PEM dans une mémoire tampon fournie. (Hérité de AsymmetricAlgorithm)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)	Tente d’exporter la clé actuelle au format X.509 SubjectPublicKeyInfo dans une mémoire tampon fournie. (Hérité de ECDiffieHellman)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	Tente d’exporter la clé actuelle au format X.509 SubjectPublicKeyInfo encodé en PEM dans une mémoire tampon fournie. (Hérité de AsymmetricAlgorithm)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Pour obtenir une description de ce membre, consultez Dispose().

(Hérité de AsymmetricAlgorithm)

S’applique à

Partager via