ECDiffieHellman Classe

Définition

Fournit une classe de base abstraite de laquelle les implémentations de l'algorithme ECDH (Elliptic Curve Diffie-Hellman) peuvent dériver.Provides an abstract base class that Elliptic Curve Diffie-Hellman (ECDH) algorithm implementations can derive from. Cette classe fournit le jeu d'opérations de base que toutes les implémentations ECDH doivent prendre en charge.This class provides the basic set of operations that all ECDH implementations must support.

public ref class ECDiffieHellman abstract : System::Security::Cryptography::AsymmetricAlgorithm
public abstract class ECDiffieHellman : System.Security.Cryptography.AsymmetricAlgorithm
type ECDiffieHellman = class
    inherit AsymmetricAlgorithm
Public MustInherit Class ECDiffieHellman
Inherits AsymmetricAlgorithm
Héritage
ECDiffieHellman
Dérivé

Remarques

Cette classe sert de classe de base abstraite pour les implémentations ECDH.This class serves as the abstract base class for ECDH implementations.

Constructeurs

ECDiffieHellman()

Initialise une nouvelle instance de la classe ECDiffieHellman.Initializes a new instance of the ECDiffieHellman class.

Champs

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.

(Hérité de AsymmetricAlgorithm)
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.

(Hérité de AsymmetricAlgorithm)

Propriétés

KeyExchangeAlgorithm

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

KeySize

Obtient ou définit la taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.Gets or sets the size, in bits, of the key modulus used by the asymmetric algorithm.

(Hérité de AsymmetricAlgorithm)
LegalKeySizes

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

(Hérité de AsymmetricAlgorithm)
PublicKey

Obtient la clé publique utilisée par l'instance ECDH (Elliptic Curve Diffie-Hellman) actuelle.Gets the public key that is being used by the current Elliptic Curve Diffie-Hellman (ECDH) instance.

SignatureAlgorithm

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

Méthodes

Clear()

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

(Hérité de AsymmetricAlgorithm)
Create()

Crée une nouvelle instance de l'implémentation par défaut de l'algorithme ECDH (Elliptic Curve Diffie-Hellman).Creates a new instance of the default implementation of the Elliptic Curve Diffie-Hellman (ECDH) algorithm.

Create(ECCurve)

Crée une nouvelle instance de l’implémentation par défaut de l’algorithme Elliptic Curve Diffie-Hellman (ECDH) avec une nouvelle paire de clés publique/privée générée sur la courbe spécifiée.Creates a new instance of the default implementation of the Elliptic Curve Diffie-Hellman (ECDH) algorithm with a new public/private key-pair generated over the specified curve.

Create(ECParameters)

Crée une nouvelle instance de l’implémentation par défaut de l’algorithme ECDH (Elliptic Curve Diffie-Hellman) avec la clé décrite par l’objet ECParameters spécifié.Creates a new instance of the default implementation of the Elliptic Curve Diffie-Hellman (ECDH) algorithm with the key described by the specified ECParameters object.

Create(String)

Crée une nouvelle instance de l’implémentation spécifiée de l’algorithme ECHD (Elliptic Curve Diffie-Hellman).Creates a new instance of the specified implementation of the Elliptic Curve Diffie-Hellman (ECDH) algorithm.

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.

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

En cas d’implémentation dans une classe dérivée, 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.When implemented in a derived class, 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[])

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).

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

En cas d’implémentation dans une classe dérivée, dérive des octets qui peuvent être utilisés comme clé à l’aide d’un code d'authentification de message haché (HMAC).When implemented in a derived class, derives bytes that can be used as a key using a Hash-based Message Authentication Code (HMAC).

DeriveKeyMaterial(ECDiffieHellmanPublicKey)

Dérive des octets qui peuvent être utilisés comme clé, étant donné la clé publique d'un autre correspondant.Derives bytes that can be used as a key, given another party's public key.

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

En cas d’implémentation dans une classe dérivée, 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).When implemented in a derived class, derives bytes that can be used as a key using a Transport Layer Security (TLS) Pseudo-Random Function (PRF) derivation algorithm.

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.

(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.Releases the unmanaged resources used by the AsymmetricAlgorithm class and optionally releases the managed resources.

(Hérité de AsymmetricAlgorithm)
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.

(Hérité de Object)
ExportECPrivateKey()

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

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.

(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.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a char-based password.

(Hérité de AsymmetricAlgorithm)
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).When overridden in a derived class, exports either the public or the public and private key information using the explicit curve form from a working ECDiffieHellman key to an ECParameters structure so that it can be passed to the ImportParameters(ECParameters) method.

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).When overridden in a derived class, exports either the public or the public and private key information from a working ECDiffieHellman key to an ECParameters structure so that it can be passed to the ImportParameters(ECParameters) method.

ExportPkcs8PrivateKey()

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

(Hérité de AsymmetricAlgorithm)
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.

(Hérité de AsymmetricAlgorithm)
FromXmlString(String)

Cette méthode lève une exception dans tous les cas.This method throws in all cases.

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.When overridden in a derived class, generates a new ephemeral public/private key pair for the specified curve.

GetHashCode()

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

(Hérité de Object)
GetType()

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

(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.Imports the public/private keypair from an ECPrivateKey structure, replacing the keys for this object.

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.

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.

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.When overridden in a derived class, imports the specified parameters for an ECCurve as an ephemeral key into the current ECDiffieHellman object.

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.

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.

MemberwiseClone()

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

(Hérité de Object)
ToString()

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

(Hérité de Object)
ToXmlString(Boolean)

Cette méthode lève une exception dans tous les cas.This method throws in all cases.

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.

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.

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.

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.

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.

Implémentations d’interfaces explicites

IDisposable.Dispose()

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

(Hérité de AsymmetricAlgorithm)

S’applique à