ECDiffieHellmanCng Klass

Definition

Namnområde:: System.Security.Cryptography

Sammansättning:: System.Security.Cryptography.dll

Sammansättning:: System.Security.Cryptography.Cng.dll

Sammansättningar:: System.Security.Cryptography.dll, System.Security.Cryptography.Cng.dll

Sammansättning:: System.Core.dll

Källa:: Cng.NotSupported.cs

Källa:: Cng.NotSupported.cs

Källa:: Cng.NotSupported.cs

Källa:: Cng.NotSupported.cs

Källa:: Cng.NotSupported.cs

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Tillhandahåller en CNG-implementering (Cryptography Next Generation) av algoritmen Elliptic Curve Diffie-Hellman (ECDH). Den här klassen används för att utföra kryptografiska åtgärder.

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

Arv: Object

AsymmetricAlgorithm

ECAlgorithm

ECDiffieHellman
ECDiffieHellmanCng

Arv: Object

AsymmetricAlgorithm

ECDiffieHellman
ECDiffieHellmanCng

Exempel

I följande exempel visas hur du använder ECDiffieHellmanCng klassen för att upprätta ett nyckelutbyte och hur du använder den nyckeln för att kryptera ett meddelande som kan skickas via en offentlig kanal och dekrypteras av mottagaren.

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

Kommentarer

Klassen ECDiffieHellmanCng gör det möjligt för två parter att utbyta privat nyckelmaterial även om de kommunicerar via en offentlig kanal. Båda parter kan beräkna samma hemliga värde som det hemliga avtalet i de hanterade Diffie-Hellman klasserna. Det hemliga avtalet kan sedan användas för en mängd olika syften, bland annat som en symmetrisk nyckel. Men i stället för att exponera det hemliga avtalet direkt utför ECDiffieHellmanCng klassen viss efterbearbetning av avtalet innan värdet anges. Den här efterbearbetningen kallas nyckelhärledningsfunktionen (KDF); du kan välja vilken KDF du vill använda och ange dess parametrar via en uppsättning egenskaper på instansen av Diffie-Hellman-objektet.

Nyckelhärledningsfunktion	Egenskaper
Hash	HashAlgorithm – Hash-algoritmen som används för att bearbeta det hemliga avtalet. SecretPrepend – En valfri bytematris som ska förberedas för det hemliga avtalet innan du hashar det. SecretAppend – En valfri bytematris som ska läggas till i det hemliga avtalet innan du hashar det.
Hmac	HashAlgorithm – Hash-algoritmen som används för att bearbeta det hemliga avtalet. SecretPrepend– En valfri bytematris som ska förberedas för det hemliga avtalet innan du hashar det. SecretAppend – En valfri bytematris som ska läggas till i det hemliga avtalet innan du hashar det.
Tls	Label - Etiketten för nyckelhärledning. Seed - Fröet för nyckelhärledning.

Resultatet av att skicka det hemliga avtalet via nyckelhärledningsfunktionen är en bytematris som kan användas som nyckelmaterial för ditt program. Antalet byte av nyckelmaterial som genereras är beroende av nyckelhärledningsfunktionen. SHA-256 genererar till exempel 256 bitar nyckelmaterial, medan SHA-512 genererar 512 bitar nyckelmaterial. Det grundläggande flödet för ett ECDH-nyckelutbyte är följande:

Alice och Bob skapar ett nyckelpar som ska användas för åtgärden Diffie-Hellman nyckelutbyte
Alice och Bob konfigurerar KDF med parametrar som överensstämmde.
Alice skickar sin offentliga nyckel till Bob.
Bob skickar alice sin offentliga nyckel.
Alice och Bob använder varandras offentliga nycklar för att generera det hemliga avtalet och tillämpa KDF på det hemliga avtalet för att generera nyckelmaterial.

Konstruktorer

