ECDsaCng Clase

Definición

Proporciona una implementación de CNG (Cryptography Next Generation) del algoritmo ECDSA (Elliptic Curve Digital Signature Algorithm).Provides a Cryptography Next Generation (CNG) implementation of the Elliptic Curve Digital Signature Algorithm (ECDSA).

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
Herencia

Ejemplos

En el ejemplo siguiente se muestra cómo usar la clase ECDsaCng para firmar un mensaje y cómo usar la firma para comprobar que el mensaje no se ha modificado.The following example shows how to use the ECDsaCng class to sign a message and how to use the signature to verify that the message has not been altered.

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

Comentarios

Esta clase solo se debe usar directamente al realizar la interoperabilidad de plataforma con la biblioteca CNG de Windows.This class should only be used directly when doing platform interop with the Windows CNG library. Cuando no se necesita la interoperabilidad de plataforma, debe utilizar los métodos de ECDsa.Create Factory en lugar de una implementación derivada concreta.When platform interop is not needed, you should use the ECDsa.Create factory methods instead of a specific derived implementation.

Constructores

ECDsaCng()

Inicializa una nueva instancia de la clase ECDsaCng con un par de claves aleatorio.Initializes a new instance of the ECDsaCng class with a random key pair.

ECDsaCng(CngKey)

Inicializa una nueva instancia de la clase ECDsaCng mediante el objeto CngKey especificado.Initializes a new instance of the ECDsaCng class by using the specified CngKey object.

ECDsaCng(ECCurve)

Inicializa una nueva instancia de la clase ECDsaCng cuyo par de claves pública-privada se genera sobre la curva especificada.Initializes a new instance of the ECDsaCng class whose public/private key pair is generated over the specified curve.

ECDsaCng(Int32)

Inicializa una nueva instancia de la clase ECDsaCng con un tamaño de clave de destino especificado.Initializes a new instance of the ECDsaCng class with a specified target key size.

Campos

KeySizeValue

Representa el tamaño, en bits, del módulo de claves que usa el algoritmo asimétrico.Represents the size, in bits, of the key modulus used by the asymmetric algorithm.

(Heredado de AsymmetricAlgorithm)
LegalKeySizesValue

Especifica los tamaños de clave admitidos por el algoritmo asimétrico.Specifies the key sizes that are supported by the asymmetric algorithm.

(Heredado de AsymmetricAlgorithm)

Propiedades

HashAlgorithm

Obtiene o establece el algoritmo hash que se utiliza en la firma y comprobación de datosGets or sets the hash algorithm to use when signing and verifying data.

Key

Obtiene o establece la clave que se debe usar para firmar y comprobar datos.Gets or sets the key to use when signing and verifying data.

KeyExchangeAlgorithm

Obtiene el nombre del algoritmo de intercambio de claves.Gets the name of the key exchange algorithm.

(Heredado de ECDsa)
KeySize

Obtiene o establece el tamaño, en bits, del módulo de claves que usa el algoritmo asimétrico.Gets or sets the size, in bits, of the key modulus used by the asymmetric algorithm.

LegalKeySizes

Obtiene los tamaños de clave, en bits, admitidos por el establecedor de propiedad KeySize.Gets the key sizes, in bits, that are supported by the KeySize property setter.

SignatureAlgorithm

Obtiene el nombre del algoritmo de firma.Gets the name of the signature algorithm.

(Heredado de ECDsa)

Métodos

Clear()

Libera todos los recursos que utiliza la clase AsymmetricAlgorithm.Releases all resources used by the AsymmetricAlgorithm class.

(Heredado de AsymmetricAlgorithm)
Dispose()

Libera todos los recursos usados por la instancia actual de la clase AsymmetricAlgorithm.Releases all resources used by the current instance of the AsymmetricAlgorithm class.

(Heredado de AsymmetricAlgorithm)
Dispose(Boolean)

Libera los recursos no administrados utilizados por la clase AsymmetricAlgorithm y, de forma opcional, libera los recursos administrados.Releases the unmanaged resources used by the AsymmetricAlgorithm class and optionally releases the managed resources.

(Heredado de AsymmetricAlgorithm)
Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
ExportECPrivateKey()

Exporta la clave actual en el formato ECPrivateKey.Exports the current key in the ECPrivateKey format.

(Heredado de ECDsa)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

Exporta la clave actual en el formato EncryptedPrivateKeyInfo de PKCS#8 con una contraseña basada en bytes.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a byte-based password.

