ECDiffieHellmanCng Klasse

Definition

Namespace:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Quelle:

Cng.NotSupported.cs

Stellt eine CNG (Cryptography Next Generation)-Implementierung des ECDH (Elliptic Curve Diffie-Hellman)-Algorithmus bereit. Diese Klasse wird für kryptografische Operationen verwendet.

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

Vererbung

Object

AsymmetricAlgorithm

ECAlgorithm

ECDiffieHellman

ECDiffieHellmanCng

Beispiele

Das folgende Beispiel zeigt, wie Sie die ECDiffieHellmanCng -Klasse zum Einrichten eines Schlüsselaustauschs verwenden und wie Sie diesen Schlüssel verwenden, um eine Nachricht zu verschlüsseln, die über einen öffentlichen Kanal gesendet und vom Empfänger entschlüsselt werden kann.

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

Hinweise

Die ECDiffieHellmanCng -Klasse ermöglicht es zwei Parteien, private Schlüsselmaterial auszutauschen, auch wenn sie über einen öffentlichen Kanal kommunizieren. Beide Parteien können denselben Geheimwert berechnen, der in den verwalteten Diffie-Hellman Klassen als geheime Vereinbarung bezeichnet wird. Die geheime Vereinbarung kann dann für eine Vielzahl von Zwecken verwendet werden, einschließlich als symmetrischer Schlüssel. Anstatt jedoch die geheime Vereinbarung direkt offen zu legen, führt die ECDiffieHellmanCng Klasse eine Nachbearbeitung der Vereinbarung durch, bevor sie den Wert bereitstellt. Diese Nachverarbeitung wird als Schlüsselableitungsfunktion (Key Derivation Function, KDF) bezeichnet. Sie können auswählen, welche KDF Sie verwenden möchten, und ihre Parameter über einen Satz von Eigenschaften für die Instanz des Diffie-Hellman-Objekts festlegen.

Schlüsselableitungsfunktion	Eigenschaften
Hash	HashAlgorithm – Der Hashalgorithmus, der zum Verarbeiten der Geheimvereinbarung verwendet wird. SecretPrepend – Ein optionales Bytearray, das der geheimen Vereinbarung vor dem Hashing vorangestellt werden soll. SecretAppend – Ein optionales Bytearray, das vor dem Hashen an die Geheimvereinbarung angefügt werden soll.
Hmac	HashAlgorithm – Der Hashalgorithmus, der zum Verarbeiten der Geheimvereinbarung verwendet wird. SecretPrepend– Ein optionales Bytearray, das der geheimen Vereinbarung vor dem Hashing vorangestellt werden soll. SecretAppend – Ein optionales Bytearray, das vor dem Hashen an die Geheimvereinbarung angefügt werden soll.
Tls	Label - Die Bezeichnung für Schlüsselableitung. Seed - Der Seed für die Schlüsselableitung.

Das Ergebnis der Übergabe der Geheimvereinbarung über die Schlüsselableitungsfunktion ist ein Bytearray, das als Schlüsselmaterial für Ihre Anwendung verwendet werden kann. Die Anzahl der generierten Bytes des generierten Schlüsselmaterials hängt von der Schlüsselableitungsfunktion ab. SHA-256 generiert beispielsweise 256 Bits Schlüsselmaterial, während SHA-512 512 Schlüsselmaterial generiert. Der grundlegende Ablauf eines ECDH-Schlüsselaustauschs ist wie folgt:

1. Alice und Bob erstellen ein Schlüsselpaar, das für den Diffie-Hellman Schlüsselaustauschvorgang verwendet werden soll

2. Alice und Bob konfigurieren die KDF mithilfe von Parametern, für die sie sich einigen.

3. Alice sendet Bob ihren öffentlichen Schlüssel.

4. Bob sendet Alice seinen öffentlichen Schlüssel.

5. Alice und Bob verwenden die öffentlichen Schlüssel des anderen, um die geheime Vereinbarung zu generieren, und wenden die KDF auf die geheime Vereinbarung an, um Schlüsselmaterial zu generieren.

Konstruktoren

ECDiffieHellmanCng()	Initialisiert eine neue Instanz der ECDiffieHellmanCng-Klasse mit einem zufällig generierten Schlüsselpaar.
ECDiffieHellmanCng(CngKey)	Initialisiert eine neue Instanz der ECDiffieHellmanCng-Klasse unter Verwendung des angegebenen CngKey-Objekts.
ECDiffieHellmanCng(ECCurve)	Erstellt eine neue Instanz der ECDiffieHellmanCng-Klasse, deren Paar aus öffentlichem und privatem Schlüssel über die angegebene Kurve generiert wird.
ECDiffieHellmanCng(Int32)	Initialisiert eine neue Instanz der ECDiffieHellmanCng-Klasse mit einem zufällig erzeugten Schlüsselpaar mit der angegebenen Schlüsselgröße.

Felder

KeySizeValue	Stellt die Größe des vom asymmetrischen Algorithmus verwendeten Schlüsselmodulos in Bits dar. (Geerbt von AsymmetricAlgorithm)
LegalKeySizesValue	Gibt die vom asymmetrischen Algorithmus unterstützten Schlüsselgrößen an. (Geerbt von AsymmetricAlgorithm)

Eigenschaften

HashAlgorithm	Ruft den Hashalgorithmus ab, der zur Generierung des Schlüsselmaterials verwendet wird, oder legt diesen fest.
HmacKey	Ruft den HMAC (Hash-based Message Authentication Code)-Schlüssel ab, mit dem das Schlüsselmaterial abgeleitet wird, oder legt diesen fest.
Key	Gibt den CngKey an, der vom aktuellen Objekt für kryptografische Operationen verwendet wird.
KeyDerivationFunction	Ruft die Schlüsselableitungsfunktion für die ECDiffieHellmanCng-Klasse ab oder legt diese fest.
KeyExchangeAlgorithm	Ruft den Namen des Algorithmus für den Schlüsselaustausch ab. (Geerbt von ECDiffieHellman)
KeySize	Ruft die Größe des vom asymmetrischen Algorithmus verwendeten Schlüsselmodulos in Bits ab oder legt diese fest.
Label	Ruft die für die Schlüsselableitung verwendete Bezeichnung ab oder legt diese fest.
LegalKeySizes	Ruft die vom asymmetrischen Algorithmus unterstützten Schlüsselgrößen ab.
PublicKey	Ruft den öffentlichen Schlüssel ab, der von einem anderen ECDiffieHellmanCng-Objekt zum Generieren eines gemeinsamen Geheimvertrags verwendet werden kann.
SecretAppend	Ruft einen Wert ab, der beim Generieren des Schlüsselmaterials an den Geheimvertrag angefügt wird, oder legt diesen Wert fest.
SecretPrepend	Ruft einen Wert ab, der beim Ableiten des Schlüsselmaterials am Anfang des Geheimvertrags eingefügt wird, oder legt diesen Wert fest.
Seed	Ruft den Startwert ab, der zum Ableiten des Schlüsselmaterials verwendet wird, oder legt diesen Wert fest.
SignatureAlgorithm	Ruft den Namen des Signaturalgorithmus ab. (Geerbt von ECDiffieHellman)
UseSecretAgreementAsHmacKey	Ruft einen Wert ab, der angibt, ob der Geheimvertrag als HMAC (Hash-based Message Authentication Code)-Schlüssel zur Ableitung von Schlüsselmaterial verwendet wird.

Methoden

Clear()	Gibt alle von der AsymmetricAlgorithm-Klasse verwendeten Ressourcen frei. (Geerbt von AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)	Führt die Schlüsselableitung mithilfe eines angegebenen Hashalgorithmus aus (Geerbt von ECDiffieHellman)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])	Führt die Schlüsselableitung mithilfe eines angegebenen Hashalgorithmus mit optionalen vorangestellten oder angefügten Daten aus.
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])	Führt die Schlüsselableitung mithilfe eines angegebenen HMAC-Algorithmus (Hash-based Message Authentication Code, Hash-Nachrichtenauthentifizierungscode) aus. (Geerbt von ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])	Führt die Schlüsselableitung mithilfe eines angegebenen HMAC-Algorithmus (Hash-based Message Authentication Code, Hash-Nachrichtenauthentifizierungscode) mit optionalen vorangestellten oder angefügten Daten aus.
DeriveKeyMaterial(CngKey)	Leitet das Schlüsselmaterial ab, das aus dem Geheimvertrag zweier Seiten generiert wird, und erwartet ein CngKey-Objekt, das den öffentlichen Schlüssel der anderen Seite enthält.
DeriveKeyMaterial(ECDiffieHellmanPublicKey)	Leitet das Schlüsselmaterial ab, das aus dem Geheimvertrag zweier Seiten generiert wird, und erwartet ein ECDiffieHellmanPublicKey-Objekt, das den öffentlichen Schlüssel der anderen Seite enthält.
DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])	Führt eine Schlüsselableitung mithilfe der Pseudozufallsfunktion von TLS 1.1 (Transport Layer Security) durch.
DeriveRawSecretAgreement(ECDiffieHellmanPublicKey)	Leiten Sie rohes Schlüsselmaterial ab. (Geerbt von ECDiffieHellman)
DeriveSecretAgreementHandle(CngKey)	Ruft ein Handle für den Geheimvertrag ab, der zwischen zwei Seiten generiert wird, und erwartet ein CngKey-Objekt, das den öffentlichen Schlüssel der anderen Seite enthält.
DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey)	Ruft ein Handle für den Geheimvertrag ab, der zwischen zwei Seiten generiert wird, und erwartet ein ECDiffieHellmanPublicKey-Objekt, das den öffentlichen Schlüssel der anderen Seite enthält.
Dispose()	Gibt alle von der aktuellen Instanz der AsymmetricAlgorithm-Klasse verwendeten Ressourcen frei. (Geerbt von AsymmetricAlgorithm)
Dispose(Boolean)	Gibt die von der AsymmetricAlgorithm-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. (Geerbt von AsymmetricAlgorithm)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
ExportECPrivateKey()	Exportiert den aktuellen Schlüssel im ECPrivateKey-Format. (Geerbt von ECDiffieHellman)
ExportECPrivateKeyPem()	Exportiert den aktuellen Schlüssel im ECPrivateKey-Format, PEM-codiert. (Geerbt von ECAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Exportiert den aktuellen Schlüssel in das Format „PKCS#8 EncryptedPrivateKeyInfo“ mit einem bytebasierten Kennwort.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Exportiert den aktuellen Schlüssel in das Format „PKCS#8 EncryptedPrivateKeyInfo“ mit einem zeichenbasierten Kennwort.
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	Exportiert den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem bytebasierten Kennwort, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	Exportiert den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem charbasierten Kennwort, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)	Exportiert die Schlüssel- und expliziten Kurvenparameter, die vom ECCurve-Objekt verwendet werden, in ein ECParameters-Objekt.
ExportParameters(Boolean)	Exportiert den vom ECCurve-Objekt verwendeten Schlüssel in ein ECParameters-Objekt.
ExportPkcs8PrivateKey()	Exportiert den aktuellen Schlüssel im Format „PKCS#8 PrivateKeyInfo“. (Geerbt von AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Exportiert den aktuellen Schlüssel im PKCS#8 PrivateKeyInfo-Format, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()	Exportiert den Teil mit dem öffentlichen Schlüssel des aktuellen Schlüssels in das Format „X.509 SubjectPublicKeyInfo“. (Geerbt von AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Exportiert den öffentlichen Schlüsselteil des aktuellen Schlüssels im X.509 SubjectPublicKeyInfo-Format, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
FromXmlString(String)	Diese Methode löst in allen Fällen aus. (Geerbt von ECDiffieHellman)
FromXmlString(String, ECKeyXmlFormat)	Veraltet. Deserialisiert die Schlüsselinformationen aus einer XML-Zeichenfolge mit dem angegebenen Format.
GenerateKey(ECCurve)	Generiert ein neues kurzlebiges Paar aus privatem und öffentlichem Schlüssel für die angegebene Kurve.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32)	Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer ECPrivateKey-Struktur und ersetzt dabei die Schlüssel für dieses Objekt. (Geerbt von ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer PKCS#8-EncryptedPrivateKeyInfo-Struktur nach der Entschlüsselung mit einem bytebasierten Kennwort und ersetzt die Schlüssel für dieses Objekt.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer PKCS#8-EncryptedPrivateKeyInfo-Struktur nach der Entschlüsselung mit einem zeichenbasierten Kennwort und ersetzt die Schlüssel für dieses Objekt.
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)	Importiert einen verschlüsselten, mit RFC 7468 PEM-codierten privaten Schlüssel und ersetzt die Schlüssel für dieses Objekt. (Geerbt von ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Importiert einen verschlüsselten, mit RFC 7468 PEM-codierten privaten Schlüssel und ersetzt die Schlüssel für dieses Objekt. (Geerbt von ECDiffieHellman)
ImportFromPem(ReadOnlySpan<Char>)	Importiert einen mit RFC 7468 PEM-codierten Schlüssel und ersetzt die Schlüssel für dieses Objekt. (Geerbt von ECDiffieHellman)
ImportParameters(ECParameters)	Importiert die angegebenen Parameter für ein ECCurve-Objekt als Schlüssel in die Kurveninstanz.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer PKCS#8-PrivateKeyInfo-Struktur nach der Entschlüsselung und ersetzt die Schlüssel für dieses Objekt.
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)	Importiert den öffentlichen Schlüssel aus einer X.509-SubjectPublicKeyInfo-Struktur nach der Entschlüsselung und ersetzt dabei die Schlüssel für dieses Objekt. (Geerbt von ECDiffieHellman)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
ToXmlString(Boolean)	Diese Methode löst in allen Fällen aus. (Geerbt von ECDiffieHellman)
ToXmlString(ECKeyXmlFormat)	Veraltet. Serialisiert die Schlüsselinformationen in eine XML-Zeichenfolge mit dem angegebenen Format.
TryExportECPrivateKey(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im ECPrivateKey-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von ECDiffieHellman)
TryExportECPrivateKeyPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten ECPrivateKey-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von ECAlgorithm)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#8-EncryptedPrivateKeyInfo-Format mit einem bytebasierten Kennwort in einen bereitgestellten Puffer zu exportieren.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#8-EncryptedPrivateKeyInfo-Format mit einem zeichenbasierten Kennwort in einen bereitgestellten Puffer zu exportieren.
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem bytebasierten Kennwort( PEM-codiert) zu exportieren. (Geerbt von AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	Exportiert den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem charbasierten Kennwort, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#8-PrivateKeyInfo-Format in einen bereitgestellten Puffer zu exportieren.
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten PKCS#8 PrivateKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von AsymmetricAlgorithm)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im X.509-SubjectPublicKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von ECDiffieHellman)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten X.509 SubjectPublicKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von AsymmetricAlgorithm)