ECDiffieHellmanCng ECDiffieHellmanCng ECDiffieHellmanCng ECDiffieHellmanCng Class

Définition

Fournit une implémentation CNG (Cryptography Next Generation) de l'algorithme ECDH (Elliptic Curve Diffie-Hellman).Provides a Cryptography Next Generation (CNG) implementation of the Elliptic Curve Diffie-Hellman (ECDH) algorithm. Cette classe est utilisée pour exécuter des opérations de chiffrement.This class is used to perform cryptographic operations.

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

Exemples

L’exemple suivant montre comment utiliser le ECDiffieHellmanCng classe pour établir un échange de clés et l’utilisation de cette clé pour chiffrer un message qui peut être envoyé via un canal public et déchiffré par le destinataire.The following example shows how to use the ECDiffieHellmanCng class to establish a key exchange and how to use that key to encrypt a message that can be sent over a public channel and decrypted by the receiver.

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 k = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob);
            byte[] aliceKey = alice.DeriveKeyMaterial(CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob));
            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
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 'Main


    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 'Send 
End Class 'Alice

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 'New


    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 'Receive
End Class 'Bob 

Remarques

Le ECDiffieHellmanCng classe permet de deux parties échanger la clé privée même s’ils communiquent via un canal public.The ECDiffieHellmanCng class enables two parties to exchange private key material even if they are communicating through a public channel. Les deux parties peuvent calculer la même valeur secrète, qui est appelée le accord secret dans les classes Diffie-Hellman managées.Both parties can calculate the same secret value, which is referred to as the secret agreement in the managed Diffie-Hellman classes. L’accord secret peut ensuite être utilisé à diverses fins, notamment comme une clé symétrique.The secret agreement can then be used for a variety of purposes, including as a symmetric key. Toutefois, au lieu d’exposer directement, de l’accord secret la ECDiffieHellmanCng classe procède à un traitement consécutives sur l’accord avant de fournir la valeur.However, instead of exposing the secret agreement directly, the ECDiffieHellmanCng class does some post-processing on the agreement before providing the value. Ce traitement post est appelé le la clé de fonction de dérivation (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.This post processing is referred to as the key derivation function (KDF); you can select which KDF you want to use and set its parameters through a set of properties on the instance of the Diffie-Hellman object.

Fonction de dérivation de cléKey derivation function PropriétésProperties
Hash HashAlgorithm -L’algorithme de hachage qui est utilisé pour traiter l’accord secret.HashAlgorithm - The hash algorithm that is used to process the secret agreement.

SecretPrepend -Tableau d’octets facultatif à ajouter à l’accord secret avant de le hacher.SecretPrepend - An optional byte array to prepend to the secret agreement before hashing it.

SecretAppend -Tableau d’octets facultatif à ajouter à l’accord secret avant de le hacher.SecretAppend - An optional byte array to append to the secret agreement before hashing it.
Hmac HashAlgorithm -L’algorithme de hachage qui est utilisé pour traiter l’accord secret.HashAlgorithm - The hash algorithm that is used to process the secret agreement.

SecretPrepend-Tableau d’octets facultatif à ajouter à l’accord secret avant de le hacher.SecretPrepend- An optional byte array to prepend to the secret agreement before hashing it.

SecretAppend -Tableau d’octets facultatif à ajouter à l’accord secret avant de le hacher.SecretAppend - An optional byte array to append to the secret agreement before hashing it.
Tls Label -L’étiquette de dérivation de clé.Label - The label for key derivation.

Seed -La valeur de départ pour la dérivation de clé.Seed - The seed for key derivation.

Le résultat du passage de l’accord secret via la fonction de dérivation de clé est un tableau d’octets qui peut-être être utilisé en tant que le matériel de clé pour votre application.The result of passing the secret agreement through the key derivation function is a byte array that may be used as key material for your 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érera 256 bits de matériel de clé, tandis que SHA-512 génèrent 512 bits de matériel de clé. Le flux de base d’un échange de clé ECDH est comme suit :The number of bytes of key material generated is dependent on the key derivation function; for example, SHA-256 will generate 256 bits of key material, whereas SHA-512 will generate 512 bits of key material.The basic flow of an ECDH key exchange is as follows:

  1. Alice et Bob créent une paire de clés à utiliser pour l’opération d’échange de clés Diffie-HellmanAlice and Bob create a key pair to use for the Diffie-Hellman key exchange operation

  2. Alice et Bob configurent le KDF à l’aide des paramètres de l’accord sur.Alice and Bob configure the KDF using parameters the agree on.

  3. Alice envoie sa clé publique à Bob.Alice sends Bob her public key.

  4. Bob envoie sa clé publique à Alice.Bob sends Alice his public key.

  5. Alice et Bob utilisent des clés publiques entre eux pour générer l’accord secret et applique le KDF à l’accord secret pour générer le matériel clé.Alice and Bob use each other's public keys to generate the secret agreement, and apply the KDF to the secret agreement to generate key material.

Constructeurs

ECDiffieHellmanCng() ECDiffieHellmanCng() ECDiffieHellmanCng() ECDiffieHellmanCng()

Initialise une nouvelle instance de la classe ECDiffieHellmanCng avec une paire de clés aléatoire.Initializes a new instance of the ECDiffieHellmanCng class with a random key pair.

ECDiffieHellmanCng(CngKey) ECDiffieHellmanCng(CngKey) ECDiffieHellmanCng(CngKey) ECDiffieHellmanCng(CngKey)

Initialise une nouvelle instance de la classe ECDiffieHellmanCng à l'aide de l'objet CngKey spécifié.Initializes a new instance of the ECDiffieHellmanCng class by using the specified CngKey object.

ECDiffieHellmanCng(ECCurve) ECDiffieHellmanCng(ECCurve) ECDiffieHellmanCng(ECCurve) 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.Creates a new instance of the ECDiffieHellmanCng class whose public/private key pair is generated over the specified curve.

ECDiffieHellmanCng(Int32) ECDiffieHellmanCng(Int32) ECDiffieHellmanCng(Int32) 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.Initializes a new instance of the ECDiffieHellmanCng class with a random key pair, using the specified key size.

Propriétés

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

Obtient ou définit l'algorithme de hachage à utiliser lors de la génération du matériel de clé.Gets or sets the hash algorithm to use when generating key material.

HmacKey HmacKey HmacKey HmacKey

Obtient ou définit la clé HMAC (Hash-based Message Authentication Code) à utiliser lorsque le matériel de clé est dérivé.Gets or sets the Hash-based Message Authentication Code (HMAC) key to use when deriving key material.

Key Key Key Key

Spécifie le CngKey utilisé par l'objet actuel pour les opérations de chiffrement.Specifies the CngKey that is used by the current object for cryptographic operations.

KeyDerivationFunction KeyDerivationFunction KeyDerivationFunction KeyDerivationFunction

Obtient ou définit la fonction de dérivation de clés pour la classe ECDiffieHellmanCng.Gets or sets the key derivation function for the ECDiffieHellmanCng class.

KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm

Obtient le nom de l'algorithme d'échange de clés.Gets the name of the key exchange algorithm.

(Inherited from ECDiffieHellman)
KeySize KeySize KeySize KeySize
Label Label Label Label

Obtient ou définit la valeur d'étiquette utilisée pour la dérivation de clés.Gets or sets the label value that is used for key derivation.

LegalKeySizes LegalKeySizes LegalKeySizes LegalKeySizes
PublicKey PublicKey PublicKey PublicKey

Obtient la clé publique qui peut être utilisée par un autre objet ECDiffieHellmanCng pour générer un accord secret partagé.Gets the public key that can be used by another ECDiffieHellmanCng object to generate a shared secret agreement.

SecretAppend SecretAppend SecretAppend 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é.Gets or sets a value that will be appended to the secret agreement when generating key material.

SecretPrepend SecretPrepend SecretPrepend 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é.Gets or sets a value that will be added to the beginning of the secret agreement when deriving key material.

Seed Seed Seed Seed

Obtient ou définit la valeur initiale qui sera utilisée lors de la dérivation du matériel de clé.Gets or sets the seed value that will be used when deriving key material.

SignatureAlgorithm SignatureAlgorithm SignatureAlgorithm SignatureAlgorithm

Obtient le nom de l'algorithme de signature.Gets the name of the signature algorithm.

(Inherited from ECDiffieHellman)
UseSecretAgreementAsHmacKey UseSecretAgreementAsHmacKey UseSecretAgreementAsHmacKey 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é.Gets a value that indicates whether the secret agreement is used as a Hash-based Message Authentication Code (HMAC) key to derive key material.

Méthodes

Clear() Clear() Clear() Clear()

Libère toutes les ressources utilisées par la classe AsymmetricAlgorithm.Releases all resources used by the AsymmetricAlgorithm class.

(Inherited from AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)

Dérive des octets qui peuvent être utilisés comme une clé à l’aide d’une fonction de hachage, en fonction de la clé publique d’une autre partie et du nom de l’algorithme de hachage.Derives bytes that can be used as a key using a hash function, given another party's public key and hash algorithm's name.

(Inherited from ECDiffieHellman)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[]) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[]) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[]) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])

