ECDiffieHellmanCng ECDiffieHellmanCng ECDiffieHellmanCng ECDiffieHellmanCng Class

Definition

Stellt eine CNG (Cryptography Next Generation)-Implementierung des ECDH (Elliptic Curve Diffie-Hellman)-Algorithmus bereit.Provides a Cryptography Next Generation (CNG) implementation of the Elliptic Curve Diffie-Hellman (ECDH) algorithm. Diese Klasse wird für kryptografische Operationen verwendet.This class is used to perform cryptographic operations.

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

Beispiele

Im folgenden Beispiel wird gezeigt, wie die ECDiffieHellmanCng -Klasse verwendet wird, um einen Schlüsselaustausch einzurichten, und wie dieser Schlüssel zum Verschlüsseln einer Nachricht verwendet wird, die über einen öffentlichen Kanal gesendet und vom Empfänger entschlüsselt werden kann.The following example shows how to use the ECDiffieHellmanCng class to establish a key exchange and how to use that key to encrypt a message that can be sent over a public channel and decrypted by the receiver.

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 k = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob);
            byte[] aliceKey = alice.DeriveKeyMaterial(CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob));
            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 'Alice

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 'Bob 

Hinweise

Die ECDiffieHellmanCng -Klasse ermöglicht zwei Parteien das Austauschen von privatem Schlüsselmaterial, auch wenn Sie über einen öffentlichen Kanal kommunizieren.The ECDiffieHellmanCng class enables two parties to exchange private key material even if they are communicating through a public channel. Beide Parteien können denselben geheimen Wert berechnen, der in den verwalteten Diffie-Hellman-Klassen als geheimer Vertrag bezeichnet wird.Both parties can calculate the same secret value, which is referred to as the secret agreement in the managed Diffie-Hellman classes. Der geheime Vertrag kann dann für eine Vielzahl von Zwecken verwendet werden, einschließlich als symmetrischer Schlüssel.The secret agreement can then be used for a variety of purposes, including as a symmetric key. Anstatt jedoch die geheime Vereinbarung direkt verfügbar zu machen, führt ECDiffieHellmanCng die-Klasse vor der Bereitstellung des-Werts einige Nachbearbeitung der Vereinbarung durch.However, instead of exposing the secret agreement directly, the ECDiffieHellmanCng class does some post-processing on the agreement before providing the value. Diese nach Verarbeitung wird als schlüsselabderivationsfunktion (KDF) bezeichnet. Sie können auswählen, welche KDF Sie verwenden möchten, und die zugehörigen Parameter über einen Satz von Eigenschaften für die Instanz des Diffie-Hellman-Objekts festlegen.This post processing is referred to as the key derivation function (KDF); you can select which KDF you want to use and set its parameters through a set of properties on the instance of the Diffie-Hellman object.

SchlüsselabderivationsfunktionKey derivation function EigenschaftenProperties
Hash HashAlgorithm-Der Hash Algorithmus, der verwendet wird, um den geheimen Vertrag zu verarbeiten.HashAlgorithm - The hash algorithm that is used to process the secret agreement.

SecretPrepend: Ein optionales Bytearray, das vor dem Hashwert der geheimen Vereinbarung vorangesteht wird.SecretPrepend - An optional byte array to prepend to the secret agreement before hashing it.

SecretAppend: Ein optionales Bytearray, das dem geheimen Vertrag vor dem Hashwert angefügt wird.SecretAppend - An optional byte array to append to the secret agreement before hashing it.
Hmac HashAlgorithm-Der Hash Algorithmus, der verwendet wird, um den geheimen Vertrag zu verarbeiten.HashAlgorithm - The hash algorithm that is used to process the secret agreement.

SecretPrepend: Ein optionales Bytearray, das vor dem Hashwert der geheimen Vereinbarung vorangesteht wird.SecretPrepend- An optional byte array to prepend to the secret agreement before hashing it.

SecretAppend: Ein optionales Bytearray, das dem geheimen Vertrag vor dem Hashwert angefügt wird.SecretAppend - An optional byte array to append to the secret agreement before hashing it.
Tls Label: Bezeichnung für die Schlüssel Ableitung.Label - The label for key derivation.

Seed: Der Ausgangswert für die Schlüssel Ableitung.Seed - The seed for key derivation.

Das Ergebnis der Übergabe der geheimen Vereinbarung über die Schlüssel abderivations Funktion ist ein Bytearray, das als Schlüsselmaterial für Ihre Anwendung verwendet werden kann.The result of passing the secret agreement through the key derivation function is a byte array that may be used as key material for your application. Die Anzahl der Bytes des generierten Schlüssel Materials ist von der schlüsselabderivationsfunktion abhängig. beispielsweise generiert SHA-256 256 Bits von Schlüsselmaterial, während SHA-512 512 Bits von Schlüsselmaterial generiert. Der grundlegende Ablauf eines ECDH-Schlüssel Austauschs lautet wie folgt:The number of bytes of key material generated is dependent on the key derivation function; for example, SHA-256 will generate 256 bits of key material, whereas SHA-512 will generate 512 bits of key material.The basic flow of an ECDH key exchange is as follows:

  1. Alice und Bob erstellen ein Schlüsselpaar für die Verwendung für den Diffie-Hellman-Schlüsselaustausch Vorgang.Alice and Bob create a key pair to use for the Diffie-Hellman key exchange operation

  2. Alice und Bob konfigurieren die KDF mit den Parametern, die für die Zustimmung verwendet werden.Alice and Bob configure the KDF using parameters the agree on.

  3. Alice sendet Bob ihren öffentlichen Schlüssel.Alice sends Bob her public key.

  4. Bob sendet Alice seinen öffentlichen Schlüssel.Bob sends Alice his public key.

  5. Alice und Bob verwenden die öffentlichen Schlüssel der anderen zum Generieren der geheimen Vereinbarung und wenden die KDF auf den geheimen Vertrag an, um Schlüsselmaterial zu generieren.Alice and Bob use each other's public keys to generate the secret agreement, and apply the KDF to the secret agreement to generate key material.

Konstruktoren

ECDiffieHellmanCng() ECDiffieHellmanCng() ECDiffieHellmanCng() ECDiffieHellmanCng()

Initialisiert eine neue Instanz der ECDiffieHellmanCng-Klasse mit einem zufällig generierten Schlüsselpaar.Initializes a new instance of the ECDiffieHellmanCng class with a random key pair.

ECDiffieHellmanCng(CngKey) ECDiffieHellmanCng(CngKey) ECDiffieHellmanCng(CngKey) ECDiffieHellmanCng(CngKey)

Initialisiert eine neue Instanz der ECDiffieHellmanCng-Klasse unter Verwendung des angegebenen CngKey-Objekts.Initializes a new instance of the ECDiffieHellmanCng class by using the specified CngKey object.

ECDiffieHellmanCng(ECCurve) ECDiffieHellmanCng(ECCurve) ECDiffieHellmanCng(ECCurve) ECDiffieHellmanCng(ECCurve)

Erstellt eine neue Instanz der ECDiffieHellmanCng-Klasse, deren Paar aus öffentlichem und privatem Schlüssel über die angegebene Kurve generiert wird.Creates a new instance of the ECDiffieHellmanCng class whose public/private key pair is generated over the specified curve.

ECDiffieHellmanCng(Int32) ECDiffieHellmanCng(Int32) ECDiffieHellmanCng(Int32) ECDiffieHellmanCng(Int32)

Initialisiert eine neue Instanz der ECDiffieHellmanCng-Klasse mit einem zufällig erzeugten Schlüsselpaar mit der angegebenen Schlüsselgröße.Initializes a new instance of the ECDiffieHellmanCng class with a random key pair, using the specified key size.

Eigenschaften

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

Ruft den Hashalgorithmus ab, der zur Generierung des Schlüsselmaterials verwendet wird, oder legt diesen fest.Gets or sets the hash algorithm to use when generating key material.

HmacKey HmacKey HmacKey HmacKey

Ruft den HMAC (Hash-based Message Authentication Code)-Schlüssel ab, mit dem das Schlüsselmaterial abgeleitet wird, oder legt diesen fest.Gets or sets the Hash-based Message Authentication Code (HMAC) key to use when deriving key material.

Key Key Key Key

Gibt den CngKey an, der vom aktuellen Objekt für kryptografische Operationen verwendet wird.Specifies the CngKey that is used by the current object for cryptographic operations.

KeyDerivationFunction KeyDerivationFunction KeyDerivationFunction KeyDerivationFunction

Ruft die Schlüsselableitungsfunktion für die ECDiffieHellmanCng-Klasse ab oder legt diese fest.Gets or sets the key derivation function for the ECDiffieHellmanCng class.

KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm

Ruft den Namen des Algorithmus für den Schlüsselaustausch ab.Gets the name of the key exchange algorithm.

(Inherited from ECDiffieHellman)
KeySize KeySize KeySize KeySize
Label Label Label Label

Ruft die für die Schlüsselableitung verwendete Bezeichnung ab oder legt diese fest.Gets or sets the label value that is used for key derivation.

LegalKeySizes LegalKeySizes LegalKeySizes LegalKeySizes
PublicKey PublicKey PublicKey PublicKey

Ruft den öffentlichen Schlüssel ab, der von einem anderen ECDiffieHellmanCng-Objekt zum Generieren eines gemeinsamen Geheimvertrags verwendet werden kann.Gets the public key that can be used by another ECDiffieHellmanCng object to generate a shared secret agreement.

SecretAppend SecretAppend SecretAppend SecretAppend

Ruft einen Wert ab, der beim Generieren des Schlüsselmaterials an den Geheimvertrag angefügt wird, oder legt diesen Wert fest.Gets or sets a value that will be appended to the secret agreement when generating key material.

SecretPrepend SecretPrepend SecretPrepend SecretPrepend

Ruft einen Wert ab, der beim Ableiten des Schlüsselmaterials am Anfang des Geheimvertrags eingefügt wird, oder legt diesen Wert fest.Gets or sets a value that will be added to the beginning of the secret agreement when deriving key material.

Seed Seed Seed Seed

Ruft den Startwert ab, der zum Ableiten des Schlüsselmaterials verwendet wird, oder legt diesen Wert fest.Gets or sets the seed value that will be used when deriving key material.

SignatureAlgorithm SignatureAlgorithm SignatureAlgorithm SignatureAlgorithm

Ruft den Namen des Signaturalgorithmus ab.Gets the name of the signature algorithm.

(Inherited from ECDiffieHellman)
UseSecretAgreementAsHmacKey UseSecretAgreementAsHmacKey UseSecretAgreementAsHmacKey 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.Gets a value that indicates whether the secret agreement is used as a Hash-based Message Authentication Code (HMAC) key to derive key material.

Methoden

Clear() Clear() Clear() Clear()

Gibt alle von der AsymmetricAlgorithm-Klasse verwendeten Ressourcen frei.Releases all resources used by the AsymmetricAlgorithm class.

(Inherited from AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)

Leitet Bytes ab, die mithilfe einer Hashfunktion als Schlüssel verwendet werden können. Der öffentliche Schlüssel einer anderen Partei und der Name des Hashalgorithmus werden übergeben.Derives bytes that can be used as a key using a hash function, given another party's public key and hash algorithm's name.

(Inherited from ECDiffieHellman)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[]) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[]) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[]) DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])

Leitet Bytes ab, die mithilfe einer Hashfunktion als Schlüssel verwendet werden können. Der öffentliche Schlüssel einer anderen Partei, der Name des Hashalgorithmus, ein vorangestellter und ein angefügter Wert werden übergeben.Derives bytes that can be used as a key using a hash function, given another party's public key, hash algorithm's name, a prepend value and an append value.

DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])

Leitet Bytes ab, die als Schlüssel mit einem Hash-based Message Authentication Code (HMAC) verwendet werden können.Derives bytes that can be used as a key using a Hash-based Message Authentication Code (HMAC).

(Inherited from ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[]) DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])

Leitet Bytes ab, die als Schlüssel mit einem Hash-based Message Authentication Code (HMAC) verwendet werden können.Derives bytes that can be used as a key using a Hash-based Message Authentication Code (HMAC).

DeriveKeyMaterial(CngKey) DeriveKeyMaterial(CngKey) DeriveKeyMaterial(CngKey) 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.Derives the key material that is generated from the secret agreement between two parties, given a CngKey object that contains the second party's public key.

DeriveKeyMaterial(ECDiffieHellmanPublicKey) DeriveKeyMaterial(ECDiffieHellmanPublicKey) DeriveKeyMaterial(ECDiffieHellmanPublicKey) 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.Derives the key material that is generated from the secret agreement between two parties, given an ECDiffieHellmanPublicKey object that contains the second party's public key.

DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[]) DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[]) DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[]) DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])

Leitet Bytes ab, die mithilfe eines Transport Layer Security-Pseudo-Random Function-Ableitungsalgorithmus (TLS, PRF) als Schlüssel verwendet werden können.Derives bytes that can be used as a key using a Transport Layer Security (TLS) Pseudo-Random Function (PRF) derivation algorithm.

DeriveSecretAgreementHandle(CngKey) DeriveSecretAgreementHandle(CngKey) DeriveSecretAgreementHandle(CngKey) 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.Gets a handle to the secret agreement generated between two parties, given a CngKey object that contains the second party's public key.

DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey) DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey) DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey) 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.Gets a handle to the secret agreement generated between two parties, given an ECDiffieHellmanPublicKey object that contains the second party's public key.

Dispose() Dispose() Dispose() Dispose()

Gibt alle von der aktuellen Instanz der AsymmetricAlgorithm-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the AsymmetricAlgorithm class.

(Inherited from AsymmetricAlgorithm)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt die von der AsymmetricAlgorithm-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei.Releases the unmanaged resources used by the AsymmetricAlgorithm class and optionally releases the managed resources.

(Inherited from AsymmetricAlgorithm)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
ExportECPrivateKey() ExportECPrivateKey() ExportECPrivateKey() ExportECPrivateKey()

Exportiert den aktuellen Schlüssel im ECPrivateKey-Format.Exports the current key in the ECPrivateKey format.

(Inherited from ECDiffieHellman)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

Exportiert den aktuellen Schlüssel in das Format „PKCS#8 EncryptedPrivateKeyInfo“ mit einem bytebasierten Kennwort.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a byte-based password.

(Inherited from AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters) ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

Exportiert den aktuellen Schlüssel in das Format „PKCS#8 EncryptedPrivateKeyInfo“ mit einem zeichenbasierten Kennwort.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a char-based password.

(Inherited from AsymmetricAlgorithm)
ExportExplicitParameters(Boolean) ExportExplicitParameters(Boolean) ExportExplicitParameters(Boolean) ExportExplicitParameters(Boolean)

Exportiert die Schlüssel- und expliziten Kurvenparameter, die vom ECCurve-Objekt verwendet werden, in ein ECParameters-Objekt.Exports the key and explicit curve parameters used by the ECCurve object into an ECParameters object.

ExportParameters(Boolean) ExportParameters(Boolean) ExportParameters(Boolean) ExportParameters(Boolean)

Exportiert den vom ECCurve-Objekt verwendeten Schlüssel in ein ECParameters-Objekt.Exports the key used by the ECCurve object into an ECParameters object.

ExportPkcs8PrivateKey() ExportPkcs8PrivateKey() ExportPkcs8PrivateKey() ExportPkcs8PrivateKey()

Exportiert den aktuellen Schlüssel im Format „PKCS#8 PrivateKeyInfo“.Exports the current key in the PKCS#8 PrivateKeyInfo format.

(Inherited from AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo() ExportSubjectPublicKeyInfo() ExportSubjectPublicKeyInfo() ExportSubjectPublicKeyInfo()

Exportiert den Teil mit dem öffentlichen Schlüssel des aktuellen Schlüssels in das Format „X.509 SubjectPublicKeyInfo“.Exports the public-key portion of the current key in the X.509 SubjectPublicKeyInfo format.

(Inherited from AsymmetricAlgorithm)
FromXmlString(String) FromXmlString(String) FromXmlString(String) FromXmlString(String)

Diese Methode ist nicht implementiert.This method is not implemented.

FromXmlString(String, ECKeyXmlFormat) FromXmlString(String, ECKeyXmlFormat) FromXmlString(String, ECKeyXmlFormat) FromXmlString(String, ECKeyXmlFormat)

Deserialisiert die Schlüsselinformationen aus einer XML-Zeichenfolge mit dem angegebenen Format.Deserializes the key information from an XML string by using the specified format.

GenerateKey(ECCurve) GenerateKey(ECCurve) GenerateKey(ECCurve) GenerateKey(ECCurve)

Generiert ein neues kurzlebiges Paar aus privatem und öffentlichem Schlüssel für die angegebene Kurve.Generates a new ephemeral public/private key pair for the specified curve.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32) ImportECPrivateKey(ReadOnlySpan<Byte>, Int32) ImportECPrivateKey(ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from an ECPrivateKey structure, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a byte-based password, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32) ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a char-based password, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportParameters(ECParameters) ImportParameters(ECParameters) ImportParameters(ECParameters) ImportParameters(ECParameters)

