AsymmetricKeyAlgorithmProvider Klasse

Referenz

Definition

Namespace:: Windows.Security.Cryptography.Core

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Bearbeiten

Stellt einen Anbieter von asymmetrischen (öffentlichen) Schlüsselalgorithmen dar. Weitere Informationen finden Sie unter Kryptografische Schlüssel.

public ref class AsymmetricKeyAlgorithmProvider sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class AsymmetricKeyAlgorithmProvider final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class AsymmetricKeyAlgorithmProvider

Public NotInheritable Class AsymmetricKeyAlgorithmProvider

Vererbung: Object Platform::Object IInspectable AsymmetricKeyAlgorithmProvider

Attribute: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Windows-Anforderungen

Gerätefamilie	Windows 10 (eingeführt in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (eingeführt in v1.0)

Beispiele

Da die asymmetrische Kryptografie im Vergleich zur symmetrischen Kryptografie deutlich langsamer ist, werden mit ihr nur selten große Datenmengen direkt verschlüsselt. Stattdessen wird sie häufig wie folgt zur Verschlüsselung von Schlüsseln verwendet:

Andrea möchte, dass Sven ihr ausschließlich verschlüsselte Nachrichten sendet.
Andrea erstellt ein Schlüsselpaar aus privatem und öffentlichem Schlüssel, hält ihren privaten Schlüssel geheim und veröffentlicht ihren öffentlichen Schlüssel.
Sven möchte Andrea eine Nachricht senden.
Er erstellt einen symmetrischen Schlüssel.
Mithilfe seines neuen symmetrischen Schlüssels verschlüsselt Sven seine Nachricht an Andrea.
Bob verwendet den öffentlichen Schlüssel von Alice, um seinen symmetrischen Schlüssel zu verschlüsseln.
Sven sendet die verschlüsselte Nachricht und den verschlüsselten symmetrischen Schlüssel an Andrea (codiert).
Andrea entschlüsselt Svens symmetrischen Schlüssel mithilfe ihres privaten Schlüssels (aus dem Schlüsselpaar mit privatem und öffentlichem Schlüssel).
Alice verwendet Bobs symmetrischen Schlüssel, um die Nachricht zu entschlüsseln. Die Aspekte des vorherigen Prozesses, die im Code behandelt werden können, werden im folgenden Beispiel veranschaulicht.


using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;
using Windows.Storage.Streams;

namespace SampleAsymmetricKeyAlgorithmProvider
{
    sealed partial class AsymmetricKeyAlgorithmApp : Application
    {
        static IBuffer buffKeyPair;

        public AsymmetricKeyAlgorithmApp()
        {
            // Initialize the application.
            this.InitializeComponent();

            // Create a symmetric session key.
            String strSymmetricAlgName = SymmetricAlgorithmNames.AesCbc;
            UInt32 symmetricKeyLength = 32;
            IBuffer buffSessionKey;
            this.SampleCreateSymmetricSessionKey(
                strSymmetricAlgName, 
                symmetricKeyLength, 
                out buffSessionKey);

            // Create an asymmetric key pair.
            String strAsymmetricAlgName = AsymmetricAlgorithmNames.RsaPkcs1;
            UInt32 asymmetricKeyLength = 512;
            IBuffer buffPublicKey;
            this.SampleCreateAsymmetricKeyPair(
                strAsymmetricAlgName, 
                asymmetricKeyLength, 
                out buffPublicKey);
 
            // Encrypt the symmetric session key by using the asymmetric public key.
            IBuffer buffEncryptedSessionKey;
            this.SampleAsymmetricEncryptSessionKey(
                strAsymmetricAlgName,
                buffSessionKey,
                buffPublicKey,
                out buffEncryptedSessionKey);

            // Decrypt the symmetric session key by using the asymmetric private key
            // that corresponds to the public key used to encrypt the session key.
            this.SampleAsymmetricDecryptSessionKey(
                strAsymmetricAlgName,
                strSymmetricAlgName,
                buffEncryptedSessionKey);
        }

        public void SampleCreateSymmetricSessionKey(
            string strSymmetricAlgName,
            UInt32 keyLength,
            out IBuffer buffSessionKey)
        {
            // Open a symmetric algorithm provider for the specified algorithm.
            SymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(strSymmetricAlgName);

            // Create a symmetric session key.
            IBuffer keyMaterial = CryptographicBuffer.GenerateRandom(keyLength);
            CryptographicKey sessionKey = objAlg.CreateSymmetricKey(keyMaterial);

            buffSessionKey = keyMaterial;
        }

        public void SampleCreateAsymmetricKeyPair(
            String strAsymmetricAlgName,
            UInt32 keyLength,
            out IBuffer buffPublicKey)
        {
            // Open the algorithm provider for the specified asymmetric algorithm.
            AsymmetricKeyAlgorithmProvider objAlgProv = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(strAsymmetricAlgName);

            // Demonstrate use of the AlgorithmName property (not necessary to create a key pair).
            String strAlgName = objAlgProv.AlgorithmName;

            // Create an asymmetric key pair.
            CryptographicKey keyPair = objAlgProv.CreateKeyPair(keyLength);

            // Export the public key to a buffer for use by others.
            buffPublicKey = keyPair.ExportPublicKey();

            // You should keep your private key (embedded in the key pair) secure. For  
            // the purposes of this example, however, we're just copying it into a
            // static class variable for later use during decryption.
            AsymmetricKeyAlgorithmApp.buffKeyPair = keyPair.Export();
        }
 
        public void SampleAsymmetricEncryptSessionKey(
            String strAsymmetricAlgName,
            IBuffer buffSessionKeyToEncrypt,
            IBuffer buffPublicKey,
            out IBuffer buffEncryptedSessionKey)
        {
            // Open the algorithm provider for the specified asymmetric algorithm.
            AsymmetricKeyAlgorithmProvider objAlgProv = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(strAsymmetricAlgName);

            // Import the public key from a buffer.
            CryptographicKey publicKey = objAlgProv.ImportPublicKey(buffPublicKey);

            // Encrypt the session key by using the public key.
            buffEncryptedSessionKey = CryptographicEngine.Encrypt(publicKey, buffSessionKeyToEncrypt, null);
        }

        public void SampleAsymmetricDecryptSessionKey(
            String strAsymmetricAlgName,
            String strSymmetricAlgName,
            IBuffer buffEncryptedSessionKey)
        {
            // Open the algorithm provider for the specified asymmetric algorithm.
            AsymmetricKeyAlgorithmProvider objAsymmAlgProv = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(strAsymmetricAlgName);

            // Import the public key from a buffer. You should keep your private key
            // secure. For the purposes of this example, however, the private key is
            // just stored in a static class variable.
            CryptographicKey keyPair = objAsymmAlgProv.ImportKeyPair(AsymmetricKeyAlgorithmApp.buffKeyPair);

            // Use the private key embedded in the key pair to decrypt the session key.
            IBuffer buffDecryptedSessionKey = CryptographicEngine.Decrypt(keyPair, buffEncryptedSessionKey, null);

            // Convert the decrypted session key into a CryptographicKey object that
            // can be used to decrypt the message that it previously encrypted (not shown).
            SymmetricKeyAlgorithmProvider objSymmAlgProv = SymmetricKeyAlgorithmProvider.OpenAlgorithm(strSymmetricAlgName);
            CryptographicKey sessionKey = objSymmAlgProv.CreateSymmetricKey(buffDecryptedSessionKey);
        }
    }
}

Hinweise

Sie erstellen ein AsymmetricKeyAlgorithmProvider-Objekt, indem Sie die statische OpenAlgorithm-Methode aufrufen.

Eigenschaften

AlgorithmName

Ruft den Namen des offenen asymmetrischen Algorithmus ab.

Methoden

CreateKeyPair(UInt32)	Erstellt ein öffentliches/privates Schlüsselpaar.
CreateKeyPairWithCurveName(String)	Erstellt ein Öffentliches/Private-Schlüssel-Paar unter Verwendung eines algorithmusischen Kurvennamens.
CreateKeyPairWithCurveParameters(Byte[])	Erstellt mithilfe von Kurvenparametern ein asymmetrisches Paar mit öffentlichem und privatem Schlüssel.
ImportKeyPair(IBuffer)	Importiert ein öffentliches/privates Schlüsselpaar aus einem Puffer.
ImportKeyPair(IBuffer, CryptographicPrivateKeyBlobType)	Importiert ein öffentliches/privates Schlüsselpaar aus einem Puffer im angegebenen Format.
ImportPublicKey(IBuffer)	Importiert einen öffentlichen Schlüssel in einen Puffer.
ImportPublicKey(IBuffer, CryptographicPublicKeyBlobType)	Importiert einen öffentlichen Schlüssel in einen Puffer für ein angegebenes Format.
OpenAlgorithm(String)	Erstellt eine instance der AsymmetricKeyAlgorithmProvider-Klasse und öffnet den angegebenen Algorithmus zur Verwendung.

Gilt für: