ECDiffieHellmanCng Classe

Definizione

Spazio dei nomi:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Source:

Cng.NotSupported.cs

Fornisce un'implementazione CNG (Cryptography Next Generation) dell'algoritmo ECDH (Diffie-Hellman a curva ellittica). Questa classe viene utilizzata per eseguire operazioni di crittografia.

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

Ereditarietà

Object

AsymmetricAlgorithm

ECAlgorithm

ECDiffieHellman

ECDiffieHellmanCng

Esempio

Nell'esempio seguente viene illustrato come usare la ECDiffieHellmanCng classe per stabilire uno scambio di chiavi e come usare tale chiave per crittografare un messaggio che può essere inviato tramite un canale pubblico e decrittografato dal ricevitore.

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

Commenti

La ECDiffieHellmanCng classe consente a due parti di scambiare materiale della chiave privata anche se comunicano tramite un canale pubblico. Entrambe le parti possono calcolare lo stesso valore del segreto, definito contratto segreto nelle classi di Diffie-Hellman gestite. Il contratto segreto può quindi essere usato per diversi scopi, tra cui come chiave simmetrica. Tuttavia, invece di esporre direttamente il contratto segreto, la ECDiffieHellmanCng classe esegue alcune operazioni di post-elaborazione sul contratto prima di fornire il valore. Questa post-elaborazione viene definita funzione di derivazione chiave (KDF) ; è possibile selezionare la KDF da usare e impostarne i parametri tramite un set di proprietà nell'istanza dell'oggetto Diffie-Hellman.

Funzione di derivazione chiave	Proprietà
Hash	HashAlgorithm - Algoritmo hash usato per elaborare il contratto segreto. SecretPrepend - Matrice di byte facoltativa da anteporre al contratto segreto prima di eseguire l'hashing. SecretAppend - Matrice di byte facoltativa da aggiungere al contratto segreto prima di eseguire l'hashing.
Hmac	HashAlgorithm - Algoritmo hash usato per elaborare il contratto segreto. SecretPrepend- Matrice di byte facoltativa da anteporre al contratto segreto prima di eseguire l'hashing. SecretAppend - Matrice di byte facoltativa da aggiungere al contratto segreto prima di eseguire l'hashing.
Tls	Label - Etichetta per la derivazione della chiave. Seed - Valore di inizializzazione per la derivazione della chiave.

Il risultato del passaggio del contratto segreto tramite la funzione di derivazione della chiave è una matrice di byte che può essere usata come materiale chiave per l'applicazione. Il numero di byte del materiale della chiave generato dipende dalla funzione di derivazione della chiave; Ad esempio, SHA-256 genererà 256 bit di materiale della chiave, mentre SHA-512 genererà 512 bit di materiale della chiave. Il flusso di base di uno scambio di chiavi ECDH è il seguente:

1. Alice e Bob creano una coppia di chiavi da usare per l'operazione di scambio di chiavi Diffie-Hellman

2. Alice e Bob configurano la KDF usando i parametri a cui sono d'accordo.

3. Alice invia a Bob la chiave pubblica.

4. Bob invia ad Alice la sua chiave pubblica.

5. Alice e Bob usano le chiavi pubbliche degli altri per generare il contratto segreto e applicare il KDF al contratto segreto per generare il materiale della chiave.

Costruttori

ECDiffieHellmanCng()	Inizializza una nuova istanza della classe ECDiffieHellmanCng con una coppia di chiavi casuale.
ECDiffieHellmanCng(CngKey)	Inizializza una nuova istanza della classe ECDiffieHellmanCng usando l'oggetto CngKey specificato.
ECDiffieHellmanCng(ECCurve)	Crea una nuova istanza della classe ECDiffieHellmanCng la cui coppia di chiavi pubblica/privata viene generata per la curva specificata.
ECDiffieHellmanCng(Int32)	Inizializza una nuova istanza della classe ECDiffieHellmanCng con una coppia di chiavi generata in modo casuale, usando le dimensioni specificate per la chiave.

Campi

KeySizeValue	Rappresenta la dimensione in bit del modulo della chiave usato dall'algoritmo asimmetrico. (Ereditato da AsymmetricAlgorithm)
LegalKeySizesValue	Specifica le dimensioni delle chiavi supportate dall'algoritmo asimmetrico. (Ereditato da AsymmetricAlgorithm)

Proprietà

HashAlgorithm	Ottiene o imposta l'algoritmo hash da utilizzare durante la generazione del materiale della chiave.
HmacKey	Ottiene o imposta la chiave HMAC (Hash-based Message Authentication Code) da utilizzare per la derivazione del materiale della chiave.
Key	Specifica l'oggetto CngKey utilizzato dall'oggetto corrente per le operazioni di crittografia.
KeyDerivationFunction	Ottiene o imposta la funzione di derivazione di chiave per la classe ECDiffieHellmanCng.
KeyExchangeAlgorithm	Ottiene il nome dell'algoritmo di scambio delle chiavi. (Ereditato da ECDiffieHellman)
KeySize	Ottiene o imposta la dimensione in bit del modulo della chiave usato dall'algoritmo asimmetrico.
Label	Ottiene o imposta il valore dell'etichetta utilizzato per la derivazione della chiave.
LegalKeySizes	Ottiene le dimensioni delle chiavi supportate dall'algoritmo asimmetrico.
PublicKey	Ottiene la chiave pubblica che può essere utilizzata da un altro oggetto ECDiffieHellmanCng per generare una chiave privata condivisa.
SecretAppend	Ottiene o imposta un valore che verrà aggiunto alla chiave privata durante la generazione del materiale della chiave.
SecretPrepend	Ottiene o imposta un valore che verrà aggiunto all'inizio della chiave privata durante la derivazione del materiale della chiave.
Seed	Ottiene o imposta il valore di inizializzazione che verrà utilizzato durante la derivazione del materiale della chiave.
SignatureAlgorithm	Ottiene il nome dell'algoritmo di firma. (Ereditato da ECDiffieHellman)
UseSecretAgreementAsHmacKey	Ottiene un valore che indica se la chiave privata viene utilizzata o meno come chiave HMAC (Hash-based Message Authentication Code) per derivare il materiale della chiave.

Metodi

Clear()	Rilascia tutte le risorse usate dalla classe AsymmetricAlgorithm. (Ereditato da AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)	Esegue la derivazione della chiave usando un algoritmo hash specificato. (Ereditato da ECDiffieHellman)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])	Esegue la derivazione della chiave usando un algoritmo hash specificato con dati facoltativi anteposti o accodati.
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])	Esegue la derivazione della chiave usando un algoritmo HMAC (Hash-based Message Authentication Code) specificato. (Ereditato da ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])	Esegue la derivazione della chiave usando un algoritmo HMAC (Hash-based Message Authentication Code) specificato con dati facoltativi anteposti o accodati.
DeriveKeyMaterial(CngKey)	Deriva il materiale della chiave generato dalla chiave privata tra due parti, dato un oggetto CngKey contenente la chiave pubblica della seconda parte.
DeriveKeyMaterial(ECDiffieHellmanPublicKey)	Deriva il materiale della chiave generato dalla chiave privata tra due parti, dato un oggetto ECDiffieHellmanPublicKey contenente la chiave pubblica della seconda parte.
DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])	Esegue la derivazione della chiave usando la PRF (Pseudo-Random Function) TLS (Transport Layer Security) 1.1.
DeriveRawSecretAgreement(ECDiffieHellmanPublicKey)	Derivare materiale chiave non elaborato. (Ereditato da ECDiffieHellman)
DeriveSecretAgreementHandle(CngKey)	Ottiene un handle per la chiave privata generata tra due parti, dato un oggetto CngKey contenente la chiave pubblica della seconda parte.
DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey)	Ottiene un handle per la chiave privata generata tra due parti, dato un oggetto ECDiffieHellmanPublicKey contenente la chiave pubblica della seconda parte.
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della classe AsymmetricAlgorithm. (Ereditato da AsymmetricAlgorithm)
Dispose(Boolean)	Rilascia le risorse non gestite usate dalla classe AsymmetricAlgorithm e facoltativamente le risorse gestite. (Ereditato da AsymmetricAlgorithm)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
ExportECPrivateKey()	Esporta la chiave corrente nel formato ECPrivateKey. (Ereditato da ECDiffieHellman)
ExportECPrivateKeyPem()	Esporta la chiave corrente nel formato ECPrivateKey, con codifica PEM. (Ereditato da ECAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su byte.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su caratteri.
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su byte, con codifica PEM. (Ereditato da AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su caratteri, con codifica PEM. (Ereditato da AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)	Esporta la chiave e i parametri della curva esplicita usati dall'oggetto ECCurve in un oggetto ECParameters.
ExportParameters(Boolean)	Esporta la chiave usata dall'oggetto ECCurve in un oggetto ECParameters.
ExportPkcs8PrivateKey()	Esporta la chiave corrente nel formato PKCS#8 PrivateKeyInfo. (Ereditato da AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Esporta la chiave corrente nel formato PKCS#8 PrivateKeyInfo, con codifica PEM. (Ereditato da AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()	Esporta la parte della chiave pubblica della chiave corrente nel formato X.509 SubjectPublicKeyInfo. (Ereditato da AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Esporta la parte pubblica della chiave pubblica della chiave corrente nel formato X.509 SubjectPublicKeyInfo, codificato con PEM. (Ereditato da AsymmetricAlgorithm)
FromXmlString(String)	Questo metodo genera in tutti i casi. (Ereditato da ECDiffieHellman)
FromXmlString(String, ECKeyXmlFormat)	Obsoleti. Deserializza le informazioni sulla chiave da una stringa XML utilizzando il formato specificato.
GenerateKey(ECCurve)	Genera una nuova coppia di chiavi pubblica/privata temporanea per la curva specificata.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32)	Importa la coppia di chiavi pubblica/privata da una struttura ECPrivateKey, sostituendo le chiavi per questo oggetto. (Ereditato da ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importa la coppia di chiavi pubblica/privata da una struttura PKCS#8 EncryptedPrivateKeyInfo dopo la decrittografia con una password basata su byte, sostituendo le chiavi per questo oggetto.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importa la coppia di chiavi pubblica/privata da una struttura PKCS#8 EncryptedPrivateKeyInfo dopo la decrittografia con una password basata su caratteri, sostituendo le chiavi per questo oggetto.
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)	Importa una chiave privata con codifica PEM crittografata RFC 7468, sostituendo le chiavi per questo oggetto. (Ereditato da ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Importa una chiave privata con codifica PEM crittografata RFC 7468, sostituendo le chiavi per questo oggetto. (Ereditato da ECDiffieHellman)
ImportFromPem(ReadOnlySpan<Char>)	Importa una chiave con codifica PEM RFC 7468, sostituendo le chiavi per questo oggetto. (Ereditato da ECDiffieHellman)
ImportParameters(ECParameters)	Importa i parametri specificati per un oggetto ECCurve come chiave nell'istanza corrente.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	Importa la coppia di chiavi pubblica/privata da una struttura PKCS#8 PrivateKeyInfo dopo la decrittografia, sostituendo le chiavi per questo oggetto.
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)	Importa la chiave pubblica da una struttura X.509 SubjectPublicKeyInfo dopo la decrittografia, sostituendo le chiavi per questo oggetto. (Ereditato da ECDiffieHellman)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
ToXmlString(Boolean)	Questo metodo genera in tutti i casi. (Ereditato da ECDiffieHellman)
ToXmlString(ECKeyXmlFormat)	Obsoleti. Serializza le informazioni sulla chiave in una stringa XML utilizzando il formato specificato.
TryExportECPrivateKey(Span<Byte>, Int32)	Prova a esportare la chiave corrente nel formato ECPrivateKey in un buffer specificato. (Ereditato da ECDiffieHellman)
TryExportECPrivateKeyPem(Span<Char>, Int32)	Tenta di esportare la chiave corrente nel formato ECPrivateKey con codifica PEM in un buffer fornito. (Ereditato da ECAlgorithm)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Tenta di esportare la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo in un buffer specificato, usando una password basata su byte.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Tenta di esportare la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo in un buffer specificato, usando una password basata su caratteri.
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Tenta di esportare la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su byte, con codifica PEM. (Ereditato da AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su caratteri, con codifica PEM. (Ereditato da AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Tenta di esportare la chiave corrente nel formato PKCS#8 PrivateKeyInfo in un buffer specificato.
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Tenta di esportare la chiave corrente nel formato PKCS#8 PrivateKeyInfo con codifica PEM in un buffer fornito. (Ereditato da AsymmetricAlgorithm)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)	Tenta di esportare la chiave corrente nel formato X.509 SubjectPublicKeyInfo in un buffer specificato. (Ereditato da ECDiffieHellman)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	Tenta di esportare la chiave corrente nel formato X.509 SoggettoPublicKeyInfo con codifica PEM in un buffer fornito. (Ereditato da AsymmetricAlgorithm)