ECDsaCng Classe

Définition

Espace de noms:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Source:

Cng.NotSupported.cs

Fournit une implémentation CNG (Cryptography Next Generation) de l’algorithme ECDSA (Elliptic Curve Digital Signature Algorithm).

public ref class ECDsaCng sealed : System::Security::Cryptography::ECDsa

public sealed class ECDsaCng : System.Security.Cryptography.ECDsa

type ECDsaCng = class
    inherit ECDsa

Public NotInheritable Class ECDsaCng
Inherits ECDsa

Héritage

Object

AsymmetricAlgorithm

ECAlgorithm

ECDsa

ECDsaCng

Exemples

L’exemple suivant montre comment utiliser la ECDsaCng classe pour signer un message et comment utiliser la signature pour vérifier que le message n’a pas été modifié.

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

class Alice
{
    public static void Main(string[] args)
    {
        Bob bob = new Bob();
        using (ECDsaCng dsa = new ECDsaCng())
        {
            dsa.HashAlgorithm = CngAlgorithm.Sha256;
             bob.key = dsa.Key.Export(CngKeyBlobFormat.EccPublicBlob);

             byte[] data = new byte[] { 21, 5, 8, 12, 207 };

             byte[] signature = dsa.SignData(data);

             bob.Receive(data, signature);
            }
    }
}
public class Bob
{
    public byte[] key;

    public void Receive(byte[] data, byte[] signature)
    {
        using (ECDsaCng ecsdKey = new ECDsaCng(CngKey.Import(key, CngKeyBlobFormat.EccPublicBlob)))
        {
            if (ecsdKey.VerifyData(data, signature))
                Console.WriteLine("Data is good");
            else
                Console.WriteLine("Data is bad");
        }
    }
}

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

Class Alice

    Public Shared Sub Main(ByVal args() As String)
        Dim bob As New Bob()
        If (True) Then
            Using dsa As New ECDsaCng()
                    dsa.HashAlgorithm = CngAlgorithm.Sha256
                    bob.key = dsa.Key.Export(CngKeyBlobFormat.EccPublicBlob)
                    Dim data() As Byte = {21, 5, 8, 12, 207}
                    Dim signature As Byte() = dsa.SignData(data)
                    bob.Receive(data, signature)
            End Using
        End If

    End Sub
End Class


Public Class Bob
    Public key() As Byte

    Public Sub Receive(ByVal data() As Byte, ByVal signature() As Byte)
        Using ecsdKey As New ECDsaCng(CngKey.Import(key, CngKeyBlobFormat.EccPublicBlob))
                If ecsdKey.VerifyData(data, signature) Then
                    Console.WriteLine("Data is good")
                Else
                    Console.WriteLine("Data is bad")
                End If
        End Using

    End Sub
End Class

Remarques

Cette classe doit uniquement être utilisée directement lors de l’interopérabilité de plateforme avec la bibliothèque CNG Windows. Lorsque l’interopérabilité de plateforme n’est pas nécessaire, vous devez utiliser les ECDsa.Create méthodes de fabrique au lieu d’une implémentation dérivée spécifique.

Constructeurs

ECDsaCng()	Initialise une nouvelle instance de la classe ECDsaCng avec une paire de clés aléatoire.
ECDsaCng(CngKey)	Initialise une nouvelle instance de la classe ECDsaCng à l'aide de l'objet CngKey spécifié.
ECDsaCng(ECCurve)	Initialise une nouvelle instance de la classe ECDsaCng dont la paire de clés publique/privée est générée sur la courbe spécifiée.
ECDsaCng(Int32)	Initialise une nouvelle instance de la classe ECDsaCng avec une taille de clé cible 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 pour la signature et la vérification des données.
Key	Obtient ou définit la clé à utiliser lors de la signature et de la vérification des données.
KeyExchangeAlgorithm	Obtient le nom de l'algorithme d'échange de clés. (Hérité de ECDsa)
KeySize	Obtient ou définit la taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.
LegalKeySizes	Obtient les tailles de clé, en bits, prises en charge par la méthode setter de propriété KeySize.
SignatureAlgorithm	Obtient le nom de l'algorithme de signature. (Hérité de ECDsa)

Méthodes

Clear()	Libère toutes les ressources utilisées par la classe AsymmetricAlgorithm. (Hérité de AsymmetricAlgorithm)
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 ECDsa)
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<Char>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char.
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur des octets, encodé 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, pem encodé. (Hérité de AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)	Exporte les paramètres de clé et de courbe explicite utilisés par l’objet ECC dans un objet ECParameters.
ExportParameters(Boolean)	Exporte la clé utilisée par l’objet ECC dans un objet ECParameters. Si la clé a été créée en tant que courbe nommée, le champ Curve contient les paramètres de la courbe nommée, sinon il contient des paramètres explicites.
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é 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 de clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo, encodé PEM. (Hérité de AsymmetricAlgorithm)
FromXmlString(String)	Cette méthode lève une exception dans tous les cas. (Hérité de ECDsa)
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, remplaçant la clé actuelle.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetMaxSignatureSize(DSASignatureFormat)	Obtient la plus grande taille, en octets, pour une signature produite par cette clé dans le format indiqué. (Hérité de ECDsa)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
HashData(Byte[], Int32, Int32, HashAlgorithmName)	En cas de substitution dans une classe dérivée, calcule la valeur de hachage de la partie indiquée d'un tableau d'octets à l'aide de l'algorithme de hachage spécifié. (Hérité de ECDsa)
HashData(Stream, HashAlgorithmName)	En cas de substitution dans une classe dérivée, calcule la valeur de hachage du flux binaire indiqué à l'aide de l'algorithme de hachage spécifié. (Hérité de ECDsa)
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 ECDsa)
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<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.
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 ECDsa)
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 ECDsa)
ImportFromPem(ReadOnlySpan<Char>)	Importe une clé encodée PEM RFC 7468, en remplaçant les clés de cet objet. (Hérité de ECDsa)
ImportParameters(ECParameters)	Remplace la clé existante utilisée par l'instance actuelle en créant un CngKey pour la structure des paramètres.
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.
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 ECDsa)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
SignData(Byte[])	Génère une signature pour les données spécifiées.
SignData(Byte[], HashAlgorithmName)	Calcule la valeur de hachage du tableau d'octets indiqué à l'aide de l'algorithme de hachage spécifié et signe la valeur de hachage obtenue. (Hérité de ECDsa)
SignData(Byte[], HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et la signe à l’aide du format de signature spécifié. (Hérité de ECDsa)
SignData(Byte[], Int32, Int32)	Génère une signature numérique pour la longueur spécifiée de données, en commençant à l'offset spécifié.
SignData(Byte[], Int32, Int32, HashAlgorithmName)	Calcule la valeur de hachage d'une partie du tableau d'octets indiqué à l'aide de l'algorithme de hachage spécifié et signe la valeur de hachage obtenue. (Hérité de ECDsa)
SignData(Byte[], Int32, Int32, HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et la signe à l’aide du format de signature spécifié. (Hérité de ECDsa)
SignData(ReadOnlySpan<Byte>, HashAlgorithmName)	Calcule la valeur de hachage des données spécifiées et la signe. (Hérité de ECDsa)
SignData(ReadOnlySpan<Byte>, HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et la signe à l’aide du format de signature spécifié. (Hérité de ECDsa)
SignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName)	Calcule la valeur de hachage des données spécifiées et les signe au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
SignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et les signe au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
SignData(Stream)	Génère une signature pour le flux de données spécifié, en lisant jusqu'à la fin le flux de données.
SignData(Stream, HashAlgorithmName)	Calcule la valeur de hachage du flux indiqué à l'aide de l'algorithme de hachage spécifié et signe la valeur de hachage obtenue. (Hérité de ECDsa)
SignData(Stream, HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et la signe à l’aide du format de signature spécifié. (Hérité de ECDsa)
SignDataCore(ReadOnlySpan<Byte>, HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et la signe à l’aide du format de signature spécifié. (Hérité de ECDsa)
SignDataCore(Stream, HashAlgorithmName, DSASignatureFormat)	Calcule la valeur de hachage des données spécifiées et la signe à l’aide du format de signature spécifié. (Hérité de ECDsa)
SignHash(Byte[])	Génère une signature pour la valeur de hachage spécifiée.
SignHash(Byte[], DSASignatureFormat)	Calcule la signature ECDSA pour la valeur de hachage spécifiée au format indiqué. (Hérité de ECDsa)
SignHash(ReadOnlySpan<Byte>)	Calcule la signature ECDSA pour la valeur de hachage spécifiée. (Hérité de ECDsa)
SignHash(ReadOnlySpan<Byte>, DSASignatureFormat)	Calcule la signature ECDSA pour la valeur de hachage spécifiée au format indiqué. (Hérité de ECDsa)
SignHash(ReadOnlySpan<Byte>, Span<Byte>)	Calcule la signature ECDSA pour la valeur de hachage spécifiée dans la mémoire tampon fournie. (Hérité de ECDsa)
SignHash(ReadOnlySpan<Byte>, Span<Byte>, DSASignatureFormat)	Calcule la signature ECDSA pour la valeur de hachage spécifiée au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
SignHashCore(ReadOnlySpan<Byte>, DSASignatureFormat)	Calcule la signature ECDSA pour la valeur de hachage spécifiée au format indiqué. (Hérité de ECDsa)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
ToXmlString(Boolean)	Cette méthode lève une exception dans tous les cas. (Hérité de ECDsa)
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 au format ECPrivateKey dans une mémoire tampon fournie. (Hérité de ECDsa)
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<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.
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 un octet, 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, pem encodé. (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.
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Tente d’exporter la clé actuelle au format PrivateKeyInfo PKCS#8 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 ECDsa)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	Tente d’exporter la clé actuelle dans le format X.509 SubjectPublicKeyInfo encodé en PEM dans une mémoire tampon fournie. (Hérité de AsymmetricAlgorithm)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)	Tente de calculer la valeur de hachage de la plage d’octets en lecture seule spécifiée dans la destination fournie en utilisant l’algorithme de hachage spécifié. (Hérité de ECDsa)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, DSASignatureFormat, Int32)	Tente de créer la signature ECDSA pour les données spécifiées au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)	Tente de calculer la signature numérique ECDSA de la plage d'octets en lecture seule spécifiée dans la destination fournie en utilisant l'algorithme de hachage spécifié et la clé actuelle. (Hérité de ECDsa)
TrySignDataCore(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, DSASignatureFormat, Int32)	Tente de créer la signature ECDSA pour les données spécifiées au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, DSASignatureFormat, Int32)	Tente de créer la signature ECDSA pour la valeur de hachage spécifiée au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)	Tente de calculer la signature numérique ECDSA de la plage d’octets en lecture seule spécifiée représentant un hachage de données dans la destination fournie en utilisant la clé actuelle.
TrySignHashCore(ReadOnlySpan<Byte>, Span<Byte>, DSASignatureFormat, Int32)	Tente de créer la signature ECDSA pour la valeur de hachage spécifiée au format indiqué dans la mémoire tampon fournie. (Hérité de ECDsa)
VerifyData(Byte[], Byte[])	Vérifie la signature numérique des données spécifiées.
VerifyData(Byte[], Byte[], HashAlgorithmName)	Vérifie qu'une signature numérique est adaptée à la clé actuelle et aux données fournies à l’aide d’un algorithme de hachage spécifié. (Hérité de ECDsa)
VerifyData(Byte[], Byte[], HashAlgorithmName, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour les données fournies. (Hérité de ECDsa)
VerifyData(Byte[], Int32, Int32, Byte[])	Vérifie une signature pour la longueur spécifiée de données, en commençant à l'offset spécifié.
VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName)	Vérifie qu’une signature numérique est adaptée à la clé actuelle et la partie de données fournie à l’aide d’un algorithme de hachage spécifié. (Hérité de ECDsa)
VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour les données fournies. (Hérité de ECDsa)
VerifyData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName)	Vérifie qu'une signature numérique est adaptée à la clé actuelle et aux données fournies à l’aide d’un algorithme de hachage spécifié. (Hérité de ECDsa)
VerifyData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour les données fournies. (Hérité de ECDsa)
VerifyData(Stream, Byte[])	Vérifie la signature numérique du flux de données spécifié, en lisant jusqu'à la fin le flux de données.
VerifyData(Stream, Byte[], HashAlgorithmName)	Vérifie qu'une signature numérique est adaptée à la clé actuelle et aux données fournies à l’aide d’un algorithme de hachage spécifié. (Hérité de ECDsa)
VerifyData(Stream, Byte[], HashAlgorithmName, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour les données fournies. (Hérité de ECDsa)
VerifyDataCore(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour les données fournies. (Hérité de ECDsa)
VerifyDataCore(Stream, ReadOnlySpan<Byte>, HashAlgorithmName, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour les données fournies. (Hérité de ECDsa)
VerifyHash(Byte[], Byte[])	Vérifie qu’une signature numérique est adaptée à la clé actuelle et au hachage de données fourni.
VerifyHash(Byte[], Byte[], DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour le hachage fourni. (Hérité de ECDsa)
VerifyHash(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>)	Vérifie qu’une signature numérique est adaptée à la clé actuelle et au hachage de données fourni.
VerifyHash(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour le hachage fourni. (Hérité de ECDsa)
VerifyHashCore(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, DSASignatureFormat)	Vérifie qu’une signature numérique est valide pour le hachage fourni. (Hérité de ECDsa)