Name	Description
ECDiffieHellmanCng()	Initierar en ny instans av ECDiffieHellmanCng klassen med ett slumpmässigt nyckelpar.
ECDiffieHellmanCng(CngKey)	Initierar en ny instans av ECDiffieHellmanCng klassen med hjälp av det angivna CngKey objektet.
ECDiffieHellmanCng(ECCurve)	Skapar en ny instans av ECDiffieHellmanCng klassen vars offentliga/privata nyckelpar genereras över den angivna kurvan.
ECDiffieHellmanCng(Int32)	Initierar en ny instans av ECDiffieHellmanCng klassen med ett slumpmässigt nyckelpar med den angivna nyckelstorleken.

Fält

Name	Description
KeySizeValue	Representerar storleken, i bitar, på de nyckelmoduler som används av den asymmetriska algoritmen. (Ärvd från AsymmetricAlgorithm)
LegalKeySizesValue	Anger de nyckelstorlekar som stöds av den asymmetriska algoritmen. (Ärvd från AsymmetricAlgorithm)

Egenskaper

Name	Description
HashAlgorithm	Hämtar eller ställer in hash-algoritmen som ska användas vid generering av nyckelmaterial.
HmacKey	Hämtar eller anger den Hash-baserade HMAC-nyckeln (Message Authentication Code) som ska användas vid härledning av nyckelmaterial.
Key	Anger det CngKey som används av det aktuella objektet för kryptografiska åtgärder.
KeyDerivationFunction	Hämtar eller anger nyckelhärledningsfunktionen för ECDiffieHellmanCng klassen.
KeyExchangeAlgorithm	Hämtar namnet på nyckelutbytesalgoritmen. (Ärvd från ECDiffieHellman)
KeySize	Hämtar eller anger storleken, i bitar, på de nyckelmoduler som används av den asymmetriska algoritmen.
KeySize	Hämtar eller anger storleken, i bitar, på de nyckelmoduler som används av den asymmetriska algoritmen. (Ärvd från AsymmetricAlgorithm)
Label	Hämtar eller anger det etikettvärde som används för nyckelhärledning.
LegalKeySizes	Hämtar de nyckelstorlekar som stöds av den asymmetriska algoritmen.
LegalKeySizes	Hämtar de nyckelstorlekar som stöds av den asymmetriska algoritmen. (Ärvd från AsymmetricAlgorithm)
PublicKey	Hämtar den offentliga nyckeln som kan användas av ett annat ECDiffieHellmanCng objekt för att generera ett delat hemligt avtal.
SecretAppend	Hämtar eller anger ett värde som läggs till i det hemliga avtalet när nyckelmaterial genereras.
SecretPrepend	Hämtar eller anger ett värde som läggs till i början av det hemliga avtalet när nyckelmaterial härleds.
Seed	Hämtar eller anger det startvärde som ska användas vid härledning av nyckelmaterial.
SignatureAlgorithm	Hämtar namnet på signaturalgoritmen. (Ärvd från ECDiffieHellman)
UseSecretAgreementAsHmacKey	Hämtar ett värde som anger om det hemliga avtalet används som en Hash-baserad HMAC-nyckel (Message Authentication Code) för att härleda nyckelmaterial.

Metoder

Name	Description
Clear()	Släpper alla resurser som används av AsymmetricAlgorithm klassen. (Ärvd från AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])	Utför nyckelhärledning med hjälp av en angiven hash-algoritm med valfria förberedda eller bifogade data.
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)	Utför nyckelhärledning med hjälp av en angiven hash-algoritm. (Ärvd från ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])	Utför nyckelhärledning med hjälp av en angiven HMAC-algoritm (Hash-baserad kod för meddelandeautentisering) med valfria förberedda eller bifogade data.
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])	Utför nyckelhärledning med en angiven HMAC-algoritm (Hash-baserad kod för meddelandeautentisering). (Ärvd från ECDiffieHellman)
DeriveKeyMaterial(CngKey)	Härleder det nyckelmaterial som genereras från det hemliga avtalet mellan två parter, givet ett CngKey objekt som innehåller den andra partens offentliga nyckel.
DeriveKeyMaterial(ECDiffieHellmanPublicKey)	Härleder det nyckelmaterial som genereras från det hemliga avtalet mellan två parter, givet ett ECDiffieHellmanPublicKey objekt som innehåller den andra partens offentliga nyckel.
DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])	Utför nyckelhärledning med hjälp av TLS (Transport Layer Security) 1.1 PRF (Pseudo-Random Function).
DeriveRawSecretAgreement(ECDiffieHellmanPublicKey)	Härled råmaterial. (Ärvd från ECDiffieHellman)
DeriveSecretAgreementHandle(CngKey)	Hämtar ett handtag till det hemliga avtal som genererats mellan två parter, givet ett CngKey objekt som innehåller den andra partens offentliga nyckel.
DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey)	Hämtar ett handtag till det hemliga avtal som genereras mellan två parter, givet ett ECDiffieHellmanPublicKey objekt som innehåller den andra partens offentliga nyckel.
Dispose()	Släpper alla resurser som används av den aktuella instansen AsymmetricAlgorithm av klassen. (Ärvd från AsymmetricAlgorithm)
Dispose(Boolean)	Släpper de ohanterade resurser som används av AsymmetricAlgorithm klassen och släpper eventuellt de hanterade resurserna. (Ärvd från AsymmetricAlgorithm)
Equals(Object)	Avgör om det angivna objektet är lika med det aktuella objektet. (Ärvd från Object)
ExportECPrivateKey()	Exporterar den aktuella nyckeln i ECPrivateKey-formatet. (Ärvd från ECDiffieHellman)
ExportECPrivateKeyPem()	Exporterar den aktuella nyckeln i ECPrivateKey-format, PEM-kodad. (Ärvd från ECAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett bytebaserat lösenord.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett bytebaserat lösenord. (Ärvd från AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett teckenbaserat lösenord.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett teckenbaserat lösenord. (Ärvd från AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett bytebaserat lösenord, PEM-kodat. (Ärvd från AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett teckenbaserat lösenord, PEM-kodat. (Ärvd från AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)	Exporterar nyckel- och explicita kurvparametrar som används av ECCurve objektet till ett ECParameters objekt.
ExportParameters(Boolean)	Exporterar nyckeln som används av ECCurve objektet till ett ECParameters objekt.
ExportPkcs8PrivateKey()	Exporterar den aktuella nyckeln i formatet PKCS#8 PrivateKeyInfo. (Ärvd från AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Exporterar den aktuella nyckeln i PKCS#8 PrivateKeyInfo-format, PEM-kodad. (Ärvd från AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()	Exporterar den offentliga delen av den aktuella nyckeln i formatet X.509 SubjectPublicKeyInfo. (Ärvd från AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Exporterar den offentliga delen av den aktuella nyckeln i formatet X.509 SubjectPublicKeyInfo, PEM-kodad. (Ärvd från AsymmetricAlgorithm)
FromXmlString(String, ECKeyXmlFormat)	Föråldrad. Deserialiserar nyckelinformationen från en XML-sträng med det angivna formatet.
FromXmlString(String)	Den här metoden har inte implementerats.
FromXmlString(String)	Den här metoden genererar i alla fall. (Ärvd från ECDiffieHellman)
GenerateKey(ECCurve)	Genererar ett nytt tillfälliga offentligt/privat nyckelpar för den angivna kurvan.
GetHashCode()	Fungerar som standard-hash-funktion. (Ärvd från Object)
GetType()	Hämtar den aktuella instansen Type . (Ärvd från Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32)	Importerar det offentliga/privata nyckelparet från en ECPrivateKey-struktur och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importerar den offentliga/privata keypair från en PKCS#8 EncryptedPrivateKeyInfo-struktur efter dekryptering med ett bytebaserat lösenord och ersätter nycklarna för det här objektet.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importerar den offentliga/privata keypair från en PKCS#8 EncryptedPrivateKeyInfo-struktur efter dekryptering med ett bytebaserat lösenord och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importerar det offentliga/privata nyckelparet från en PKCS#8 EncryptedPrivateKeyInfo-struktur efter dekryptering med ett teckenbaserat lösenord och ersätter nycklarna för det här objektet.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importerar det offentliga/privata nyckelparet från en PKCS#8 EncryptedPrivateKeyInfo-struktur efter dekryptering med ett teckenbaserat lösenord och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)	Importerar en krypterad RFC 7468 PEM-kodad privat nyckel och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Importerar en krypterad RFC 7468 PEM-kodad privat nyckel och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportFromPem(ReadOnlySpan<Char>)	Importerar en RFC 7468 PEM-kodad nyckel och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportParameters(ECParameters)	Importerar de angivna parametrarna för ett ECCurve objekt som en nyckel till den aktuella instansen.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	Importerar den offentliga/privata keypair från en PKCS#8 PrivateKeyInfo-struktur efter dekryptering och ersätter nycklarna för det här objektet.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	Importerar den offentliga/privata keypair från en PKCS#8 PrivateKeyInfo-struktur efter dekryptering och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)	Importerar den offentliga nyckeln från en X.509 SubjectPublicKeyInfo-struktur efter dekryptering och ersätter nycklarna för det här objektet. (Ärvd från ECDiffieHellman)
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
ToString()	Returnerar en sträng som representerar det aktuella objektet. (Ärvd från Object)
ToXmlString(Boolean)	Den här metoden har inte implementerats.
ToXmlString(Boolean)	Den här metoden genererar i alla fall. (Ärvd från ECDiffieHellman)
ToXmlString(ECKeyXmlFormat)	Föråldrad. Serialiserar nyckelinformationen till en XML-sträng med det angivna formatet.
TryExportECPrivateKey(Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i `ECPrivateKey` formatet till en angivet buffert. (Ärvd från ECDiffieHellman)
TryExportECPrivateKeyPem(Span<Char>, Int32)	Försöker exportera den aktuella nyckeln i PEM-kodat ECPrivateKey-format till en angivet buffert. (Ärvd från ECAlgorithm)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo till en angiven buffert med ett bytebaserat lösenord.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo till en angiven buffert med ett bytebaserat lösenord. (Ärvd från ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo till en angiven buffert med hjälp av ett teckenbaserat lösenord.
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo till en angiven buffert med hjälp av ett teckenbaserat lösenord. (Ärvd från ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Försöker exportera den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett bytebaserat lösenord, PEM-kodat. (Ärvd från AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	Exporterar den aktuella nyckeln i formatet PKCS#8 EncryptedPrivateKeyInfo med ett teckenbaserat lösenord, PEM-kodat. (Ärvd från AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i PKCS#8 PrivateKeyInfo-formatet till en angivet buffert.
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i PKCS#8 PrivateKeyInfo-formatet till en angivet buffert. (Ärvd från ECDiffieHellman)
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Försöker exportera den aktuella nyckeln i PEM-kodade PKCS#8 PrivateKeyInfo-format till en angivet buffert. (Ärvd från AsymmetricAlgorithm)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)	Försöker exportera den aktuella nyckeln i formatet X.509 SubjectPublicKeyInfo till en angivet buffert. (Ärvd från ECDiffieHellman)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	Försöker exportera den aktuella nyckeln i PEM-kodat X.509 SubjectPublicKeyInfo-format till en angivet buffert. (Ärvd från AsymmetricAlgorithm)

Explicita gränssnittsimplementeringar

Name	Description
IDisposable.Dispose()	Detta API stöder produktinfrastrukturen och är inte avsett att användas direkt från koden. En beskrivning av den här medlemmen finns i Dispose(). (Ärvd från AsymmetricAlgorithm)

Name

Description

IDisposable.Dispose()

Detta API stöder produktinfrastrukturen och är inte avsett att användas direkt från koden.

En beskrivning av den här medlemmen finns i Dispose().

(Ärvd från AsymmetricAlgorithm)

Gäller för

Feedback

Var den här sidan till hjälp?