Importiert die angegebenen Parameter für ein ECCurve-Objekt als Schlüssel in die Kurveninstanz.Imports the specified parameters for an ECCurve object as a key into the current instance.

ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32) ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32) ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32) 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.Imports the public/private keypair from a PKCS#8 PrivateKeyInfo structure after decryption, replacing the keys for this object.

(Inherited from ECDiffieHellman)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32) ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32) ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32) 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.Imports the public key from an X.509 SubjectPublicKeyInfo structure after decryption, replacing the keys for this object.

(Inherited from ECDiffieHellman)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)
ToXmlString(Boolean) ToXmlString(Boolean) ToXmlString(Boolean) ToXmlString(Boolean)

Diese Methode ist nicht implementiert.This method is not implemented.

ToXmlString(ECKeyXmlFormat) ToXmlString(ECKeyXmlFormat) ToXmlString(ECKeyXmlFormat) ToXmlString(ECKeyXmlFormat)

Serialisiert die Schlüsselinformationen in eine XML-Zeichenfolge mit dem angegebenen Format.Serializes the key information to an XML string by using the specified format.

TryExportECPrivateKey(Span<Byte>, Int32) TryExportECPrivateKey(Span<Byte>, Int32) TryExportECPrivateKey(Span<Byte>, Int32) TryExportECPrivateKey(Span<Byte>, Int32)

Versucht, den aktuellen Schlüssel im ECPrivateKey-Format in einen bereitgestellten Puffer zu exportieren.Attempts to export the current key in the ECPrivateKey format into a provided buffer.

(Inherited from ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32) 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.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a byte-based password.

(Inherited from ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32) TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32) 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.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a char-based password.

(Inherited from ECDiffieHellman)
TryExportPkcs8PrivateKey(Span<Byte>, Int32) TryExportPkcs8PrivateKey(Span<Byte>, Int32) TryExportPkcs8PrivateKey(Span<Byte>, Int32) TryExportPkcs8PrivateKey(Span<Byte>, Int32)

Versucht, den aktuellen Schlüssel im PKCS#8-PrivateKeyInfo-Format in einen bereitgestellten Puffer zu exportieren.Attempts to export the current key in the PKCS#8 PrivateKeyInfo format into a provided buffer.

(Inherited from ECDiffieHellman)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32) TryExportSubjectPublicKeyInfo(Span<Byte>, Int32) TryExportSubjectPublicKeyInfo(Span<Byte>, Int32) TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)

Versucht, den aktuellen Schlüssel im X.509-SubjectPublicKeyInfo-Format in einen bereitgestellten Puffer zu exportieren.Attempts to export the current key in the X.509 SubjectPublicKeyInfo format into a provided buffer.

(Inherited from ECDiffieHellman)

Felder

KeySizeValue KeySizeValue KeySizeValue KeySizeValue

Stellt die Größe des vom asymmetrischen Algorithmus verwendeten Schlüsselmodulos in Bits dar.Represents the size, in bits, of the key modulus used by the asymmetric algorithm.

(Inherited from AsymmetricAlgorithm)
LegalKeySizesValue LegalKeySizesValue LegalKeySizesValue LegalKeySizesValue

Gibt die vom asymmetrischen Algorithmus unterstützten Schlüsselgrößen an.Specifies the key sizes that are supported by the asymmetric algorithm.

(Inherited from AsymmetricAlgorithm)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Eine Beschreibung dieses Elements finden Sie unter Dispose().For a description of this member, see Dispose().

(Inherited from AsymmetricAlgorithm)

Gilt für: