ECDiffieHellmanCng Osztály

Definíció

Névtér:

System.Security.Cryptography

Szerelvény:

System.Security.Cryptography.dll

Forrás:

Cng.NotSupported.cs

Az Elliptikus Görbe Diffie-Hellman (ECDH) algoritmus következő generációs (CNG) titkosítási implementációját biztosítja. Ez az osztály titkosítási műveletek végrehajtására szolgál.

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

Öröklődés

Object

AsymmetricAlgorithm

ECAlgorithm

ECDiffieHellman

ECDiffieHellmanCng

Példák

Az alábbi példa bemutatja, hogyan hozhat létre kulcscserét az ECDiffieHellmanCng osztály használatával, és hogyan titkosíthat egy nyilvános csatornán keresztül küldhető és a fogadó által visszafejthető üzeneteket.

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

Megjegyzések

Az ECDiffieHellmanCng osztály lehetővé teszi két fél számára, hogy titkos kulcsú anyagokat cseréljenek akkor is, ha nyilvános csatornán keresztül kommunikálnak. Mindkét fél kiszámíthatja ugyanazt a titkos értéket, amelyet titkos megállapodásnak neveznek a felügyelt Diffie-Hellman osztályokban. A titkos megállapodás ezután számos célra használható, például szimmetrikus kulcsként. A titkos szerződés közvetlen közzététele helyett azonban az ECDiffieHellmanCng osztály utófeldolgozást végez a megállapodáson az érték megadása előtt. Ezt az utófeldolgozást kulcs származtatási függvénynek (KDF) nevezzük; Kiválaszthatja, hogy melyik KDF-t szeretné használni, és a paramétereket az Diffie-Hellman objektum példányán található tulajdonságok halmazán keresztül állíthatja be.

Kulcs származtatási függvénye	Tulajdonságok
Hash	HashAlgorithm - A titkos megállapodás feldolgozásához használt kivonatoló algoritmus. SecretPrepend – Nem kötelező bájttömb, amelyet a titkos szerződéshez kell elővenni a kivonatolás előtt. SecretAppend – Nem kötelező bájttömb, amelyet a kivonatolás előtt hozzáfűzhet a titkos szerződéshez.
Hmac	HashAlgorithm - A titkos megállapodás feldolgozásához használt kivonatoló algoritmus. SecretPrepend– Nem kötelező bájttömb, amelyet a titkos szerződéshez kell elővenni a kivonatolás előtt. SecretAppend – Nem kötelező bájttömb, amelyet a kivonatolás előtt hozzáfűzhet a titkos szerződéshez.
Tls	Label - A kulcs származtatásának címkéje. Seed - A kulcs származtatásának magja.

A titkos szerződés kulcs származtatási függvényen keresztüli átadásának eredménye egy bájttömb, amely az alkalmazás kulcsanyagaként használható. A létrehozott kulcsanyag bájtjainak száma a kulcs származtatási függvényétől függ; Az SHA-256 például 256 bit kulcsanyagot hoz létre, míg az SHA-512 512 bit kulcsanyagot fog létrehozni. Az ECDH-kulcscsere alapfolyamata a következő:

1. Alice és Bob létrehoz egy kulcspárt a Diffie-Hellman kulcscsere művelethez

2. Alice és Bob konfigurálja a KDF-t az egyeztetett paraméterekkel.

3. Alice elküldi Bobnak a nyilvános kulcsát.

4. Bob elküldi Alice-nek a nyilvános kulcsát.

5. Alice és Bob egymás nyilvános kulcsait használják a titkos megállapodás létrehozásához, és a KDF-t alkalmazzák a titkos megállapodásra a kulcsanyagok létrehozásához.

Konstruktorok

Name	Description
ECDiffieHellmanCng()	Inicializálja az ECDiffieHellmanCng osztály új példányát egy véletlenszerű kulcspárral.
ECDiffieHellmanCng(CngKey)	Inicializálja az ECDiffieHellmanCng osztály új példányát a megadott CngKey objektum használatával.
ECDiffieHellmanCng(ECCurve)	Létrehoz egy új példányt annak az osztálynak, ECDiffieHellmanCng amelynek nyilvános/privát kulcspárja a megadott görbén jön létre.
ECDiffieHellmanCng(Int32)	Inicializálja az ECDiffieHellmanCng osztály új példányát egy véletlenszerű kulcspárral a megadott kulcsméret használatával.

Mezők

Name	Description
KeySizeValue	Az aszimmetrikus algoritmus által használt kulcsmodulusok méretét jelöli bitekben. (Öröklődés forrása AsymmetricAlgorithm)
LegalKeySizesValue	Megadja az aszimmetrikus algoritmus által támogatott kulcsméreteket. (Öröklődés forrása AsymmetricAlgorithm)

Tulajdonságok

Name	Description
HashAlgorithm	Lekéri vagy beállítja a kulcsanyag létrehozásakor használni kívánt kivonatoló algoritmust.
HmacKey	Lekéri vagy beállítja a kivonatalapú üzenethitelesítési kód (HMAC) kulcsát, amelyet a kulcsanyag származtatásakor használjon.
Key	CngKey Az aktuális objektum által a titkosítási műveletekhez használt objektumot adja meg.
KeyDerivationFunction	Lekéri vagy beállítja az osztály kulcs származtatási függvényét ECDiffieHellmanCng .
KeyExchangeAlgorithm	Lekéri a kulcscsere-algoritmus nevét. (Öröklődés forrása ECDiffieHellman)
KeySize	Bitekben lekéri vagy beállítja az aszimmetrikus algoritmus által használt kulcsmodulus méretét.
Label	Lekéri vagy beállítja a kulcs származtatásához használt címkeértéket.
LegalKeySizes	Lekéri az aszimmetrikus algoritmus által támogatott kulcsméreteket.
PublicKey	Lekéri azt a nyilvános kulcsot, amelyet egy másik ECDiffieHellmanCng objektum használhat megosztott titkos kulcs-szerződés létrehozásához.
SecretAppend	Lekéri vagy beállít egy értéket, amelyet hozzáfűz a titkos szerződéshez a kulcsanyag létrehozásakor.
SecretPrepend	Lekéri vagy beállít egy értéket, amelyet a titkos megállapodás elején ad hozzá a kulcsanyag származtatásakor.
Seed	Lekéri vagy beállítja a kulcsanyag származtatásakor használni kívánt magértéket.
SignatureAlgorithm	Lekéri az aláírási algoritmus nevét. (Öröklődés forrása ECDiffieHellman)
UseSecretAgreementAsHmacKey	Lekéri azt az értéket, amely jelzi, hogy a titkos szerződés kivonatalapú üzenethitelesítési kódként (HMAC) van-e használva a kulcsanyag kinyeréséhez.

Metódusok

Name	Description
Clear()	Az osztály által AsymmetricAlgorithm használt összes erőforrást felszabadítja. (Öröklődés forrása AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])	A kulcs származtatását egy megadott kivonatoló algoritmussal hajtja végre, opcionálisan előre felfűzött vagy hozzáfűzött adatokkal.
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)	A kulcs származtatását egy megadott kivonatoló algoritmussal hajtja végre. (Öröklődés forrása ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])	A kulcs származtatását egy megadott HMAC (kivonatalapú üzenethitelesítési kód) algoritmussal hajtja végre, opcionálisan előre felfűzött vagy hozzáfűzött adatokkal.
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])	A kulcs származtatását egy megadott HMAC (kivonatalapú üzenethitelesítési kód) algoritmussal hajtja végre. (Öröklődés forrása ECDiffieHellman)
DeriveKeyMaterial(CngKey)	A két fél közötti titkos megállapodásból generált kulcsanyagot egy olyan objektum alapján CngKey hozza létre, amely a második fél nyilvános kulcsát tartalmazza.
DeriveKeyMaterial(ECDiffieHellmanPublicKey)	A két fél közötti titkos megállapodásból generált kulcsanyagot egy olyan objektum alapján ECDiffieHellmanPublicKey hozza létre, amely a második fél nyilvános kulcsát tartalmazza.
DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])	A kulcslevezetést a TLS (Transport Layer Security) 1.1 PRF (Pseudo-Random függvény) használatával hajtja végre.
DeriveRawSecretAgreement(ECDiffieHellmanPublicKey)	Nyerskulcs-anyag kinyerése. (Öröklődés forrása ECDiffieHellman)
DeriveSecretAgreementHandle(CngKey)	Lekéri a két fél között létrejött titkos megállapodás leíróját egy olyan objektummal CngKey , amely a második fél nyilvános kulcsát tartalmazza.
DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey)	Lekéri a két fél között létrejött titkos szerződést egy olyan objektummal ECDiffieHellmanPublicKey , amely tartalmazza a második fél nyilvános kulcsát.
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja AsymmetricAlgorithm . (Öröklődés forrása AsymmetricAlgorithm)
Dispose(Boolean)	Felszabadítja az osztály által AsymmetricAlgorithm használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása AsymmetricAlgorithm)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
ExportECPrivateKeyPem()	Exportálja az aktuális kulcsot ECPrivateKey formátumban, PEM kódolású formátumban. (Öröklődés forrása ECAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja bájtalapú jelszóval.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja karakteralapú jelszóval.
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	A PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja az aktuális kulcsot egy bájtalapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	A PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja az aktuális kulcsot egy karakteralapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)	Exportálja az objektum által ECCurve használt kulcs- és explicit görbeparamétereket egy ECParameters objektumba.
ExportParameters(Boolean)	Exportálja az objektum által ECCurve használt kulcsot egy ECParameters objektumba.
ExportPkcs8PrivateKey()	Exportálja az aktuális kulcsot a PKCS#8 PrivateKeyInfo formátumban. (Öröklődés forrása AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Exportálja az aktuális kulcsot PKCS#8 PrivateKeyInfo formátumban, PEM kódolású formátumban. (Öröklődés forrása AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()	Az aktuális kulcs nyilvános kulcs részét exportálja X.509 SubjectPublicKeyInfo formátumban. (Öröklődés forrása AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Exportálja az aktuális kulcs nyilvános kulcs részét X.509 SubjectPublicKeyInfo formátumban, PEM kódolású formátumban. (Öröklődés forrása AsymmetricAlgorithm)
FromXmlString(String, ECKeyXmlFormat)	Elavult. Deszerializálja a kulcsadatokat egy XML-sztringből a megadott formátum használatával.
FromXmlString(String)	Ez a módszer minden esetben eldobja. (Öröklődés forrása ECDiffieHellman)
GenerateKey(ECCurve)	Létrehoz egy új rövid élettartamú nyilvános/privát kulcspárt a megadott görbéhez.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importálja a nyilvános/privát kulcspairt egy PKCS#8 EncryptedPrivateKeyInfo szerkezetből, miután a visszafejtést egy bájtalapú jelszóval végzett visszafejtés után az objektum kulcsainak lecserélésével végzi.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importálja a nyilvános/privát kulcspairt egy PKCS#8 EncryptedPrivateKeyInfo struktúrából, miután a visszafejtés egy karakteralapú jelszóval megtörtént, és lecserélte az objektum kulcsait.
ImportParameters(ECParameters)	Importálja egy objektum megadott paramétereit ECCurve kulcsként az aktuális példányba.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	A visszafejtés után importálja a nyilvános/privát kulcstárat egy PKCS#8 PrivateKeyInfo struktúrából, és lecseréli az objektum kulcsait.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
ToXmlString(Boolean)	Ez a módszer minden esetben eldobja. (Öröklődés forrása ECDiffieHellman)
ToXmlString(ECKeyXmlFormat)	Elavult. A megadott formátummal szerializálja a kulcsadatokat egy XML-sztringre.
TryExportECPrivateKeyPem(Span<Char>, Int32)	Megkísérli exportálni az aktuális kulcsot a PEM kódolású ECPrivateKey formátumban egy megadott pufferbe. (Öröklődés forrása ECAlgorithm)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Megkísérli exportálni a PKCS#8 EncryptedPrivateKeyInfo formátumú aktuális kulcsot egy megadott pufferbe egy bájtalapú jelszó használatával.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban egy megadott pufferbe egy karakteralapú jelszó használatával.
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban egy bájtalapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	A PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja az aktuális kulcsot egy karakteralapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#8 PrivateKeyInfo formátumban egy megadott pufferbe.
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Megkísérli exportálni az aktuális kulcsot a PEM kódolású PKCS#8 PrivateKeyInfo formátumban egy megadott pufferbe. (Öröklődés forrása AsymmetricAlgorithm)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	A PEM kódolású X.509 SubjectPublicKeyInfo formátumban lévő aktuális kulcsot egy megadott pufferbe próbálja exportálni. (Öröklődés forrása AsymmetricAlgorithm)