(Heredado de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

Exporta la clave actual en el formato EncryptedPrivateKeyInfo de PKCS#8 con una contraseña basada en caracteres.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a char-based password.

(Heredado de AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)

Exporta la clave y parámetros de curva explícitos que usa el objeto de criptografía de curva elíptica (ECC) en un objeto ECParameters.Exports the key and explicit curve parameters used by the Elliptic curve cryptography (ECC) object into an ECParameters object.

ExportParameters(Boolean)

Exporta la clave usada por el objeto de criptografía de curva elíptica (ECC) en un objeto ECParameters.Exports the key used by the Elliptic curve cryptography (ECC) object into an ECParameters object. Si la clave se creó como una curva con nombre, el campo Curve contiene parámetros de curva con nombre; en caso contrario, contiene parámetros explícitos.If the key was created as a named curve, the Curve field contains named curve parameters; otherwise, it contains explicit parameters.

ExportPkcs8PrivateKey()

Exporta la clave actual en el formato PrivateKeyInfo de PKCS#8.Exports the current key in the PKCS#8 PrivateKeyInfo format.

(Heredado de AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()

Exporta la parte de la clave pública de la clave actual en el formato SubjectPublicKeyInfo de X.509.Exports the public-key portion of the current key in the X.509 SubjectPublicKeyInfo format.

(Heredado de AsymmetricAlgorithm)
FromXmlString(String)

Este método no se implementa.This method is not implemented.

FromXmlString(String, ECKeyXmlFormat)

Deserializa la información de clave de una cadena XML mediante el formato especificado.Deserializes the key information from an XML string by using the specified format.

GenerateKey(ECCurve)

Genera un nuevo par de claves pública-privada efímeras para la curva especificada y reemplaza la clave actual.Generates a new ephemeral public/private key pair for the specified curve, replacing the current key.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
HashData(Byte[], Int32, Int32, HashAlgorithmName)

Cuando se reemplaza en una clase derivada, calcula el valor hash de la parte especificada de una matriz de bytes usando el algoritmo hash especificado.When overridden in a derived class, computes the hash value of the specified portion of a byte array by using the specified hashing algorithm.

(Heredado de ECDsa)
HashData(Stream, HashAlgorithmName)

Cuando se reemplaza en una clase derivada, calcula el valor hash de la secuencia binaria especificada usando el algoritmo hash especificado.When overridden in a derived class, computes the hash value of the specified binary stream by using the specified hashing algorithm.

(Heredado de ECDsa)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32)

Importa el par de claves pública/privada desde una estructura ECPrivateKey, reemplazando las claves de este objeto.Imports the public/private keypair from an ECPrivateKey structure, replacing the keys for this object.

(Heredado de ECDsa)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)

Importa el par de claves pública/privada desde una estructura EncryptedPrivateKeyInfo de PKCS#8 después de descifrar con una contraseña basada en bytes, reemplazando las claves de este objeto.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a byte-based password, replacing the keys for this object.

(Heredado de ECDsa)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)

Importa el par de claves pública/privada desde una estructura EncryptedPrivateKeyInfo de PKCS#8 después de descifrar con una contraseña basada en caracteres, reemplazando las claves de este objeto.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a char-based password, replacing the keys for this object.

(Heredado de ECDsa)
ImportParameters(ECParameters)

Reemplaza la clave existente con la que funciona la instancia actual mediante la creación de un nuevo CngKey para la estructura de parámetros.Replaces the existing key that the current instance is working with by creating a new CngKey for the parameters structure.

ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)

Importa el par de claves pública/privada desde una estructura PrivateKeyInfo de PKCS#8 después del descifrado, reemplazando las claves de este objeto.Imports the public/private keypair from a PKCS#8 PrivateKeyInfo structure after decryption, replacing the keys for this object.

(Heredado de ECDsa)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)

Importa la clave pública desde una estructura SubjectPublicKeyInfo de X.509 después del descifrado, reemplazando las claves de este objeto.Imports the public key from an X.509 SubjectPublicKeyInfo structure after decryption, replacing the keys for this object.

(Heredado de ECDsa)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
SignData(Byte[])

Genera una firma para los datos especificados.Generates a signature for the specified data.

SignData(Byte[], HashAlgorithmName)

Calcula el valor hash de la matriz de bytes especificada usando el algoritmo hash especificado y firma el valor hash resultante.Computes the hash value of the specified byte array using the specified hash algorithm and signs the resulting hash value.

(Heredado de ECDsa)
SignData(Byte[], Int32, Int32)

Genera una firma digital para la longitud de datos especificada, comenzando en el desplazamiento especificado.Generates a digital signature for the specified length of data, beginning at the specified offset.

SignData(Byte[], Int32, Int32, HashAlgorithmName)

Calcula el valor hash de una parte de la matriz de bytes especificada usando el algoritmo hash especificado y firma el valor hash resultante.Computes the hash value of a portion of the specified byte array using the specified hash algorithm and signs the resulting hash value.

(Heredado de ECDsa)
SignData(Stream)

Genera una firma para el flujo de datos especificado, leyendo hasta el final del flujo.Generates a signature for the specified data stream, reading to the end of the stream.

SignData(Stream, HashAlgorithmName)

Calcula el valor hash de la secuencia especificada usando el algoritmo hash especificado y firma el valor hash resultante.Computes the hash value of the specified stream using the specified hash algorithm and signs the resulting hash value.

(Heredado de ECDsa)
SignHash(Byte[])

Genera una firma del valor hash especificado.Generates a signature for the specified hash value.

ToString()

Devuelve un valor de tipo string que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)
ToXmlString(Boolean)

Este método no se implementa.This method is not implemented.

ToXmlString(ECKeyXmlFormat)

Serializa la información de clave en una cadena XML mediante el formato especificado.Serializes the key information to an XML string by using the specified format.

TryExportECPrivateKey(Span<Byte>, Int32)

Intenta exportar la clave actual en el formato ECPrivateKey a un búfer proporcionado.Attempts to export the current key in the ECPrivateKey format into a provided buffer.

(Heredado de ECDsa)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)

Intenta exportar la clave actual en el formato EncryptedPrivateKeyInfo de PKCS#8 a un búfer proporcionado, utilizando una contraseña basada en bytes.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a byte-based password.

(Heredado de ECDsa)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)

Intenta exportar la clave actual en el formato EncryptedPrivateKeyInfo de PKCS#8 a un búfer proporcionado, utilizando una contraseña basada en caracteres.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a char-based password.

(Heredado de ECDsa)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)

Intenta exportar la clave actual en el formato PrivateKeyInfo de PKCS#8 a un búfer proporcionado.Attempts to export the current key in the PKCS#8 PrivateKeyInfo format into a provided buffer.

(Heredado de ECDsa)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)

Intenta exportar la clave actual en el formato SubjectPublicKeyInfo de X.509 a un búfer proporcionado.Attempts to export the current key in the X.509 SubjectPublicKeyInfo format into a provided buffer.

(Heredado de ECDsa)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)

Intenta calcular el valor hash del intervalo de bytes de solo lectura especificado en el destino proporcionado mediante el algoritmo hash especificado.Attempts to compute the hash value of the specified read-only span of bytes into the provided destination by using the specified hashing algorithm.

(Heredado de ECDsa)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)

Intenta calcular la firma digital ECDSA del intervalo de bytes de solo lectura especificado en el destino proporcionado mediante el algoritmo hash especificado y la clave actual.Attempts to compute the ECDSA digital signature for the specified read-only span of bytes into the provided destination by using the specified hashing algorithm and the current key.

(Heredado de ECDsa)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)

Intenta calcular la firma digital ECDSA del intervalo de bytes de solo lectura especificado que representa un hash de datos en el destino proporcionado mediante la clave actual.Attempts to compute the ECDSA digital signature for the specified read-only span of bytes representing a data hash into the provided destination by using the current key.

(Heredado de ECDsa)
VerifyData(Byte[], Byte[])

Comprueba la firma digital de los datos especificados.Verifies the digital signature of the specified data.

VerifyData(Byte[], Byte[], HashAlgorithmName)

Comprueba si una firma digital es adecuada para la clave actual y proporciona datos con un algoritmo hash especificado.Verifies that a digital signature is appropriate for the current key and provided data with a specified hash algorithm.

(Heredado de ECDsa)
VerifyData(Byte[], Int32, Int32, Byte[])

Comprueba una firma para la longitud de datos especificada, comenzando en el desplazamiento especificado.Verifies a signature for the specified length of data, beginning at the specified offset.

VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName)

Comprueba que una firma digital es adecuada para la clave actual y proporciona la parte de los datos un algoritmo hash especificado.Verifies that a digital signature is appropriate for the current key and provided portion of data with a specified hash algorithm.

(Heredado de ECDsa)
VerifyData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName)

Comprueba si una firma digital es adecuada para la clave actual y proporciona datos con un algoritmo hash especificado.Verifies that a digital signature is appropriate for the current key and provided data with a specified hash algorithm.

(Heredado de ECDsa)
VerifyData(Stream, Byte[])

Comprueba la firma digital del flujo de datos especificado, leyendo hasta el final del flujo.Verifies the digital signature of the specified data stream, reading to the end of the stream.

VerifyData(Stream, Byte[], HashAlgorithmName)

Comprueba si una firma digital es adecuada para la clave actual y proporciona datos con un algoritmo hash especificado.Verifies that a digital signature is appropriate for the current key and provided data with a specified hash algorithm.

(Heredado de ECDsa)
VerifyHash(Byte[], Byte[])

Comprueba que una firma digital es adecuada para la clave actual y el hash de datos proporcionado.Verifies that a digital signature is appropriate for the current key and provided data hash.

VerifyHash(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>)

Comprueba que una firma digital es adecuada para la clave actual y el hash de datos proporcionado.Verifies that a digital signature is appropriate for the current key and provided data hash.

(Heredado de ECDsa)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Para obtener una descripción de este miembro, vea Dispose().For a description of this member, see Dispose().

(Heredado de AsymmetricAlgorithm)

Se aplica a