Dérive des octets qui peuvent être utilisés comme une clé à l’aide d’une fonction de hachage, en fonction de la clé publique d’une autre partie, le nom de l’algorithme de hachage, une valeur à ajouter au début et une valeur à ajouter à la fin.Derives bytes that can be used as a key using a hash function, given another party's public key, hash algorithm's name, a prepend value and an append value.

DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])

Dérive des octets qui peuvent être utilisés comme clé à l’aide d’un code d’authentification de message haché (HMAC).Derives bytes that can be used as a key using a Hash-based Message Authentication Code (HMAC).

(Inherited from ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])

Dérive des octets qui peuvent être utilisés comme clé à l’aide d’un code d’authentification de message haché (HMAC).Derives bytes that can be used as a key using a Hash-based Message Authentication Code (HMAC).

DeriveKeyMaterial(CngKey) DeriveKeyMaterial(CngKey) DeriveKeyMaterial(CngKey) 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.Derives the key material that is generated from the secret agreement between two parties, given a CngKey object that contains the second party's public key.

DeriveKeyMaterial(ECDiffieHellmanPublicKey) DeriveKeyMaterial(ECDiffieHellmanPublicKey) DeriveKeyMaterial(ECDiffieHellmanPublicKey) 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.Derives the key material that is generated from the secret agreement between two parties, given an ECDiffieHellmanPublicKey object that contains the second party's public key.

DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[]) DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[]) DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[]) DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])

Dérive des octets qui peuvent être utilisés comme une clé à l’aide d’un algorithme de dérivation TLS (Transport Layer Security) PRF (Pseudo-Random Function).Derives bytes that can be used as a key using a Transport Layer Security (TLS) Pseudo-Random Function (PRF) derivation algorithm.

DeriveSecretAgreementHandle(CngKey) DeriveSecretAgreementHandle(CngKey) DeriveSecretAgreementHandle(CngKey) 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.Gets a handle to the secret agreement generated between two parties, given a CngKey object that contains the second party's public key.

DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey) DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey) DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey) 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.Gets a handle to the secret agreement generated between two parties, given an ECDiffieHellmanPublicKey object that contains the second party's public key.

Dispose() Dispose() Dispose() Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe AsymmetricAlgorithm.Releases all resources used by the current instance of the AsymmetricAlgorithm class.

(Inherited from AsymmetricAlgorithm)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Libère les ressources non managées utilisées par la classe AsymmetricAlgorithm et libère éventuellement les ressources managées.Releases the unmanaged resources used by the AsymmetricAlgorithm class and optionally releases the managed resources.

(Inherited from AsymmetricAlgorithm)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
ExportECPrivateKey() ExportECPrivateKey() ExportECPrivateKey() ExportECPrivateKey()

Exporte la clé actuelle au format ECPrivateKey.Exports the current key in the ECPrivateKey format.

(Inherited from ECDiffieHellman)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur l’octet.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a byte-based password.

(Inherited from AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a char-based password.

(Inherited from AsymmetricAlgorithm)
ExportExplicitParameters(Boolean) ExportExplicitParameters(Boolean) ExportExplicitParameters(Boolean) ExportExplicitParameters(Boolean)

Exporte les paramètres de clé et de courbe explicite utilisés par l’objet ECCurve dans un objet ECParameters.Exports the key and explicit curve parameters used by the ECCurve object into an ECParameters object.

ExportParameters(Boolean) ExportParameters(Boolean) ExportParameters(Boolean) ExportParameters(Boolean)

Exporte la clé utilisée par l'objet ECCurve dans un objet ECParameters.Exports the key used by the ECCurve object into an ECParameters object.

ExportPkcs8PrivateKey() ExportPkcs8PrivateKey() ExportPkcs8PrivateKey() ExportPkcs8PrivateKey()

Exporte la clé actuelle au format PKCS#8 PrivateKeyInfo.Exports the current key in the PKCS#8 PrivateKeyInfo format.

(Inherited from AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo() ExportSubjectPublicKeyInfo() ExportSubjectPublicKeyInfo() ExportSubjectPublicKeyInfo()

Exporte la partie clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo.Exports the public-key portion of the current key in the X.509 SubjectPublicKeyInfo format.

(Inherited from AsymmetricAlgorithm)
FromXmlString(String) FromXmlString(String) FromXmlString(String) FromXmlString(String)

Cette méthode n’est pas implémentée.This method is not implemented.

FromXmlString(String, ECKeyXmlFormat) FromXmlString(String, ECKeyXmlFormat) FromXmlString(String, ECKeyXmlFormat) FromXmlString(String, ECKeyXmlFormat)

Désérialise les informations de clés d'une chaîne XML en utilisant le format spécifié.Deserializes the key information from an XML string by using the specified format.

GenerateKey(ECCurve) GenerateKey(ECCurve) GenerateKey(ECCurve) GenerateKey(ECCurve)

Génère une nouvelle paire de clés publique/privée éphémère pour la courbe spécifiée.Generates a new ephemeral public/private key pair for the specified curve.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32) ImportECPrivateKey(ReadOnlySpan<Byte>, Int32) ImportECPrivateKey(ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from an ECPrivateKey structure, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a byte-based password, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a char-based password, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportParameters(ECParameters) ImportParameters(ECParameters) ImportParameters(ECParameters) ImportParameters(ECParameters)

Importe les paramètres spécifiés pour un objet ECCurve comme clé dans l’instance actuelle.Imports the specified parameters for an ECCurve object as a key into the current instance.

ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32) ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32) ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from a PKCS#8 PrivateKeyInfo structure after decryption, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32) ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32) ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32) 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.Imports the public key from an X.509 SubjectPublicKeyInfo structure after decryption, replacing the keys for this object.

(Inherited from ECDiffieHellman)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
ToXmlString(Boolean) ToXmlString(Boolean) ToXmlString(Boolean) ToXmlString(Boolean)

Cette méthode n’est pas implémentée.This method is not implemented.

ToXmlString(ECKeyXmlFormat) ToXmlString(ECKeyXmlFormat) ToXmlString(ECKeyXmlFormat) ToXmlString(ECKeyXmlFormat)

Sérialise les informations de clés en une chaîne XML en utilisant le format spécifié.Serializes the key information to an XML string by using the specified format.

TryExportECPrivateKey(Span<Byte>, Int32) TryExportECPrivateKey(Span<Byte>, Int32) TryExportECPrivateKey(Span<Byte>, Int32) TryExportECPrivateKey(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format ECPrivateKey dans une mémoire tampon fournie.Attempts to export the current key in the ECPrivateKey format into a provided buffer.

(Inherited from ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32) 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.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a byte-based password.

(Inherited from ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32) 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.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a char-based password.

(Inherited from ECDiffieHellman)
TryExportPkcs8PrivateKey(Span<Byte>, Int32) TryExportPkcs8PrivateKey(Span<Byte>, Int32) TryExportPkcs8PrivateKey(Span<Byte>, Int32) TryExportPkcs8PrivateKey(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo dans une mémoire tampon fournie.Attempts to export the current key in the PKCS#8 PrivateKeyInfo format into a provided buffer.

(Inherited from ECDiffieHellman)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32) TryExportSubjectPublicKeyInfo(Span<Byte>, Int32) TryExportSubjectPublicKeyInfo(Span<Byte>, Int32) TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format X.509 SubjectPublicKeyInfo dans une mémoire tampon fournie.Attempts to export the current key in the X.509 SubjectPublicKeyInfo format into a provided buffer.

(Inherited from ECDiffieHellman)

Champs

KeySizeValue KeySizeValue KeySizeValue KeySizeValue

Représente la taille, en bits, du modulo de la clé utilisé par l'algorithme asymétrique.Represents the size, in bits, of the key modulus used by the asymmetric algorithm.

(Inherited from AsymmetricAlgorithm)
LegalKeySizesValue LegalKeySizesValue LegalKeySizesValue LegalKeySizesValue

Spécifie les tailles de clé prises en charge par l'algorithme asymétrique.Specifies the key sizes that are supported by the asymmetric algorithm.

(Inherited from AsymmetricAlgorithm)

Implémentations d’interfaces explicites

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Pour obtenir une description de ce membre, consultez Dispose().For a description of this member, see Dispose().

(Inherited from AsymmetricAlgorithm)

S’applique à